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 (!rte_is_zero_ether_addr(ð_mask->src) || 552 (!rte_is_zero_ether_addr(ð_mask->dst) && 553 !rte_is_broadcast_ether_addr(ð_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 (rte_is_broadcast_ether_addr(ð_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 == RTE_ETHER_TYPE_IPV4 || 704 filter->ether_type == RTE_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 & RTE_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 != RTE_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(ðertype_filter, 0, sizeof(struct rte_eth_ethertype_filter)); 1493 ret = igb_parse_ethertype_filter(dev, attr, pattern, 1494 actions, ðertype_filter, error); 1495 if (!ret) { 1496 ret = igb_add_del_ethertype_filter(dev, 1497 ðertype_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(ðertype_filter_ptr->filter_info, 1508 ðertype_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(ðertype_filter, 0, sizeof(struct rte_eth_ethertype_filter)); 1628 ret = igb_parse_ethertype_filter(dev, attr, pattern, 1629 actions, ðertype_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 ðertype_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 }; 1916