drivers/net/e1000/igb_flow.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2016 Intel Corporation
   3  */
   4
   5 #include <sys/queue.h>
   6 #include <stdio.h>
   7 #include <errno.h>
   8 #include <stdint.h>
   9 #include <stdarg.h>
  10
  11 #include <rte_common.h>
  12 #include <rte_interrupts.h>
  13 #include <rte_byteorder.h>
  14 #include <rte_log.h>
  15 #include <rte_debug.h>
  16 #include <rte_pci.h>
  17 #include <rte_ether.h>
  18 #include <rte_ethdev_driver.h>
  19 #include <rte_ethdev_pci.h>
  20 #include <rte_memory.h>
  21 #include <rte_eal.h>
  22 #include <rte_atomic.h>
  23 #include <rte_malloc.h>
  24 #include <rte_dev.h>
  25 #include <rte_flow.h>
  26 #include <rte_flow_driver.h>
  27
  28 #include "e1000_logs.h"
  29 #include "base/e1000_api.h"
  30 #include "e1000_ethdev.h"
  31
  32 #define NEXT_ITEM_OF_PATTERN(item, pattern, index)              \
  33         do {                                                    \
  34                 item = (pattern) + (index);                     \
  35                 while (item->type == RTE_FLOW_ITEM_TYPE_VOID) { \
  36                 (index)++;                                      \
  37                 item = (pattern) + (index);                     \
  38                 }                                               \
  39         } while (0)
  40
  41 #define NEXT_ITEM_OF_ACTION(act, actions, index)                \
  42         do {                                                    \
  43                 act = (actions) + (index);                      \
  44                 while (act->type == RTE_FLOW_ACTION_TYPE_VOID) {\
  45                 (index)++;                                      \
  46                 act = (actions) + (index);                      \
  47                 }                                               \
  48         } while (0)
  49
  50 #define IGB_FLEX_RAW_NUM        12
  51
  52 /**
  53  * Please aware there's an asumption for all the parsers.
  54  * rte_flow_item is using big endian, rte_flow_attr and
  55  * rte_flow_action are using CPU order.
  56  * Because the pattern is used to describe the packets,
  57  * normally the packets should use network order.
  58  */
  59
  60 /**
  61  * Parse the rule to see if it is a n-tuple rule.
  62  * And get the n-tuple filter info BTW.
  63  * pattern:
  64  * The first not void item can be ETH or IPV4.
  65  * The second not void item must be IPV4 if the first one is ETH.
  66  * The third not void item must be UDP or TCP or SCTP
  67  * The next not void item must be END.
  68  * action:
  69  * The first not void action should be QUEUE.
  70  * The next not void action should be END.
  71  * pattern example:
  72  * ITEM         Spec                    Mask
  73  * ETH          NULL                    NULL
  74  * IPV4         src_addr 192.168.1.20   0xFFFFFFFF
  75  *                      dst_addr 192.167.3.50   0xFFFFFFFF
  76  *                      next_proto_id   17      0xFF
  77  * UDP/TCP/     src_port        80      0xFFFF
  78  * SCTP         dst_port        80      0xFFFF
  79  * END
  80  * other members in mask and spec should set to 0x00.
  81  * item->last should be NULL.
  82  */
  83 static int
  84 cons_parse_ntuple_filter(const struct rte_flow_attr *attr,
  85                          const struct rte_flow_item pattern[],
  86                          const struct rte_flow_action actions[],
  87                          struct rte_eth_ntuple_filter *filter,
  88                          struct rte_flow_error *error)
  89 {
  90         const struct rte_flow_item *item;
  91         const struct rte_flow_action *act;
  92         const struct rte_flow_item_ipv4 *ipv4_spec;
  93         const struct rte_flow_item_ipv4 *ipv4_mask;
  94         const struct rte_flow_item_tcp *tcp_spec;
  95         const struct rte_flow_item_tcp *tcp_mask;
  96         const struct rte_flow_item_udp *udp_spec;
  97         const struct rte_flow_item_udp *udp_mask;
  98         const struct rte_flow_item_sctp *sctp_spec;
  99         const struct rte_flow_item_sctp *sctp_mask;
 100         uint32_t index;
 101
 102         if (!pattern) {
 103                 rte_flow_error_set(error,
 104                         EINVAL, RTE_FLOW_ERROR_TYPE_ITEM_NUM,
 105                         NULL, "NULL pattern.");
 106                 return -rte_errno;
 107         }
 108
 109         if (!actions) {
 110                 rte_flow_error_set(error, EINVAL,
 111                                    RTE_FLOW_ERROR_TYPE_ACTION_NUM,
 112                                    NULL, "NULL action.");
 113                 return -rte_errno;
 114         }
 115         if (!attr) {
 116                 rte_flow_error_set(error, EINVAL,
 117                                    RTE_FLOW_ERROR_TYPE_ATTR,
 118                                    NULL, "NULL attribute.");
 119                 return -rte_errno;
 120         }
 121
 122         /* parse pattern */
 123         index = 0;
 124
 125         /* the first not void item can be MAC or IPv4 */
 126         NEXT_ITEM_OF_PATTERN(item, pattern, index);
 127
 128         if (item->type != RTE_FLOW_ITEM_TYPE_ETH &&
 129             item->type != RTE_FLOW_ITEM_TYPE_IPV4) {
 130                 rte_flow_error_set(error, EINVAL,
 131                         RTE_FLOW_ERROR_TYPE_ITEM,
 132                         item, "Not supported by ntuple filter");
 133                 return -rte_errno;
 134         }
 135         /* Skip Ethernet */
 136         if (item->type == RTE_FLOW_ITEM_TYPE_ETH) {
 137                 /*Not supported last point for range*/
 138                 if (item->last) {
 139                         rte_flow_error_set(error,
 140                           EINVAL,
 141                           RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
 142                           item, "Not supported last point for range");
 143                         return -rte_errno;
 144                 }
 145                 /* if the first item is MAC, the content should be NULL */
 146                 if (item->spec || item->mask) {
 147                         rte_flow_error_set(error, EINVAL,
 148                                 RTE_FLOW_ERROR_TYPE_ITEM,
 149                                 item, "Not supported by ntuple filter");
 150                         return -rte_errno;
 151                 }
 152                 /* check if the next not void item is IPv4 */
 153                 index++;
 154                 NEXT_ITEM_OF_PATTERN(item, pattern, index);
 155                 if (item->type != RTE_FLOW_ITEM_TYPE_IPV4) {
 156                         rte_flow_error_set(error,
 157                           EINVAL, RTE_FLOW_ERROR_TYPE_ITEM,
 158                           item, "Not supported by ntuple filter");
 159                         return -rte_errno;
 160                 }
 161         }
 162
 163         /* get the IPv4 info */
 164         if (!item->spec || !item->mask) {
 165                 rte_flow_error_set(error, EINVAL,
 166                         RTE_FLOW_ERROR_TYPE_ITEM,
 167                         item, "Invalid ntuple mask");
 168                 return -rte_errno;
 169         }
 170         /* Not supported last point for range */
 171         if (item->last) {
 172                 rte_flow_error_set(error, EINVAL,
 173                         RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
 174                         item, "Not supported last point for range");
 175                 return -rte_errno;
 176         }
 177
 178         ipv4_mask = item->mask;
 179         /**
 180          * Only support src & dst addresses, protocol,
 181          * others should be masked.
 182          */
 183
 184         if (ipv4_mask->hdr.version_ihl ||
 185                 ipv4_mask->hdr.type_of_service ||
 186                 ipv4_mask->hdr.total_length ||
 187                 ipv4_mask->hdr.packet_id ||
 188                 ipv4_mask->hdr.fragment_offset ||
 189                 ipv4_mask->hdr.time_to_live ||
 190                 ipv4_mask->hdr.hdr_checksum) {
 191                 rte_flow_error_set(error,
 192                         EINVAL, RTE_FLOW_ERROR_TYPE_ITEM,
 193                         item, "Not supported by ntuple filter");
 194                 return -rte_errno;
 195         }
 196
 197         filter->dst_ip_mask = ipv4_mask->hdr.dst_addr;
 198         filter->src_ip_mask = ipv4_mask->hdr.src_addr;
 199         filter->proto_mask  = ipv4_mask->hdr.next_proto_id;
 200
 201         ipv4_spec = item->spec;
 202         filter->dst_ip = ipv4_spec->hdr.dst_addr;
 203         filter->src_ip = ipv4_spec->hdr.src_addr;
 204         filter->proto  = ipv4_spec->hdr.next_proto_id;
 205
 206         /* check if the next not void item is TCP or UDP or SCTP */
 207         index++;
 208         NEXT_ITEM_OF_PATTERN(item, pattern, index);
 209         if (item->type != RTE_FLOW_ITEM_TYPE_TCP &&
 210             item->type != RTE_FLOW_ITEM_TYPE_UDP &&
 211             item->type != RTE_FLOW_ITEM_TYPE_SCTP) {
 212                 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
 213                 rte_flow_error_set(error, EINVAL,
 214                         RTE_FLOW_ERROR_TYPE_ITEM,
 215                         item, "Not supported by ntuple filter");
 216                 return -rte_errno;
 217         }
 218
 219         /* Not supported last point for range */
 220         if (item->last) {
 221                 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
 222                 rte_flow_error_set(error, EINVAL,
 223                         RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
 224                         item, "Not supported last point for range");
 225                 return -rte_errno;
 226         }
 227
 228         /* get the TCP/UDP/SCTP info */
 229         if (item->type == RTE_FLOW_ITEM_TYPE_TCP) {
 230                 if (item->spec && item->mask) {
 231                         tcp_mask = item->mask;
 232
 233                         /**
 234                          * Only support src & dst ports, tcp flags,
 235                          * others should be masked.
 236                          */
 237                         if (tcp_mask->hdr.sent_seq ||
 238                                 tcp_mask->hdr.recv_ack ||
 239                                 tcp_mask->hdr.data_off ||
 240                                 tcp_mask->hdr.rx_win ||
 241                                 tcp_mask->hdr.cksum ||
 242                                 tcp_mask->hdr.tcp_urp) {
 243                                 memset(filter, 0,
 244                                         sizeof(struct rte_eth_ntuple_filter));
 245                                 rte_flow_error_set(error, EINVAL,
 246                                         RTE_FLOW_ERROR_TYPE_ITEM,
 247                                         item, "Not supported by ntuple filter");
 248                                 return -rte_errno;
 249                         }
 250
 251                         filter->dst_port_mask  = tcp_mask->hdr.dst_port;
 252                         filter->src_port_mask  = tcp_mask->hdr.src_port;
 253                         if (tcp_mask->hdr.tcp_flags == 0xFF) {
 254                                 filter->flags |= RTE_NTUPLE_FLAGS_TCP_FLAG;
 255                         } else if (!tcp_mask->hdr.tcp_flags) {
 256                                 filter->flags &= ~RTE_NTUPLE_FLAGS_TCP_FLAG;
 257                         } else {
 258                                 memset(filter, 0,
 259                                         sizeof(struct rte_eth_ntuple_filter));
 260                                 rte_flow_error_set(error, EINVAL,
 261                                         RTE_FLOW_ERROR_TYPE_ITEM,
 262                                         item, "Not supported by ntuple filter");
 263                                 return -rte_errno;
 264                         }
 265
 266                         tcp_spec = item->spec;
 267                         filter->dst_port  = tcp_spec->hdr.dst_port;
 268                         filter->src_port  = tcp_spec->hdr.src_port;
 269                         filter->tcp_flags = tcp_spec->hdr.tcp_flags;
 270                 }
 271         } else if (item->type == RTE_FLOW_ITEM_TYPE_UDP) {
 272                 if (item->spec && item->mask) {
 273                         udp_mask = item->mask;
 274
 275                         /**
 276                          * Only support src & dst ports,
 277                          * others should be masked.
 278                          */
 279                         if (udp_mask->hdr.dgram_len ||
 280                             udp_mask->hdr.dgram_cksum) {
 281                                 memset(filter, 0,
 282                                         sizeof(struct rte_eth_ntuple_filter));
 283                                 rte_flow_error_set(error, EINVAL,
 284                                         RTE_FLOW_ERROR_TYPE_ITEM,
 285                                         item, "Not supported by ntuple filter");
 286                                 return -rte_errno;
 287                         }
 288
 289                         filter->dst_port_mask = udp_mask->hdr.dst_port;
 290                         filter->src_port_mask = udp_mask->hdr.src_port;
 291
 292                         udp_spec = item->spec;
 293                         filter->dst_port = udp_spec->hdr.dst_port;
 294                         filter->src_port = udp_spec->hdr.src_port;
 295                 }
 296         } else {
 297                 if (item->spec && item->mask) {
 298                         sctp_mask = item->mask;
 299
 300                         /**
 301                          * Only support src & dst ports,
 302                          * others should be masked.
 303                          */
 304                         if (sctp_mask->hdr.tag ||
 305                             sctp_mask->hdr.cksum) {
 306                                 memset(filter, 0,
 307                                         sizeof(struct rte_eth_ntuple_filter));
 308                                 rte_flow_error_set(error, EINVAL,
 309                                         RTE_FLOW_ERROR_TYPE_ITEM,
 310                                         item, "Not supported by ntuple filter");
 311                                 return -rte_errno;
 312                         }
 313
 314                         filter->dst_port_mask = sctp_mask->hdr.dst_port;
 315                         filter->src_port_mask = sctp_mask->hdr.src_port;
 316
 317                         sctp_spec = (const struct rte_flow_item_sctp *)
 318                                         item->spec;
 319                         filter->dst_port = sctp_spec->hdr.dst_port;
 320                         filter->src_port = sctp_spec->hdr.src_port;
 321                 }
 322         }
 323         /* check if the next not void item is END */
 324         index++;
 325         NEXT_ITEM_OF_PATTERN(item, pattern, index);
 326         if (item->type != RTE_FLOW_ITEM_TYPE_END) {
 327                 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
 328                 rte_flow_error_set(error, EINVAL,
 329                         RTE_FLOW_ERROR_TYPE_ITEM,
 330                         item, "Not supported by ntuple filter");
 331                 return -rte_errno;
 332         }
 333
 334         /* parse action */
 335         index = 0;
 336
 337         /**
 338          * n-tuple only supports forwarding,
 339          * check if the first not void action is QUEUE.
 340          */
 341         NEXT_ITEM_OF_ACTION(act, actions, index);
 342         if (act->type != RTE_FLOW_ACTION_TYPE_QUEUE) {
 343                 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
 344                 rte_flow_error_set(error, EINVAL,
 345                         RTE_FLOW_ERROR_TYPE_ACTION,
 346                         item, "Not supported action.");
 347                 return -rte_errno;
 348         }
 349         filter->queue =
 350                 ((const struct rte_flow_action_queue *)act->conf)->index;
 351
 352         /* check if the next not void item is END */
 353         index++;
 354         NEXT_ITEM_OF_ACTION(act, actions, index);
 355         if (act->type != RTE_FLOW_ACTION_TYPE_END) {
 356                 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
 357                 rte_flow_error_set(error, EINVAL,
 358                         RTE_FLOW_ERROR_TYPE_ACTION,
 359                         act, "Not supported action.");
 360                 return -rte_errno;
 361         }
 362
 363         /* parse attr */
 364         /* must be input direction */
 365         if (!attr->ingress) {
 366                 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
 367                 rte_flow_error_set(error, EINVAL,
 368                                    RTE_FLOW_ERROR_TYPE_ATTR_INGRESS,
 369                                    attr, "Only support ingress.");
 370                 return -rte_errno;
 371         }
 372
 373         /* not supported */
 374         if (attr->egress) {
 375                 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
 376                 rte_flow_error_set(error, EINVAL,
 377                                    RTE_FLOW_ERROR_TYPE_ATTR_EGRESS,
 378                                    attr, "Not support egress.");
 379                 return -rte_errno;
 380         }
 381
 382         /* not supported */
 383         if (attr->transfer) {
 384                 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
 385                 rte_flow_error_set(error, EINVAL,
 386                                    RTE_FLOW_ERROR_TYPE_ATTR_TRANSFER,
 387                                    attr, "No support for transfer.");
 388                 return -rte_errno;
 389         }
 390
 391         if (attr->priority > 0xFFFF) {
 392                 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
 393                 rte_flow_error_set(error, EINVAL,
 394                                    RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY,
 395                                    attr, "Error priority.");
 396                 return -rte_errno;
 397         }
 398         filter->priority = (uint16_t)attr->priority;
 399
 400         return 0;
 401 }
 402
 403 /* a specific function for igb because the flags is specific */
 404 static int
 405 igb_parse_ntuple_filter(struct rte_eth_dev *dev,
 406                           const struct rte_flow_attr *attr,
 407                           const struct rte_flow_item pattern[],
 408                           const struct rte_flow_action actions[],
 409                           struct rte_eth_ntuple_filter *filter,
 410                           struct rte_flow_error *error)
 411 {
 412         struct e1000_hw *hw = E1000_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 413         int ret;
 414
 415         MAC_TYPE_FILTER_SUP(hw->mac.type);
 416
 417         ret = cons_parse_ntuple_filter(attr, pattern, actions, filter, error);
 418
 419         if (ret)
 420                 return ret;
 421
 422         /* Igb doesn't support many priorities. */
 423         if (filter->priority > E1000_2TUPLE_MAX_PRI) {
 424                 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
 425                 rte_flow_error_set(error, EINVAL,
 426                         RTE_FLOW_ERROR_TYPE_ITEM,
 427                         NULL, "Priority not supported by ntuple filter");
 428                 return -rte_errno;
 429         }
 430
 431         if (hw->mac.type == e1000_82576) {
 432                 if (filter->queue >= IGB_MAX_RX_QUEUE_NUM_82576) {
 433                         memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
 434                         rte_flow_error_set(error, EINVAL,
 435                                 RTE_FLOW_ERROR_TYPE_ITEM,
 436                                 NULL, "queue number not "
 437                                 "supported by ntuple filter");
 438                         return -rte_errno;
 439                 }
 440                 filter->flags |= RTE_5TUPLE_FLAGS;
 441         } else {
 442                 if (filter->src_ip_mask || filter->dst_ip_mask ||
 443                         filter->src_port_mask) {
 444                         memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
 445                         rte_flow_error_set(error, EINVAL,
 446                                 RTE_FLOW_ERROR_TYPE_ITEM,
 447                                 NULL, "only two tuple are "
 448                                 "supported by this filter");
 449                         return -rte_errno;
 450                 }
 451                 if (filter->queue >= IGB_MAX_RX_QUEUE_NUM) {
 452                         memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
 453                         rte_flow_error_set(error, EINVAL,
 454                                 RTE_FLOW_ERROR_TYPE_ITEM,
 455                                 NULL, "queue number not "
 456                                 "supported by ntuple filter");
 457                         return -rte_errno;
 458                 }
 459                 filter->flags |= RTE_2TUPLE_FLAGS;
 460         }
 461
 462         return 0;
 463 }
 464
 465 /**
 466  * Parse the rule to see if it is a ethertype rule.
 467  * And get the ethertype filter info BTW.
 468  * pattern:
 469  * The first not void item can be ETH.
 470  * The next not void item must be END.
 471  * action:
 472  * The first not void action should be QUEUE.
 473  * The next not void action should be END.
 474  * pattern example:
 475  * ITEM         Spec                    Mask
 476  * ETH          type    0x0807          0xFFFF
 477  * END
 478  * other members in mask and spec should set to 0x00.
 479  * item->last should be NULL.
 480  */
 481 static int
 482 cons_parse_ethertype_filter(const struct rte_flow_attr *attr,
 483                             const struct rte_flow_item *pattern,
 484                             const struct rte_flow_action *actions,
 485                             struct rte_eth_ethertype_filter *filter,
 486                             struct rte_flow_error *error)
 487 {
 488         const struct rte_flow_item *item;
 489         const struct rte_flow_action *act;
 490         const struct rte_flow_item_eth *eth_spec;
 491         const struct rte_flow_item_eth *eth_mask;
 492         const struct rte_flow_action_queue *act_q;
 493         uint32_t index;
 494
 495         if (!pattern) {
 496                 rte_flow_error_set(error, EINVAL,
 497                                 RTE_FLOW_ERROR_TYPE_ITEM_NUM,
 498                                 NULL, "NULL pattern.");
 499                 return -rte_errno;
 500         }
 501
 502         if (!actions) {
 503                 rte_flow_error_set(error, EINVAL,
 504                                 RTE_FLOW_ERROR_TYPE_ACTION_NUM,
 505                                 NULL, "NULL action.");
 506                 return -rte_errno;
 507         }
 508
 509         if (!attr) {
 510                 rte_flow_error_set(error, EINVAL,
 511                                    RTE_FLOW_ERROR_TYPE_ATTR,
 512                                    NULL, "NULL attribute.");
 513                 return -rte_errno;
 514         }
 515
 516         /* Parse pattern */
 517         index = 0;
 518
 519         /* The first non-void item should be MAC. */
 520         NEXT_ITEM_OF_PATTERN(item, pattern, index);
 521         if (item->type != RTE_FLOW_ITEM_TYPE_ETH) {
 522                 rte_flow_error_set(error, EINVAL,
 523                         RTE_FLOW_ERROR_TYPE_ITEM,
 524                         item, "Not supported by ethertype filter");
 525                 return -rte_errno;
 526         }
 527
 528         /*Not supported last point for range*/
 529         if (item->last) {
 530                 rte_flow_error_set(error, EINVAL,
 531                         RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
 532                         item, "Not supported last point for range");
 533                 return -rte_errno;
 534         }
 535
 536         /* Get the MAC info. */
 537         if (!item->spec || !item->mask) {
 538                 rte_flow_error_set(error, EINVAL,
 539                                 RTE_FLOW_ERROR_TYPE_ITEM,
 540                                 item, "Not supported by ethertype filter");
 541                 return -rte_errno;
 542         }
 543
 544         eth_spec = item->spec;
 545         eth_mask = item->mask;
 546
 547         /* Mask bits of source MAC address must be full of 0.
 548          * Mask bits of destination MAC address must be full
 549          * of 1 or full of 0.
 550          */
 551         if (!is_zero_ether_addr(&eth_mask->src) ||
 552             (!is_zero_ether_addr(&eth_mask->dst) &&
 553              !is_broadcast_ether_addr(&eth_mask->dst))) {
 554                 rte_flow_error_set(error, EINVAL,
 555                                 RTE_FLOW_ERROR_TYPE_ITEM,
 556                                 item, "Invalid ether address mask");
 557                 return -rte_errno;
 558         }
 559
 560         if ((eth_mask->type & UINT16_MAX) != UINT16_MAX) {
 561                 rte_flow_error_set(error, EINVAL,
 562                                 RTE_FLOW_ERROR_TYPE_ITEM,
 563                                 item, "Invalid ethertype mask");
 564                 return -rte_errno;
 565         }
 566
 567         /* If mask bits of destination MAC address
 568          * are full of 1, set RTE_ETHTYPE_FLAGS_MAC.
 569          */
 570         if (is_broadcast_ether_addr(&eth_mask->dst)) {
 571                 filter->mac_addr = eth_spec->dst;
 572                 filter->flags |= RTE_ETHTYPE_FLAGS_MAC;
 573         } else {
 574                 filter->flags &= ~RTE_ETHTYPE_FLAGS_MAC;
 575         }
 576         filter->ether_type = rte_be_to_cpu_16(eth_spec->type);
 577
 578         /* Check if the next non-void item is END. */
 579         index++;
 580         NEXT_ITEM_OF_PATTERN(item, pattern, index);
 581         if (item->type != RTE_FLOW_ITEM_TYPE_END) {
 582                 rte_flow_error_set(error, EINVAL,
 583                                 RTE_FLOW_ERROR_TYPE_ITEM,
 584                                 item, "Not supported by ethertype filter.");
 585                 return -rte_errno;
 586         }
 587
 588         /* Parse action */
 589
 590         index = 0;
 591         /* Check if the first non-void action is QUEUE or DROP. */
 592         NEXT_ITEM_OF_ACTION(act, actions, index);
 593         if (act->type != RTE_FLOW_ACTION_TYPE_QUEUE &&
 594             act->type != RTE_FLOW_ACTION_TYPE_DROP) {
 595                 rte_flow_error_set(error, EINVAL,
 596                                 RTE_FLOW_ERROR_TYPE_ACTION,
 597                                 act, "Not supported action.");
 598                 return -rte_errno;
 599         }
 600
 601         if (act->type == RTE_FLOW_ACTION_TYPE_QUEUE) {
 602                 act_q = (const struct rte_flow_action_queue *)act->conf;
 603                 filter->queue = act_q->index;
 604         } else {
 605                 filter->flags |= RTE_ETHTYPE_FLAGS_DROP;
 606         }
 607
 608         /* Check if the next non-void item is END */
 609         index++;
 610         NEXT_ITEM_OF_ACTION(act, actions, index);
 611         if (act->type != RTE_FLOW_ACTION_TYPE_END) {
 612                 rte_flow_error_set(error, EINVAL,
 613                                 RTE_FLOW_ERROR_TYPE_ACTION,
 614                                 act, "Not supported action.");
 615                 return -rte_errno;
 616         }
 617
 618         /* Parse attr */
 619         /* Must be input direction */
 620         if (!attr->ingress) {
 621                 rte_flow_error_set(error, EINVAL,
 622                                 RTE_FLOW_ERROR_TYPE_ATTR_INGRESS,
 623                                 attr, "Only support ingress.");
 624                 return -rte_errno;
 625         }
 626
 627         /* Not supported */
 628         if (attr->egress) {
 629                 rte_flow_error_set(error, EINVAL,
 630                                 RTE_FLOW_ERROR_TYPE_ATTR_EGRESS,
 631                                 attr, "Not support egress.");
 632                 return -rte_errno;
 633         }
 634
 635         /* Not supported */
 636         if (attr->transfer) {
 637                 rte_flow_error_set(error, EINVAL,
 638                                 RTE_FLOW_ERROR_TYPE_ATTR_TRANSFER,
 639                                 attr, "No support for transfer.");
 640                 return -rte_errno;
 641         }
 642
 643         /* Not supported */
 644         if (attr->priority) {
 645                 rte_flow_error_set(error, EINVAL,
 646                                 RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY,
 647                                 attr, "Not support priority.");
 648                 return -rte_errno;
 649         }
 650
 651         /* Not supported */
 652         if (attr->group) {
 653                 rte_flow_error_set(error, EINVAL,
 654                                 RTE_FLOW_ERROR_TYPE_ATTR_GROUP,
 655                                 attr, "Not support group.");
 656                 return -rte_errno;
 657         }
 658
 659         return 0;
 660 }
 661
 662 static int
 663 igb_parse_ethertype_filter(struct rte_eth_dev *dev,
 664                                  const struct rte_flow_attr *attr,
 665                              const struct rte_flow_item pattern[],
 666                              const struct rte_flow_action actions[],
 667                              struct rte_eth_ethertype_filter *filter,
 668                              struct rte_flow_error *error)
 669 {
 670         struct e1000_hw *hw = E1000_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 671         int ret;
 672
 673         MAC_TYPE_FILTER_SUP(hw->mac.type);
 674
 675         ret = cons_parse_ethertype_filter(attr, pattern,
 676                                         actions, filter, error);
 677
 678         if (ret)
 679                 return ret;
 680
 681         if (hw->mac.type == e1000_82576) {
 682                 if (filter->queue >= IGB_MAX_RX_QUEUE_NUM_82576) {
 683                         memset(filter, 0, sizeof(
 684                                         struct rte_eth_ethertype_filter));
 685                         rte_flow_error_set(error, EINVAL,
 686                                 RTE_FLOW_ERROR_TYPE_ITEM,
 687                                 NULL, "queue number not supported "
 688                                         "by ethertype filter");
 689                         return -rte_errno;
 690                 }
 691         } else {
 692                 if (filter->queue >= IGB_MAX_RX_QUEUE_NUM) {
 693                         memset(filter, 0, sizeof(
 694                                         struct rte_eth_ethertype_filter));
 695                         rte_flow_error_set(error, EINVAL,
 696                                 RTE_FLOW_ERROR_TYPE_ITEM,
 697                                 NULL, "queue number not supported "
 698                                         "by ethertype filter");
 699                         return -rte_errno;
 700                 }
 701         }
 702
 703         if (filter->ether_type == ETHER_TYPE_IPv4 ||
 704                 filter->ether_type == ETHER_TYPE_IPv6) {
 705                 memset(filter, 0, sizeof(struct rte_eth_ethertype_filter));
 706                 rte_flow_error_set(error, EINVAL,
 707                         RTE_FLOW_ERROR_TYPE_ITEM,
 708                         NULL, "IPv4/IPv6 not supported by ethertype filter");
 709                 return -rte_errno;
 710         }
 711
 712         if (filter->flags & RTE_ETHTYPE_FLAGS_MAC) {
 713                 memset(filter, 0, sizeof(struct rte_eth_ethertype_filter));
 714                 rte_flow_error_set(error, EINVAL,
 715                         RTE_FLOW_ERROR_TYPE_ITEM,
 716                         NULL, "mac compare is unsupported");
 717                 return -rte_errno;
 718         }
 719
 720         if (filter->flags & RTE_ETHTYPE_FLAGS_DROP) {
 721                 memset(filter, 0, sizeof(struct rte_eth_ethertype_filter));
 722                 rte_flow_error_set(error, EINVAL,
 723                         RTE_FLOW_ERROR_TYPE_ITEM,
 724                         NULL, "drop option is unsupported");
 725                 return -rte_errno;
 726         }
 727
 728         return 0;
 729 }
 730
 731 /**
 732  * Parse the rule to see if it is a TCP SYN rule.
 733  * And get the TCP SYN filter info BTW.
 734  * pattern:
 735  * The first not void item must be ETH.
 736  * The second not void item must be IPV4 or IPV6.
 737  * The third not void item must be TCP.
 738  * The next not void item must be END.
 739  * action:
 740  * The first not void action should be QUEUE.
 741  * The next not void action should be END.
 742  * pattern example:
 743  * ITEM         Spec                    Mask
 744  * ETH          NULL                    NULL
 745  * IPV4/IPV6    NULL                    NULL
 746  * TCP          tcp_flags       0x02    0xFF
 747  * END
 748  * other members in mask and spec should set to 0x00.
 749  * item->last should be NULL.
 750  */
 751 static int
 752 cons_parse_syn_filter(const struct rte_flow_attr *attr,
 753                                 const struct rte_flow_item pattern[],
 754                                 const struct rte_flow_action actions[],
 755                                 struct rte_eth_syn_filter *filter,
 756                                 struct rte_flow_error *error)
 757 {
 758         const struct rte_flow_item *item;
 759         const struct rte_flow_action *act;
 760         const struct rte_flow_item_tcp *tcp_spec;
 761         const struct rte_flow_item_tcp *tcp_mask;
 762         const struct rte_flow_action_queue *act_q;
 763         uint32_t index;
 764
 765         if (!pattern) {
 766                 rte_flow_error_set(error, EINVAL,
 767                                 RTE_FLOW_ERROR_TYPE_ITEM_NUM,
 768                                 NULL, "NULL pattern.");
 769                 return -rte_errno;
 770         }
 771
 772         if (!actions) {
 773                 rte_flow_error_set(error, EINVAL,
 774                                 RTE_FLOW_ERROR_TYPE_ACTION_NUM,
 775                                 NULL, "NULL action.");
 776                 return -rte_errno;
 777         }
 778
 779         if (!attr) {
 780                 rte_flow_error_set(error, EINVAL,
 781                                    RTE_FLOW_ERROR_TYPE_ATTR,
 782                                    NULL, "NULL attribute.");
 783                 return -rte_errno;
 784         }
 785
 786         /* parse pattern */
 787         index = 0;
 788
 789         /* the first not void item should be MAC or IPv4 or IPv6 or TCP */
 790         NEXT_ITEM_OF_PATTERN(item, pattern, index);
 791         if (item->type != RTE_FLOW_ITEM_TYPE_ETH &&
 792             item->type != RTE_FLOW_ITEM_TYPE_IPV4 &&
 793             item->type != RTE_FLOW_ITEM_TYPE_IPV6 &&
 794             item->type != RTE_FLOW_ITEM_TYPE_TCP) {
 795                 rte_flow_error_set(error, EINVAL,
 796                                 RTE_FLOW_ERROR_TYPE_ITEM,
 797                                 item, "Not supported by syn filter");
 798                 return -rte_errno;
 799         }
 800                 /*Not supported last point for range*/
 801         if (item->last) {
 802                 rte_flow_error_set(error, EINVAL,
 803                         RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
 804                         item, "Not supported last point for range");
 805                 return -rte_errno;
 806         }
 807
 808         /* Skip Ethernet */
 809         if (item->type == RTE_FLOW_ITEM_TYPE_ETH) {
 810                 /* if the item is MAC, the content should be NULL */
 811                 if (item->spec || item->mask) {
 812                         rte_flow_error_set(error, EINVAL,
 813                                 RTE_FLOW_ERROR_TYPE_ITEM,
 814                                 item, "Invalid SYN address mask");
 815                         return -rte_errno;
 816                 }
 817
 818                 /* check if the next not void item is IPv4 or IPv6 */
 819                 index++;
 820                 NEXT_ITEM_OF_PATTERN(item, pattern, index);
 821                 if (item->type != RTE_FLOW_ITEM_TYPE_IPV4 &&
 822                     item->type != RTE_FLOW_ITEM_TYPE_IPV6) {
 823                         rte_flow_error_set(error, EINVAL,
 824                                 RTE_FLOW_ERROR_TYPE_ITEM,
 825                                 item, "Not supported by syn filter");
 826                         return -rte_errno;
 827                 }
 828         }
 829
 830         /* Skip IP */
 831         if (item->type == RTE_FLOW_ITEM_TYPE_IPV4 ||
 832             item->type == RTE_FLOW_ITEM_TYPE_IPV6) {
 833                 /* if the item is IP, the content should be NULL */
 834                 if (item->spec || item->mask) {
 835                         rte_flow_error_set(error, EINVAL,
 836                                 RTE_FLOW_ERROR_TYPE_ITEM,
 837                                 item, "Invalid SYN mask");
 838                         return -rte_errno;
 839                 }
 840
 841                 /* check if the next not void item is TCP */
 842                 index++;
 843                 NEXT_ITEM_OF_PATTERN(item, pattern, index);
 844                 if (item->type != RTE_FLOW_ITEM_TYPE_TCP) {
 845                         rte_flow_error_set(error, EINVAL,
 846                                 RTE_FLOW_ERROR_TYPE_ITEM,
 847                                 item, "Not supported by syn filter");
 848                         return -rte_errno;
 849                 }
 850         }
 851
 852         /* Get the TCP info. Only support SYN. */
 853         if (!item->spec || !item->mask) {
 854                 rte_flow_error_set(error, EINVAL,
 855                                 RTE_FLOW_ERROR_TYPE_ITEM,
 856                                 item, "Invalid SYN mask");
 857                 return -rte_errno;
 858         }
 859         /*Not supported last point for range*/
 860         if (item->last) {
 861                 rte_flow_error_set(error, EINVAL,
 862                         RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
 863                         item, "Not supported last point for range");
 864                 return -rte_errno;
 865         }
 866
 867         tcp_spec = item->spec;
 868         tcp_mask = item->mask;
 869         if (!(tcp_spec->hdr.tcp_flags & TCP_SYN_FLAG) ||
 870             tcp_mask->hdr.src_port ||
 871             tcp_mask->hdr.dst_port ||
 872             tcp_mask->hdr.sent_seq ||
 873             tcp_mask->hdr.recv_ack ||
 874             tcp_mask->hdr.data_off ||
 875             tcp_mask->hdr.tcp_flags != TCP_SYN_FLAG ||
 876             tcp_mask->hdr.rx_win ||
 877             tcp_mask->hdr.cksum ||
 878             tcp_mask->hdr.tcp_urp) {
 879                 memset(filter, 0, sizeof(struct rte_eth_syn_filter));
 880                 rte_flow_error_set(error, EINVAL,
 881                                 RTE_FLOW_ERROR_TYPE_ITEM,
 882                                 item, "Not supported by syn filter");
 883                 return -rte_errno;
 884         }
 885
 886         /* check if the next not void item is END */
 887         index++;
 888         NEXT_ITEM_OF_PATTERN(item, pattern, index);
 889         if (item->type != RTE_FLOW_ITEM_TYPE_END) {
 890                 memset(filter, 0, sizeof(struct rte_eth_syn_filter));
 891                 rte_flow_error_set(error, EINVAL,
 892                                 RTE_FLOW_ERROR_TYPE_ITEM,
 893                                 item, "Not supported by syn filter");
 894                 return -rte_errno;
 895         }
 896
 897         /* parse action */
 898         index = 0;
 899
 900         /* check if the first not void action is QUEUE. */
 901         NEXT_ITEM_OF_ACTION(act, actions, index);
 902         if (act->type != RTE_FLOW_ACTION_TYPE_QUEUE) {
 903                 memset(filter, 0, sizeof(struct rte_eth_syn_filter));
 904                 rte_flow_error_set(error, EINVAL,
 905                                 RTE_FLOW_ERROR_TYPE_ACTION,
 906                                 act, "Not supported action.");
 907                 return -rte_errno;
 908         }
 909
 910         act_q = (const struct rte_flow_action_queue *)act->conf;
 911         filter->queue = act_q->index;
 912
 913         /* check if the next not void item is END */
 914         index++;
 915         NEXT_ITEM_OF_ACTION(act, actions, index);
 916         if (act->type != RTE_FLOW_ACTION_TYPE_END) {
 917                 memset(filter, 0, sizeof(struct rte_eth_syn_filter));
 918                 rte_flow_error_set(error, EINVAL,
 919                                 RTE_FLOW_ERROR_TYPE_ACTION,
 920                                 act, "Not supported action.");
 921                 return -rte_errno;
 922         }
 923
 924         /* parse attr */
 925         /* must be input direction */
 926         if (!attr->ingress) {
 927                 memset(filter, 0, sizeof(struct rte_eth_syn_filter));
 928                 rte_flow_error_set(error, EINVAL,
 929                         RTE_FLOW_ERROR_TYPE_ATTR_INGRESS,
 930                         attr, "Only support ingress.");
 931                 return -rte_errno;
 932         }
 933
 934         /* not supported */
 935         if (attr->egress) {
 936                 memset(filter, 0, sizeof(struct rte_eth_syn_filter));
 937                 rte_flow_error_set(error, EINVAL,
 938                         RTE_FLOW_ERROR_TYPE_ATTR_EGRESS,
 939                         attr, "Not support egress.");
 940                 return -rte_errno;
 941         }
 942
 943         /* not supported */
 944         if (attr->transfer) {
 945                 memset(filter, 0, sizeof(struct rte_eth_syn_filter));
 946                 rte_flow_error_set(error, EINVAL,
 947                         RTE_FLOW_ERROR_TYPE_ATTR_TRANSFER,
 948                         attr, "No support for transfer.");
 949                 return -rte_errno;
 950         }
 951
 952         /* Support 2 priorities, the lowest or highest. */
 953         if (!attr->priority) {
 954                 filter->hig_pri = 0;
 955         } else if (attr->priority == (uint32_t)~0U) {
 956                 filter->hig_pri = 1;
 957         } else {
 958                 memset(filter, 0, sizeof(struct rte_eth_syn_filter));
 959                 rte_flow_error_set(error, EINVAL,
 960                         RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY,
 961                         attr, "Not support priority.");
 962                 return -rte_errno;
 963         }
 964
 965         return 0;
 966 }
 967
 968 static int
 969 igb_parse_syn_filter(struct rte_eth_dev *dev,
 970                                  const struct rte_flow_attr *attr,
 971                              const struct rte_flow_item pattern[],
 972                              const struct rte_flow_action actions[],
 973                              struct rte_eth_syn_filter *filter,
 974                              struct rte_flow_error *error)
 975 {
 976         struct e1000_hw *hw = E1000_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 977         int ret;
 978
 979         MAC_TYPE_FILTER_SUP(hw->mac.type);
 980
 981         ret = cons_parse_syn_filter(attr, pattern,
 982                                         actions, filter, error);
 983
 984         if (hw->mac.type == e1000_82576) {
 985                 if (filter->queue >= IGB_MAX_RX_QUEUE_NUM_82576) {
 986                         memset(filter, 0, sizeof(struct rte_eth_syn_filter));
 987                         rte_flow_error_set(error, EINVAL,
 988                                 RTE_FLOW_ERROR_TYPE_ITEM,
 989                                 NULL, "queue number not "
 990                                         "supported by syn filter");
 991                         return -rte_errno;
 992                 }
 993         } else {
 994                 if (filter->queue >= IGB_MAX_RX_QUEUE_NUM) {
 995                         memset(filter, 0, sizeof(struct rte_eth_syn_filter));
 996                         rte_flow_error_set(error, EINVAL,
 997                                 RTE_FLOW_ERROR_TYPE_ITEM,
 998                                 NULL, "queue number not "
 999                                         "supported by syn filter");
1000                         return -rte_errno;
1001                 }
1002         }
1003
1004         if (ret)
1005                 return ret;
1006
1007         return 0;
1008 }
1009
1010 /**
1011  * Parse the rule to see if it is a flex byte rule.
1012  * And get the flex byte filter info BTW.
1013  * pattern:
1014  * The first not void item must be RAW.
1015  * The second not void item can be RAW or END.
1016  * The third not void item can be RAW or END.
1017  * The last not void item must be END.
1018  * action:
1019  * The first not void action should be QUEUE.
1020  * The next not void action should be END.
1021  * pattern example:
1022  * ITEM         Spec                    Mask
1023  * RAW          relative        0               0x1
1024  *                      offset  0               0xFFFFFFFF
1025  *                      pattern {0x08, 0x06}            {0xFF, 0xFF}
1026  * RAW          relative        1               0x1
1027  *                      offset  100             0xFFFFFFFF
1028  *                      pattern {0x11, 0x22, 0x33}      {0xFF, 0xFF, 0xFF}
1029  * END
1030  * other members in mask and spec should set to 0x00.
1031  * item->last should be NULL.
1032  */
1033 static int
1034 cons_parse_flex_filter(const struct rte_flow_attr *attr,
1035                                 const struct rte_flow_item pattern[],
1036                                 const struct rte_flow_action actions[],
1037                                 struct rte_eth_flex_filter *filter,
1038                                 struct rte_flow_error *error)
1039 {
1040         const struct rte_flow_item *item;
1041         const struct rte_flow_action *act;
1042         const struct rte_flow_item_raw *raw_spec;
1043         const struct rte_flow_item_raw *raw_mask;
1044         const struct rte_flow_action_queue *act_q;
1045         uint32_t index, i, offset, total_offset;
1046         uint32_t max_offset = 0;
1047         int32_t shift, j, raw_index = 0;
1048         int32_t relative[IGB_FLEX_RAW_NUM] = {0};
1049         int32_t raw_offset[IGB_FLEX_RAW_NUM] = {0};
1050
1051         if (!pattern) {
1052                 rte_flow_error_set(error, EINVAL,
1053                                 RTE_FLOW_ERROR_TYPE_ITEM_NUM,
1054                                 NULL, "NULL pattern.");
1055                 return -rte_errno;
1056         }
1057
1058         if (!actions) {
1059                 rte_flow_error_set(error, EINVAL,
1060                                 RTE_FLOW_ERROR_TYPE_ACTION_NUM,
1061                                 NULL, "NULL action.");
1062                 return -rte_errno;
1063         }
1064
1065         if (!attr) {
1066                 rte_flow_error_set(error, EINVAL,
1067                                    RTE_FLOW_ERROR_TYPE_ATTR,
1068                                    NULL, "NULL attribute.");
1069                 return -rte_errno;
1070         }
1071
1072         /* parse pattern */
1073         index = 0;
1074
1075 item_loop:
1076
1077         /* the first not void item should be RAW */
1078         NEXT_ITEM_OF_PATTERN(item, pattern, index);
1079         if (item->type != RTE_FLOW_ITEM_TYPE_RAW) {
1080                 rte_flow_error_set(error, EINVAL,
1081                                 RTE_FLOW_ERROR_TYPE_ITEM,
1082                                 item, "Not supported by flex filter");
1083                 return -rte_errno;
1084         }
1085                 /*Not supported last point for range*/
1086         if (item->last) {
1087                 rte_flow_error_set(error, EINVAL,
1088                         RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
1089                         item, "Not supported last point for range");
1090                 return -rte_errno;
1091         }
1092
1093         raw_spec = item->spec;
1094         raw_mask = item->mask;
1095
1096         if (!raw_mask->length ||
1097             !raw_mask->relative) {
1098                 memset(filter, 0, sizeof(struct rte_eth_flex_filter));
1099                 rte_flow_error_set(error, EINVAL,
1100                                 RTE_FLOW_ERROR_TYPE_ITEM,
1101                                 item, "Not supported by flex filter");
1102                 return -rte_errno;
1103         }
1104
1105         if (raw_mask->offset)
1106                 offset = raw_spec->offset;
1107         else
1108                 offset = 0;
1109
1110         for (j = 0; j < raw_spec->length; j++) {
1111                 if (raw_mask->pattern[j] != 0xFF) {
1112                         memset(filter, 0, sizeof(struct rte_eth_flex_filter));
1113                         rte_flow_error_set(error, EINVAL,
1114                                         RTE_FLOW_ERROR_TYPE_ITEM,
1115                                         item, "Not supported by flex filter");
1116                         return -rte_errno;
1117                 }
1118         }
1119
1120         total_offset = 0;
1121
1122         if (raw_spec->relative) {
1123                 for (j = raw_index; j > 0; j--) {
1124                         total_offset += raw_offset[j - 1];
1125                         if (!relative[j - 1])
1126                                 break;
1127                 }
1128                 if (total_offset + raw_spec->length + offset > max_offset)
1129                         max_offset = total_offset + raw_spec->length + offset;
1130         } else {
1131                 if (raw_spec->length + offset > max_offset)
1132                         max_offset = raw_spec->length + offset;
1133         }
1134
1135         if ((raw_spec->length + offset + total_offset) >
1136                         RTE_FLEX_FILTER_MAXLEN) {
1137                 memset(filter, 0, sizeof(struct rte_eth_flex_filter));
1138                 rte_flow_error_set(error, EINVAL,
1139                                 RTE_FLOW_ERROR_TYPE_ITEM,
1140                                 item, "Not supported by flex filter");
1141                 return -rte_errno;
1142         }
1143
1144         if (raw_spec->relative == 0) {
1145                 for (j = 0; j < raw_spec->length; j++)
1146                         filter->bytes[offset + j] =
1147                         raw_spec->pattern[j];
1148                 j = offset / CHAR_BIT;
1149                 shift = offset % CHAR_BIT;
1150         } else {
1151                 for (j = 0; j < raw_spec->length; j++)
1152                         filter->bytes[total_offset + offset + j] =
1153                                 raw_spec->pattern[j];
1154                 j = (total_offset + offset) / CHAR_BIT;
1155                 shift = (total_offset + offset) % CHAR_BIT;
1156         }
1157
1158         i = 0;
1159
1160         for ( ; shift < CHAR_BIT; shift++) {
1161                 filter->mask[j] |= (0x80 >> shift);
1162                 i++;
1163                 if (i == raw_spec->length)
1164                         break;
1165                 if (shift == (CHAR_BIT - 1)) {
1166                         j++;
1167                         shift = -1;
1168                 }
1169         }
1170
1171         relative[raw_index] = raw_spec->relative;
1172         raw_offset[raw_index] = offset + raw_spec->length;
1173         raw_index++;
1174
1175         /* check if the next not void item is RAW */
1176         index++;
1177         NEXT_ITEM_OF_PATTERN(item, pattern, index);
1178         if (item->type != RTE_FLOW_ITEM_TYPE_RAW &&
1179                 item->type != RTE_FLOW_ITEM_TYPE_END) {
1180                 rte_flow_error_set(error, EINVAL,
1181                                 RTE_FLOW_ERROR_TYPE_ITEM,
1182                                 item, "Not supported by flex filter");
1183                 return -rte_errno;
1184         }
1185
1186         /* go back to parser */
1187         if (item->type == RTE_FLOW_ITEM_TYPE_RAW) {
1188                 /* if the item is RAW, the content should be parse */
1189                 goto item_loop;
1190         }
1191
1192         filter->len = RTE_ALIGN(max_offset, 8);
1193
1194         /* parse action */
1195         index = 0;
1196
1197         /* check if the first not void action is QUEUE. */
1198         NEXT_ITEM_OF_ACTION(act, actions, index);
1199         if (act->type != RTE_FLOW_ACTION_TYPE_QUEUE) {
1200                 memset(filter, 0, sizeof(struct rte_eth_flex_filter));
1201                 rte_flow_error_set(error, EINVAL,
1202                                 RTE_FLOW_ERROR_TYPE_ACTION,
1203                                 act, "Not supported action.");
1204                 return -rte_errno;
1205         }
1206
1207         act_q = (const struct rte_flow_action_queue *)act->conf;
1208         filter->queue = act_q->index;
1209
1210         /* check if the next not void item is END */
1211         index++;
1212         NEXT_ITEM_OF_ACTION(act, actions, index);
1213         if (act->type != RTE_FLOW_ACTION_TYPE_END) {
1214                 memset(filter, 0, sizeof(struct rte_eth_flex_filter));
1215                 rte_flow_error_set(error, EINVAL,
1216                                 RTE_FLOW_ERROR_TYPE_ACTION,
1217                                 act, "Not supported action.");
1218                 return -rte_errno;
1219         }
1220
1221         /* parse attr */
1222         /* must be input direction */
1223         if (!attr->ingress) {
1224                 memset(filter, 0, sizeof(struct rte_eth_flex_filter));
1225                 rte_flow_error_set(error, EINVAL,
1226                         RTE_FLOW_ERROR_TYPE_ATTR_INGRESS,
1227                         attr, "Only support ingress.");
1228                 return -rte_errno;
1229         }
1230
1231         /* not supported */
1232         if (attr->egress) {
1233                 memset(filter, 0, sizeof(struct rte_eth_flex_filter));
1234                 rte_flow_error_set(error, EINVAL,
1235                         RTE_FLOW_ERROR_TYPE_ATTR_EGRESS,
1236                         attr, "Not support egress.");
1237                 return -rte_errno;
1238         }
1239
1240         /* not supported */
1241         if (attr->transfer) {
1242                 memset(filter, 0, sizeof(struct rte_eth_flex_filter));
1243                 rte_flow_error_set(error, EINVAL,
1244                         RTE_FLOW_ERROR_TYPE_ATTR_TRANSFER,
1245                         attr, "No support for transfer.");
1246                 return -rte_errno;
1247         }
1248
1249         if (attr->priority > 0xFFFF) {
1250                 memset(filter, 0, sizeof(struct rte_eth_flex_filter));
1251                 rte_flow_error_set(error, EINVAL,
1252                                    RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY,
1253                                    attr, "Error priority.");
1254                 return -rte_errno;
1255         }
1256
1257         filter->priority = (uint16_t)attr->priority;
1258
1259         return 0;
1260 }
1261
1262 static int
1263 igb_parse_flex_filter(struct rte_eth_dev *dev,
1264                                  const struct rte_flow_attr *attr,
1265                              const struct rte_flow_item pattern[],
1266                              const struct rte_flow_action actions[],
1267                              struct rte_eth_flex_filter *filter,
1268                              struct rte_flow_error *error)
1269 {
1270         struct e1000_hw *hw = E1000_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1271         int ret;
1272
1273         MAC_TYPE_FILTER_SUP_EXT(hw->mac.type);
1274
1275         ret = cons_parse_flex_filter(attr, pattern,
1276                                         actions, filter, error);
1277
1278         if (filter->queue >= IGB_MAX_RX_QUEUE_NUM) {
1279                 memset(filter, 0, sizeof(struct rte_eth_flex_filter));
1280                 rte_flow_error_set(error, EINVAL,
1281                         RTE_FLOW_ERROR_TYPE_ITEM,
1282                         NULL, "queue number not supported by flex filter");
1283                 return -rte_errno;
1284         }
1285
1286         if (filter->len == 0 || filter->len > E1000_MAX_FLEX_FILTER_LEN ||
1287                 filter->len % sizeof(uint64_t) != 0) {
1288                 PMD_DRV_LOG(ERR, "filter's length is out of range");
1289                 return -EINVAL;
1290         }
1291
1292         if (filter->priority > E1000_MAX_FLEX_FILTER_PRI) {
1293                 PMD_DRV_LOG(ERR, "filter's priority is out of range");
1294                 return -EINVAL;
1295         }
1296
1297         if (ret)
1298                 return ret;
1299
1300         return 0;
1301 }
1302
1303 static int
1304 igb_parse_rss_filter(struct rte_eth_dev *dev,
1305                         const struct rte_flow_attr *attr,
1306                         const struct rte_flow_action actions[],
1307                         struct igb_rte_flow_rss_conf *rss_conf,
1308                         struct rte_flow_error *error)
1309 {
1310         struct e1000_hw *hw = E1000_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1311         const struct rte_flow_action *act;
1312         const struct rte_flow_action_rss *rss;
1313         uint16_t n, index;
1314
1315         /**
1316          * rss only supports forwarding,
1317          * check if the first not void action is RSS.
1318          */
1319         index = 0;
1320         NEXT_ITEM_OF_ACTION(act, actions, index);
1321         if (act->type != RTE_FLOW_ACTION_TYPE_RSS) {
1322                 memset(rss_conf, 0, sizeof(struct igb_rte_flow_rss_conf));
1323                 rte_flow_error_set(error, EINVAL,
1324                         RTE_FLOW_ERROR_TYPE_ACTION,
1325                         act, "Not supported action.");
1326                 return -rte_errno;
1327         }
1328
1329         rss = (const struct rte_flow_action_rss *)act->conf;
1330
1331         if (!rss || !rss->queue_num) {
1332                 rte_flow_error_set(error, EINVAL,
1333                                 RTE_FLOW_ERROR_TYPE_ACTION,
1334                                 act,
1335                            "no valid queues");
1336                 return -rte_errno;
1337         }
1338
1339         for (n = 0; n < rss->queue_num; n++) {
1340                 if (rss->queue[n] >= dev->data->nb_rx_queues) {
1341                         rte_flow_error_set(error, EINVAL,
1342                                    RTE_FLOW_ERROR_TYPE_ACTION,
1343                                    act,
1344                                    "queue id > max number of queues");
1345                         return -rte_errno;
1346                 }
1347         }
1348
1349         if (rss->func != RTE_ETH_HASH_FUNCTION_DEFAULT)
1350                 return rte_flow_error_set
1351                         (error, ENOTSUP, RTE_FLOW_ERROR_TYPE_ACTION, act,
1352                          "non-default RSS hash functions are not supported");
1353         if (rss->level)
1354                 return rte_flow_error_set
1355                         (error, ENOTSUP, RTE_FLOW_ERROR_TYPE_ACTION, act,
1356                          "a nonzero RSS encapsulation level is not supported");
1357         if (rss->key_len && rss->key_len != RTE_DIM(rss_conf->key))
1358                 return rte_flow_error_set
1359                         (error, ENOTSUP, RTE_FLOW_ERROR_TYPE_ACTION, act,
1360                          "RSS hash key must be exactly 40 bytes");
1361         if (((hw->mac.type == e1000_82576) &&
1362              (rss->queue_num > IGB_MAX_RX_QUEUE_NUM_82576)) ||
1363             ((hw->mac.type != e1000_82576) &&
1364              (rss->queue_num > IGB_MAX_RX_QUEUE_NUM)))
1365                 return rte_flow_error_set
1366                         (error, ENOTSUP, RTE_FLOW_ERROR_TYPE_ACTION, act,
1367                          "too many queues for RSS context");
1368         if (igb_rss_conf_init(dev, rss_conf, rss))
1369                 return rte_flow_error_set
1370                         (error, EINVAL, RTE_FLOW_ERROR_TYPE_ACTION, act,
1371                          "RSS context initialization failure");
1372
1373         /* check if the next not void item is END */
1374         index++;
1375         NEXT_ITEM_OF_ACTION(act, actions, index);
1376         if (act->type != RTE_FLOW_ACTION_TYPE_END) {
1377                 memset(rss_conf, 0, sizeof(struct rte_eth_rss_conf));
1378                 rte_flow_error_set(error, EINVAL,
1379                         RTE_FLOW_ERROR_TYPE_ACTION,
1380                         act, "Not supported action.");
1381                 return -rte_errno;
1382         }
1383
1384         /* parse attr */
1385         /* must be input direction */
1386         if (!attr->ingress) {
1387                 memset(rss_conf, 0, sizeof(struct igb_rte_flow_rss_conf));
1388                 rte_flow_error_set(error, EINVAL,
1389                                    RTE_FLOW_ERROR_TYPE_ATTR_INGRESS,
1390                                    attr, "Only support ingress.");
1391                 return -rte_errno;
1392         }
1393
1394         /* not supported */
1395         if (attr->egress) {
1396                 memset(rss_conf, 0, sizeof(struct igb_rte_flow_rss_conf));
1397                 rte_flow_error_set(error, EINVAL,
1398                                    RTE_FLOW_ERROR_TYPE_ATTR_EGRESS,
1399                                    attr, "Not support egress.");
1400                 return -rte_errno;
1401         }
1402
1403         /* not supported */
1404         if (attr->transfer) {
1405                 memset(rss_conf, 0, sizeof(struct igb_rte_flow_rss_conf));
1406                 rte_flow_error_set(error, EINVAL,
1407                                    RTE_FLOW_ERROR_TYPE_ATTR_TRANSFER,
1408                                    attr, "No support for transfer.");
1409                 return -rte_errno;
1410         }
1411
1412         if (attr->priority > 0xFFFF) {
1413                 memset(rss_conf, 0, sizeof(struct igb_rte_flow_rss_conf));
1414                 rte_flow_error_set(error, EINVAL,
1415                                    RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY,
1416                                    attr, "Error priority.");
1417                 return -rte_errno;
1418         }
1419
1420         return 0;
1421 }
1422
1423 /**
1424  * Create a flow rule.
1425  * Theorically one rule can match more than one filters.
1426  * We will let it use the filter which it hitt first.
1427  * So, the sequence matters.
1428  */
1429 static struct rte_flow *
1430 igb_flow_create(struct rte_eth_dev *dev,
1431                   const struct rte_flow_attr *attr,
1432                   const struct rte_flow_item pattern[],
1433                   const struct rte_flow_action actions[],
1434                   struct rte_flow_error *error)
1435 {
1436         int ret;
1437         struct rte_eth_ntuple_filter ntuple_filter;
1438         struct rte_eth_ethertype_filter ethertype_filter;
1439         struct rte_eth_syn_filter syn_filter;
1440         struct rte_eth_flex_filter flex_filter;
1441         struct igb_rte_flow_rss_conf rss_conf;
1442         struct rte_flow *flow = NULL;
1443         struct igb_ntuple_filter_ele *ntuple_filter_ptr;
1444         struct igb_ethertype_filter_ele *ethertype_filter_ptr;
1445         struct igb_eth_syn_filter_ele *syn_filter_ptr;
1446         struct igb_flex_filter_ele *flex_filter_ptr;
1447         struct igb_rss_conf_ele *rss_filter_ptr;
1448         struct igb_flow_mem *igb_flow_mem_ptr;
1449
1450         flow = rte_zmalloc("igb_rte_flow", sizeof(struct rte_flow), 0);
1451         if (!flow) {
1452                 PMD_DRV_LOG(ERR, "failed to allocate memory");
1453                 return (struct rte_flow *)flow;
1454         }
1455         igb_flow_mem_ptr = rte_zmalloc("igb_flow_mem",
1456                         sizeof(struct igb_flow_mem), 0);
1457         if (!igb_flow_mem_ptr) {
1458                 PMD_DRV_LOG(ERR, "failed to allocate memory");
1459                 rte_free(flow);
1460                 return NULL;
1461         }
1462         igb_flow_mem_ptr->flow = flow;
1463         igb_flow_mem_ptr->dev = dev;
1464         TAILQ_INSERT_TAIL(&igb_flow_list,
1465                                 igb_flow_mem_ptr, entries);
1466
1467         memset(&ntuple_filter, 0, sizeof(struct rte_eth_ntuple_filter));
1468         ret = igb_parse_ntuple_filter(dev, attr, pattern,
1469                         actions, &ntuple_filter, error);
1470         if (!ret) {
1471                 ret = igb_add_del_ntuple_filter(dev, &ntuple_filter, TRUE);
1472                 if (!ret) {
1473                         ntuple_filter_ptr = rte_zmalloc("igb_ntuple_filter",
1474                                 sizeof(struct igb_ntuple_filter_ele), 0);
1475                         if (!ntuple_filter_ptr) {
1476                                 PMD_DRV_LOG(ERR, "failed to allocate memory");
1477                                 goto out;
1478                         }
1479
1480                         rte_memcpy(&ntuple_filter_ptr->filter_info,
1481                                 &ntuple_filter,
1482                                 sizeof(struct rte_eth_ntuple_filter));
1483                         TAILQ_INSERT_TAIL(&igb_filter_ntuple_list,
1484                                 ntuple_filter_ptr, entries);
1485                         flow->rule = ntuple_filter_ptr;
1486                         flow->filter_type = RTE_ETH_FILTER_NTUPLE;
1487                         return flow;
1488                 }
1489                 goto out;
1490         }
1491
1492         memset(&ethertype_filter, 0, sizeof(struct rte_eth_ethertype_filter));
1493         ret = igb_parse_ethertype_filter(dev, attr, pattern,
1494                                 actions, &ethertype_filter, error);
1495         if (!ret) {
1496                 ret = igb_add_del_ethertype_filter(dev,
1497                                 &ethertype_filter, TRUE);
1498                 if (!ret) {
1499                         ethertype_filter_ptr = rte_zmalloc(
1500                                 "igb_ethertype_filter",
1501                                 sizeof(struct igb_ethertype_filter_ele), 0);
1502                         if (!ethertype_filter_ptr) {
1503                                 PMD_DRV_LOG(ERR, "failed to allocate memory");
1504                                 goto out;
1505                         }
1506
1507                         rte_memcpy(&ethertype_filter_ptr->filter_info,
1508                                 &ethertype_filter,
1509                                 sizeof(struct rte_eth_ethertype_filter));
1510                         TAILQ_INSERT_TAIL(&igb_filter_ethertype_list,
1511                                 ethertype_filter_ptr, entries);
1512                         flow->rule = ethertype_filter_ptr;
1513                         flow->filter_type = RTE_ETH_FILTER_ETHERTYPE;
1514                         return flow;
1515                 }
1516                 goto out;
1517         }
1518
1519         memset(&syn_filter, 0, sizeof(struct rte_eth_syn_filter));
1520         ret = igb_parse_syn_filter(dev, attr, pattern,
1521                                 actions, &syn_filter, error);
1522         if (!ret) {
1523                 ret = eth_igb_syn_filter_set(dev, &syn_filter, TRUE);
1524                 if (!ret) {
1525                         syn_filter_ptr = rte_zmalloc("igb_syn_filter",
1526                                 sizeof(struct igb_eth_syn_filter_ele), 0);
1527                         if (!syn_filter_ptr) {
1528                                 PMD_DRV_LOG(ERR, "failed to allocate memory");
1529                                 goto out;
1530                         }
1531
1532                         rte_memcpy(&syn_filter_ptr->filter_info,
1533                                 &syn_filter,
1534                                 sizeof(struct rte_eth_syn_filter));
1535                         TAILQ_INSERT_TAIL(&igb_filter_syn_list,
1536                                 syn_filter_ptr,
1537                                 entries);
1538                         flow->rule = syn_filter_ptr;
1539                         flow->filter_type = RTE_ETH_FILTER_SYN;
1540                         return flow;
1541                 }
1542                 goto out;
1543         }
1544
1545         memset(&flex_filter, 0, sizeof(struct rte_eth_flex_filter));
1546         ret = igb_parse_flex_filter(dev, attr, pattern,
1547                                         actions, &flex_filter, error);
1548         if (!ret) {
1549                 ret = eth_igb_add_del_flex_filter(dev, &flex_filter, TRUE);
1550                 if (!ret) {
1551                         flex_filter_ptr = rte_zmalloc("igb_flex_filter",
1552                                 sizeof(struct igb_flex_filter_ele), 0);
1553                         if (!flex_filter_ptr) {
1554                                 PMD_DRV_LOG(ERR, "failed to allocate memory");
1555                                 goto out;
1556                         }
1557
1558                         rte_memcpy(&flex_filter_ptr->filter_info,
1559                                 &flex_filter,
1560                                 sizeof(struct rte_eth_flex_filter));
1561                         TAILQ_INSERT_TAIL(&igb_filter_flex_list,
1562                                 flex_filter_ptr, entries);
1563                         flow->rule = flex_filter_ptr;
1564                         flow->filter_type = RTE_ETH_FILTER_FLEXIBLE;
1565                         return flow;
1566                 }
1567         }
1568
1569         memset(&rss_conf, 0, sizeof(struct igb_rte_flow_rss_conf));
1570         ret = igb_parse_rss_filter(dev, attr,
1571                                         actions, &rss_conf, error);
1572         if (!ret) {
1573                 ret = igb_config_rss_filter(dev, &rss_conf, TRUE);
1574                 if (!ret) {
1575                         rss_filter_ptr = rte_zmalloc("igb_rss_filter",
1576                                 sizeof(struct igb_rss_conf_ele), 0);
1577                         if (!rss_filter_ptr) {
1578                                 PMD_DRV_LOG(ERR, "failed to allocate memory");
1579                                 goto out;
1580                         }
1581                         igb_rss_conf_init(dev, &rss_filter_ptr->filter_info,
1582                                           &rss_conf.conf);
1583                         TAILQ_INSERT_TAIL(&igb_filter_rss_list,
1584                                 rss_filter_ptr, entries);
1585                         flow->rule = rss_filter_ptr;
1586                         flow->filter_type = RTE_ETH_FILTER_HASH;
1587                         return flow;
1588                 }
1589         }
1590
1591 out:
1592         TAILQ_REMOVE(&igb_flow_list,
1593                 igb_flow_mem_ptr, entries);
1594         rte_flow_error_set(error, -ret,
1595                            RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
1596                            "Failed to create flow.");
1597         rte_free(igb_flow_mem_ptr);
1598         rte_free(flow);
1599         return NULL;
1600 }
1601
1602 /**
1603  * Check if the flow rule is supported by igb.
1604  * It only checkes the format. Don't guarantee the rule can be programmed into
1605  * the HW. Because there can be no enough room for the rule.
1606  */
1607 static int
1608 igb_flow_validate(__rte_unused struct rte_eth_dev *dev,
1609                 const struct rte_flow_attr *attr,
1610                 const struct rte_flow_item pattern[],
1611                 const struct rte_flow_action actions[],
1612                 struct rte_flow_error *error)
1613 {
1614         struct rte_eth_ntuple_filter ntuple_filter;
1615         struct rte_eth_ethertype_filter ethertype_filter;
1616         struct rte_eth_syn_filter syn_filter;
1617         struct rte_eth_flex_filter flex_filter;
1618         struct igb_rte_flow_rss_conf rss_conf;
1619         int ret;
1620
1621         memset(&ntuple_filter, 0, sizeof(struct rte_eth_ntuple_filter));
1622         ret = igb_parse_ntuple_filter(dev, attr, pattern,
1623                                 actions, &ntuple_filter, error);
1624         if (!ret)
1625                 return 0;
1626
1627         memset(&ethertype_filter, 0, sizeof(struct rte_eth_ethertype_filter));
1628         ret = igb_parse_ethertype_filter(dev, attr, pattern,
1629                                 actions, &ethertype_filter, error);
1630         if (!ret)
1631                 return 0;
1632
1633         memset(&syn_filter, 0, sizeof(struct rte_eth_syn_filter));
1634         ret = igb_parse_syn_filter(dev, attr, pattern,
1635                                 actions, &syn_filter, error);
1636         if (!ret)
1637                 return 0;
1638
1639         memset(&flex_filter, 0, sizeof(struct rte_eth_flex_filter));
1640         ret = igb_parse_flex_filter(dev, attr, pattern,
1641                                 actions, &flex_filter, error);
1642         if (!ret)
1643                 return 0;
1644
1645         memset(&rss_conf, 0, sizeof(struct igb_rte_flow_rss_conf));
1646         ret = igb_parse_rss_filter(dev, attr,
1647                                         actions, &rss_conf, error);
1648
1649         return ret;
1650 }
1651
1652 /* Destroy a flow rule on igb. */
1653 static int
1654 igb_flow_destroy(struct rte_eth_dev *dev,
1655                 struct rte_flow *flow,
1656                 struct rte_flow_error *error)
1657 {
1658         int ret;
1659         struct rte_flow *pmd_flow = flow;
1660         enum rte_filter_type filter_type = pmd_flow->filter_type;
1661         struct igb_ntuple_filter_ele *ntuple_filter_ptr;
1662         struct igb_ethertype_filter_ele *ethertype_filter_ptr;
1663         struct igb_eth_syn_filter_ele *syn_filter_ptr;
1664         struct igb_flex_filter_ele *flex_filter_ptr;
1665         struct igb_flow_mem *igb_flow_mem_ptr;
1666         struct igb_rss_conf_ele *rss_filter_ptr;
1667
1668         switch (filter_type) {
1669         case RTE_ETH_FILTER_NTUPLE:
1670                 ntuple_filter_ptr = (struct igb_ntuple_filter_ele *)
1671                                         pmd_flow->rule;
1672                 ret = igb_add_del_ntuple_filter(dev,
1673                                 &ntuple_filter_ptr->filter_info, FALSE);
1674                 if (!ret) {
1675                         TAILQ_REMOVE(&igb_filter_ntuple_list,
1676                         ntuple_filter_ptr, entries);
1677                         rte_free(ntuple_filter_ptr);
1678                 }
1679                 break;
1680         case RTE_ETH_FILTER_ETHERTYPE:
1681                 ethertype_filter_ptr = (struct igb_ethertype_filter_ele *)
1682                                         pmd_flow->rule;
1683                 ret = igb_add_del_ethertype_filter(dev,
1684                                 &ethertype_filter_ptr->filter_info, FALSE);
1685                 if (!ret) {
1686                         TAILQ_REMOVE(&igb_filter_ethertype_list,
1687                                 ethertype_filter_ptr, entries);
1688                         rte_free(ethertype_filter_ptr);
1689                 }
1690                 break;
1691         case RTE_ETH_FILTER_SYN:
1692                 syn_filter_ptr = (struct igb_eth_syn_filter_ele *)
1693                                 pmd_flow->rule;
1694                 ret = eth_igb_syn_filter_set(dev,
1695                                 &syn_filter_ptr->filter_info, FALSE);
1696                 if (!ret) {
1697                         TAILQ_REMOVE(&igb_filter_syn_list,
1698                                 syn_filter_ptr, entries);
1699                         rte_free(syn_filter_ptr);
1700                 }
1701                 break;
1702         case RTE_ETH_FILTER_FLEXIBLE:
1703                 flex_filter_ptr = (struct igb_flex_filter_ele *)
1704                                 pmd_flow->rule;
1705                 ret = eth_igb_add_del_flex_filter(dev,
1706                                 &flex_filter_ptr->filter_info, FALSE);
1707                 if (!ret) {
1708                         TAILQ_REMOVE(&igb_filter_flex_list,
1709                                 flex_filter_ptr, entries);
1710                         rte_free(flex_filter_ptr);
1711                 }
1712                 break;
1713         case RTE_ETH_FILTER_HASH:
1714                 rss_filter_ptr = (struct igb_rss_conf_ele *)
1715                                 pmd_flow->rule;
1716                 ret = igb_config_rss_filter(dev,
1717                                         &rss_filter_ptr->filter_info, FALSE);
1718                 if (!ret) {
1719                         TAILQ_REMOVE(&igb_filter_rss_list,
1720                                 rss_filter_ptr, entries);
1721                         rte_free(rss_filter_ptr);
1722                 }
1723                 break;
1724         default:
1725                 PMD_DRV_LOG(WARNING, "Filter type (%d) not supported",
1726                             filter_type);
1727                 ret = -EINVAL;
1728                 break;
1729         }
1730
1731         if (ret) {
1732                 rte_flow_error_set(error, EINVAL,
1733                                 RTE_FLOW_ERROR_TYPE_HANDLE,
1734                                 NULL, "Failed to destroy flow");
1735                 return ret;
1736         }
1737
1738         TAILQ_FOREACH(igb_flow_mem_ptr, &igb_flow_list, entries) {
1739                 if (igb_flow_mem_ptr->flow == pmd_flow) {
1740                         TAILQ_REMOVE(&igb_flow_list,
1741                                 igb_flow_mem_ptr, entries);
1742                         rte_free(igb_flow_mem_ptr);
1743                 }
1744         }
1745         rte_free(flow);
1746
1747         return ret;
1748 }
1749
1750 /* remove all the n-tuple filters */
1751 static void
1752 igb_clear_all_ntuple_filter(struct rte_eth_dev *dev)
1753 {
1754         struct e1000_filter_info *filter_info =
1755                 E1000_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private);
1756         struct e1000_5tuple_filter *p_5tuple;
1757         struct e1000_2tuple_filter *p_2tuple;
1758
1759         while ((p_5tuple = TAILQ_FIRST(&filter_info->fivetuple_list)))
1760                 igb_delete_5tuple_filter_82576(dev, p_5tuple);
1761
1762         while ((p_2tuple = TAILQ_FIRST(&filter_info->twotuple_list)))
1763                 igb_delete_2tuple_filter(dev, p_2tuple);
1764 }
1765
1766 /* remove all the ether type filters */
1767 static void
1768 igb_clear_all_ethertype_filter(struct rte_eth_dev *dev)
1769 {
1770         struct e1000_hw *hw = E1000_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1771         struct e1000_filter_info *filter_info =
1772                 E1000_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private);
1773         int i;
1774
1775         for (i = 0; i < E1000_MAX_ETQF_FILTERS; i++) {
1776                 if (filter_info->ethertype_mask & (1 << i)) {
1777                         (void)igb_ethertype_filter_remove(filter_info,
1778                                                             (uint8_t)i);
1779                         E1000_WRITE_REG(hw, E1000_ETQF(i), 0);
1780                         E1000_WRITE_FLUSH(hw);
1781                 }
1782         }
1783 }
1784
1785 /* remove the SYN filter */
1786 static void
1787 igb_clear_syn_filter(struct rte_eth_dev *dev)
1788 {
1789         struct e1000_hw *hw = E1000_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1790         struct e1000_filter_info *filter_info =
1791                 E1000_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private);
1792
1793         if (filter_info->syn_info & E1000_SYN_FILTER_ENABLE) {
1794                 filter_info->syn_info = 0;
1795                 E1000_WRITE_REG(hw, E1000_SYNQF(0), 0);
1796                 E1000_WRITE_FLUSH(hw);
1797         }
1798 }
1799
1800 /* remove all the flex filters */
1801 static void
1802 igb_clear_all_flex_filter(struct rte_eth_dev *dev)
1803 {
1804         struct e1000_filter_info *filter_info =
1805                 E1000_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private);
1806         struct e1000_flex_filter *flex_filter;
1807
1808         while ((flex_filter = TAILQ_FIRST(&filter_info->flex_list)))
1809                 igb_remove_flex_filter(dev, flex_filter);
1810 }
1811
1812 /* remove the rss filter */
1813 static void
1814 igb_clear_rss_filter(struct rte_eth_dev *dev)
1815 {
1816         struct e1000_filter_info *filter =
1817                 E1000_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private);
1818
1819         if (filter->rss_info.conf.queue_num)
1820                 igb_config_rss_filter(dev, &filter->rss_info, FALSE);
1821 }
1822
1823 void
1824 igb_filterlist_flush(struct rte_eth_dev *dev)
1825 {
1826         struct igb_ntuple_filter_ele *ntuple_filter_ptr;
1827         struct igb_ethertype_filter_ele *ethertype_filter_ptr;
1828         struct igb_eth_syn_filter_ele *syn_filter_ptr;
1829         struct igb_flex_filter_ele *flex_filter_ptr;
1830         struct igb_rss_conf_ele  *rss_filter_ptr;
1831         struct igb_flow_mem *igb_flow_mem_ptr;
1832         enum rte_filter_type filter_type;
1833         struct rte_flow *pmd_flow;
1834
1835         TAILQ_FOREACH(igb_flow_mem_ptr, &igb_flow_list, entries) {
1836                 if (igb_flow_mem_ptr->dev == dev) {
1837                         pmd_flow = igb_flow_mem_ptr->flow;
1838                         filter_type = pmd_flow->filter_type;
1839
1840                         switch (filter_type) {
1841                         case RTE_ETH_FILTER_NTUPLE:
1842                                 ntuple_filter_ptr =
1843                                 (struct igb_ntuple_filter_ele *)
1844                                         pmd_flow->rule;
1845                                 TAILQ_REMOVE(&igb_filter_ntuple_list,
1846                                                 ntuple_filter_ptr, entries);
1847                                 rte_free(ntuple_filter_ptr);
1848                                 break;
1849                         case RTE_ETH_FILTER_ETHERTYPE:
1850                                 ethertype_filter_ptr =
1851                                 (struct igb_ethertype_filter_ele *)
1852                                         pmd_flow->rule;
1853                                 TAILQ_REMOVE(&igb_filter_ethertype_list,
1854                                                 ethertype_filter_ptr, entries);
1855                                 rte_free(ethertype_filter_ptr);
1856                                 break;
1857                         case RTE_ETH_FILTER_SYN:
1858                                 syn_filter_ptr =
1859                                         (struct igb_eth_syn_filter_ele *)
1860                                                 pmd_flow->rule;
1861                                 TAILQ_REMOVE(&igb_filter_syn_list,
1862                                                 syn_filter_ptr, entries);
1863                                 rte_free(syn_filter_ptr);
1864                                 break;
1865                         case RTE_ETH_FILTER_FLEXIBLE:
1866                                 flex_filter_ptr =
1867                                         (struct igb_flex_filter_ele *)
1868                                                 pmd_flow->rule;
1869                                 TAILQ_REMOVE(&igb_filter_flex_list,
1870                                                 flex_filter_ptr, entries);
1871                                 rte_free(flex_filter_ptr);
1872                                 break;
1873                         case RTE_ETH_FILTER_HASH:
1874                                 rss_filter_ptr =
1875                                         (struct igb_rss_conf_ele *)
1876                                                 pmd_flow->rule;
1877                                 TAILQ_REMOVE(&igb_filter_rss_list,
1878                                                 rss_filter_ptr, entries);
1879                                 rte_free(rss_filter_ptr);
1880                                 break;
1881                         default:
1882                                 PMD_DRV_LOG(WARNING, "Filter type"
1883                                         "(%d) not supported", filter_type);
1884                                 break;
1885                         }
1886                         TAILQ_REMOVE(&igb_flow_list,
1887                                  igb_flow_mem_ptr,
1888                                  entries);
1889                         rte_free(igb_flow_mem_ptr->flow);
1890                         rte_free(igb_flow_mem_ptr);
1891                 }
1892         }
1893 }
1894
1895 /*  Destroy all flow rules associated with a port on igb. */
1896 static int
1897 igb_flow_flush(struct rte_eth_dev *dev,
1898                 __rte_unused struct rte_flow_error *error)
1899 {
1900         igb_clear_all_ntuple_filter(dev);
1901         igb_clear_all_ethertype_filter(dev);
1902         igb_clear_syn_filter(dev);
1903         igb_clear_all_flex_filter(dev);
1904         igb_clear_rss_filter(dev);
1905         igb_filterlist_flush(dev);
1906
1907         return 0;
1908 }
1909
1910 const struct rte_flow_ops igb_flow_ops = {
1911         .validate = igb_flow_validate,
1912         .create = igb_flow_create,
1913         .destroy = igb_flow_destroy,
1914         .flush = igb_flow_flush,
1915 };