1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2019 Intel Corporation 3 */ 4 5 #include <sys/queue.h> 6 #include <stdio.h> 7 #include <errno.h> 8 #include <stdint.h> 9 #include <string.h> 10 #include <unistd.h> 11 #include <stdarg.h> 12 13 #include <rte_ether.h> 14 #include <rte_ethdev_driver.h> 15 #include <rte_malloc.h> 16 #include <rte_tailq.h> 17 18 #include "iavf.h" 19 #include "iavf_generic_flow.h" 20 21 static struct iavf_engine_list engine_list = 22 TAILQ_HEAD_INITIALIZER(engine_list); 23 24 static int iavf_flow_validate(struct rte_eth_dev *dev, 25 const struct rte_flow_attr *attr, 26 const struct rte_flow_item pattern[], 27 const struct rte_flow_action actions[], 28 struct rte_flow_error *error); 29 static struct rte_flow *iavf_flow_create(struct rte_eth_dev *dev, 30 const struct rte_flow_attr *attr, 31 const struct rte_flow_item pattern[], 32 const struct rte_flow_action actions[], 33 struct rte_flow_error *error); 34 static int iavf_flow_destroy(struct rte_eth_dev *dev, 35 struct rte_flow *flow, 36 struct rte_flow_error *error); 37 static int iavf_flow_query(struct rte_eth_dev *dev, 38 struct rte_flow *flow, 39 const struct rte_flow_action *actions, 40 void *data, 41 struct rte_flow_error *error); 42 43 const struct rte_flow_ops iavf_flow_ops = { 44 .validate = iavf_flow_validate, 45 .create = iavf_flow_create, 46 .destroy = iavf_flow_destroy, 47 .flush = iavf_flow_flush, 48 .query = iavf_flow_query, 49 }; 50 51 /* empty */ 52 enum rte_flow_item_type iavf_pattern_empty[] = { 53 RTE_FLOW_ITEM_TYPE_END, 54 }; 55 56 /* L2 */ 57 enum rte_flow_item_type iavf_pattern_ethertype[] = { 58 RTE_FLOW_ITEM_TYPE_ETH, 59 RTE_FLOW_ITEM_TYPE_END, 60 }; 61 62 enum rte_flow_item_type iavf_pattern_ethertype_vlan[] = { 63 RTE_FLOW_ITEM_TYPE_ETH, 64 RTE_FLOW_ITEM_TYPE_VLAN, 65 RTE_FLOW_ITEM_TYPE_END, 66 }; 67 68 enum rte_flow_item_type iavf_pattern_ethertype_qinq[] = { 69 RTE_FLOW_ITEM_TYPE_ETH, 70 RTE_FLOW_ITEM_TYPE_VLAN, 71 RTE_FLOW_ITEM_TYPE_VLAN, 72 RTE_FLOW_ITEM_TYPE_END, 73 }; 74 75 /* ARP */ 76 enum rte_flow_item_type iavf_pattern_eth_arp[] = { 77 RTE_FLOW_ITEM_TYPE_ETH, 78 RTE_FLOW_ITEM_TYPE_ARP_ETH_IPV4, 79 RTE_FLOW_ITEM_TYPE_END, 80 }; 81 82 /* non-tunnel IPv4 */ 83 enum rte_flow_item_type iavf_pattern_eth_ipv4[] = { 84 RTE_FLOW_ITEM_TYPE_ETH, 85 RTE_FLOW_ITEM_TYPE_IPV4, 86 RTE_FLOW_ITEM_TYPE_END, 87 }; 88 89 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv4[] = { 90 RTE_FLOW_ITEM_TYPE_ETH, 91 RTE_FLOW_ITEM_TYPE_VLAN, 92 RTE_FLOW_ITEM_TYPE_IPV4, 93 RTE_FLOW_ITEM_TYPE_END, 94 }; 95 96 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv4[] = { 97 RTE_FLOW_ITEM_TYPE_ETH, 98 RTE_FLOW_ITEM_TYPE_VLAN, 99 RTE_FLOW_ITEM_TYPE_VLAN, 100 RTE_FLOW_ITEM_TYPE_IPV4, 101 RTE_FLOW_ITEM_TYPE_END, 102 }; 103 104 enum rte_flow_item_type iavf_pattern_eth_ipv4_udp[] = { 105 RTE_FLOW_ITEM_TYPE_ETH, 106 RTE_FLOW_ITEM_TYPE_IPV4, 107 RTE_FLOW_ITEM_TYPE_UDP, 108 RTE_FLOW_ITEM_TYPE_END, 109 }; 110 111 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv4_udp[] = { 112 RTE_FLOW_ITEM_TYPE_ETH, 113 RTE_FLOW_ITEM_TYPE_VLAN, 114 RTE_FLOW_ITEM_TYPE_IPV4, 115 RTE_FLOW_ITEM_TYPE_UDP, 116 RTE_FLOW_ITEM_TYPE_END, 117 }; 118 119 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv4_udp[] = { 120 RTE_FLOW_ITEM_TYPE_ETH, 121 RTE_FLOW_ITEM_TYPE_VLAN, 122 RTE_FLOW_ITEM_TYPE_VLAN, 123 RTE_FLOW_ITEM_TYPE_IPV4, 124 RTE_FLOW_ITEM_TYPE_UDP, 125 RTE_FLOW_ITEM_TYPE_END, 126 }; 127 128 enum rte_flow_item_type iavf_pattern_eth_ipv4_tcp[] = { 129 RTE_FLOW_ITEM_TYPE_ETH, 130 RTE_FLOW_ITEM_TYPE_IPV4, 131 RTE_FLOW_ITEM_TYPE_TCP, 132 RTE_FLOW_ITEM_TYPE_END, 133 }; 134 135 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv4_tcp[] = { 136 RTE_FLOW_ITEM_TYPE_ETH, 137 RTE_FLOW_ITEM_TYPE_VLAN, 138 RTE_FLOW_ITEM_TYPE_IPV4, 139 RTE_FLOW_ITEM_TYPE_TCP, 140 RTE_FLOW_ITEM_TYPE_END, 141 }; 142 143 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv4_tcp[] = { 144 RTE_FLOW_ITEM_TYPE_ETH, 145 RTE_FLOW_ITEM_TYPE_VLAN, 146 RTE_FLOW_ITEM_TYPE_VLAN, 147 RTE_FLOW_ITEM_TYPE_IPV4, 148 RTE_FLOW_ITEM_TYPE_TCP, 149 RTE_FLOW_ITEM_TYPE_END, 150 }; 151 152 enum rte_flow_item_type iavf_pattern_eth_ipv4_sctp[] = { 153 RTE_FLOW_ITEM_TYPE_ETH, 154 RTE_FLOW_ITEM_TYPE_IPV4, 155 RTE_FLOW_ITEM_TYPE_SCTP, 156 RTE_FLOW_ITEM_TYPE_END, 157 }; 158 159 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv4_sctp[] = { 160 RTE_FLOW_ITEM_TYPE_ETH, 161 RTE_FLOW_ITEM_TYPE_VLAN, 162 RTE_FLOW_ITEM_TYPE_IPV4, 163 RTE_FLOW_ITEM_TYPE_SCTP, 164 RTE_FLOW_ITEM_TYPE_END, 165 }; 166 167 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv4_sctp[] = { 168 RTE_FLOW_ITEM_TYPE_ETH, 169 RTE_FLOW_ITEM_TYPE_VLAN, 170 RTE_FLOW_ITEM_TYPE_VLAN, 171 RTE_FLOW_ITEM_TYPE_IPV4, 172 RTE_FLOW_ITEM_TYPE_SCTP, 173 RTE_FLOW_ITEM_TYPE_END, 174 }; 175 176 enum rte_flow_item_type iavf_pattern_eth_ipv4_icmp[] = { 177 RTE_FLOW_ITEM_TYPE_ETH, 178 RTE_FLOW_ITEM_TYPE_IPV4, 179 RTE_FLOW_ITEM_TYPE_ICMP, 180 RTE_FLOW_ITEM_TYPE_END, 181 }; 182 183 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv4_icmp[] = { 184 RTE_FLOW_ITEM_TYPE_ETH, 185 RTE_FLOW_ITEM_TYPE_VLAN, 186 RTE_FLOW_ITEM_TYPE_IPV4, 187 RTE_FLOW_ITEM_TYPE_ICMP, 188 RTE_FLOW_ITEM_TYPE_END, 189 }; 190 191 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv4_icmp[] = { 192 RTE_FLOW_ITEM_TYPE_ETH, 193 RTE_FLOW_ITEM_TYPE_VLAN, 194 RTE_FLOW_ITEM_TYPE_VLAN, 195 RTE_FLOW_ITEM_TYPE_IPV4, 196 RTE_FLOW_ITEM_TYPE_ICMP, 197 RTE_FLOW_ITEM_TYPE_END, 198 }; 199 200 /* non-tunnel IPv6 */ 201 enum rte_flow_item_type iavf_pattern_eth_ipv6[] = { 202 RTE_FLOW_ITEM_TYPE_ETH, 203 RTE_FLOW_ITEM_TYPE_IPV6, 204 RTE_FLOW_ITEM_TYPE_END, 205 }; 206 207 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv6[] = { 208 RTE_FLOW_ITEM_TYPE_ETH, 209 RTE_FLOW_ITEM_TYPE_VLAN, 210 RTE_FLOW_ITEM_TYPE_IPV6, 211 RTE_FLOW_ITEM_TYPE_END, 212 }; 213 214 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv6[] = { 215 RTE_FLOW_ITEM_TYPE_ETH, 216 RTE_FLOW_ITEM_TYPE_VLAN, 217 RTE_FLOW_ITEM_TYPE_VLAN, 218 RTE_FLOW_ITEM_TYPE_IPV6, 219 RTE_FLOW_ITEM_TYPE_END, 220 }; 221 222 enum rte_flow_item_type iavf_pattern_eth_ipv6_udp[] = { 223 RTE_FLOW_ITEM_TYPE_ETH, 224 RTE_FLOW_ITEM_TYPE_IPV6, 225 RTE_FLOW_ITEM_TYPE_UDP, 226 RTE_FLOW_ITEM_TYPE_END, 227 }; 228 229 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv6_udp[] = { 230 RTE_FLOW_ITEM_TYPE_ETH, 231 RTE_FLOW_ITEM_TYPE_VLAN, 232 RTE_FLOW_ITEM_TYPE_IPV6, 233 RTE_FLOW_ITEM_TYPE_UDP, 234 RTE_FLOW_ITEM_TYPE_END, 235 }; 236 237 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv6_udp[] = { 238 RTE_FLOW_ITEM_TYPE_ETH, 239 RTE_FLOW_ITEM_TYPE_VLAN, 240 RTE_FLOW_ITEM_TYPE_VLAN, 241 RTE_FLOW_ITEM_TYPE_IPV6, 242 RTE_FLOW_ITEM_TYPE_UDP, 243 RTE_FLOW_ITEM_TYPE_END, 244 }; 245 246 enum rte_flow_item_type iavf_pattern_eth_ipv6_tcp[] = { 247 RTE_FLOW_ITEM_TYPE_ETH, 248 RTE_FLOW_ITEM_TYPE_IPV6, 249 RTE_FLOW_ITEM_TYPE_TCP, 250 RTE_FLOW_ITEM_TYPE_END, 251 }; 252 253 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv6_tcp[] = { 254 RTE_FLOW_ITEM_TYPE_ETH, 255 RTE_FLOW_ITEM_TYPE_VLAN, 256 RTE_FLOW_ITEM_TYPE_IPV6, 257 RTE_FLOW_ITEM_TYPE_TCP, 258 RTE_FLOW_ITEM_TYPE_END, 259 }; 260 261 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv6_tcp[] = { 262 RTE_FLOW_ITEM_TYPE_ETH, 263 RTE_FLOW_ITEM_TYPE_VLAN, 264 RTE_FLOW_ITEM_TYPE_VLAN, 265 RTE_FLOW_ITEM_TYPE_IPV6, 266 RTE_FLOW_ITEM_TYPE_TCP, 267 RTE_FLOW_ITEM_TYPE_END, 268 }; 269 270 enum rte_flow_item_type iavf_pattern_eth_ipv6_sctp[] = { 271 RTE_FLOW_ITEM_TYPE_ETH, 272 RTE_FLOW_ITEM_TYPE_IPV6, 273 RTE_FLOW_ITEM_TYPE_SCTP, 274 RTE_FLOW_ITEM_TYPE_END, 275 }; 276 277 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv6_sctp[] = { 278 RTE_FLOW_ITEM_TYPE_ETH, 279 RTE_FLOW_ITEM_TYPE_VLAN, 280 RTE_FLOW_ITEM_TYPE_IPV6, 281 RTE_FLOW_ITEM_TYPE_SCTP, 282 RTE_FLOW_ITEM_TYPE_END, 283 }; 284 285 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv6_sctp[] = { 286 RTE_FLOW_ITEM_TYPE_ETH, 287 RTE_FLOW_ITEM_TYPE_VLAN, 288 RTE_FLOW_ITEM_TYPE_VLAN, 289 RTE_FLOW_ITEM_TYPE_IPV6, 290 RTE_FLOW_ITEM_TYPE_SCTP, 291 RTE_FLOW_ITEM_TYPE_END, 292 }; 293 294 enum rte_flow_item_type iavf_pattern_eth_ipv6_icmp6[] = { 295 RTE_FLOW_ITEM_TYPE_ETH, 296 RTE_FLOW_ITEM_TYPE_IPV6, 297 RTE_FLOW_ITEM_TYPE_ICMP6, 298 RTE_FLOW_ITEM_TYPE_END, 299 }; 300 301 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv6_icmp6[] = { 302 RTE_FLOW_ITEM_TYPE_ETH, 303 RTE_FLOW_ITEM_TYPE_VLAN, 304 RTE_FLOW_ITEM_TYPE_IPV6, 305 RTE_FLOW_ITEM_TYPE_ICMP6, 306 RTE_FLOW_ITEM_TYPE_END, 307 }; 308 309 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv6_icmp6[] = { 310 RTE_FLOW_ITEM_TYPE_ETH, 311 RTE_FLOW_ITEM_TYPE_VLAN, 312 RTE_FLOW_ITEM_TYPE_VLAN, 313 RTE_FLOW_ITEM_TYPE_IPV6, 314 RTE_FLOW_ITEM_TYPE_ICMP6, 315 RTE_FLOW_ITEM_TYPE_END, 316 }; 317 318 /* IPv4 GTPC */ 319 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpc[] = { 320 RTE_FLOW_ITEM_TYPE_ETH, 321 RTE_FLOW_ITEM_TYPE_IPV4, 322 RTE_FLOW_ITEM_TYPE_UDP, 323 RTE_FLOW_ITEM_TYPE_GTPC, 324 RTE_FLOW_ITEM_TYPE_END, 325 }; 326 327 /* IPV4 GTPU (EH) */ 328 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu[] = { 329 RTE_FLOW_ITEM_TYPE_ETH, 330 RTE_FLOW_ITEM_TYPE_IPV4, 331 RTE_FLOW_ITEM_TYPE_UDP, 332 RTE_FLOW_ITEM_TYPE_GTPU, 333 RTE_FLOW_ITEM_TYPE_END, 334 }; 335 336 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_eh[] = { 337 RTE_FLOW_ITEM_TYPE_ETH, 338 RTE_FLOW_ITEM_TYPE_IPV4, 339 RTE_FLOW_ITEM_TYPE_UDP, 340 RTE_FLOW_ITEM_TYPE_GTPU, 341 RTE_FLOW_ITEM_TYPE_GTP_PSC, 342 RTE_FLOW_ITEM_TYPE_END, 343 }; 344 345 /* IPv6 GTPC */ 346 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpc[] = { 347 RTE_FLOW_ITEM_TYPE_ETH, 348 RTE_FLOW_ITEM_TYPE_IPV6, 349 RTE_FLOW_ITEM_TYPE_UDP, 350 RTE_FLOW_ITEM_TYPE_GTPC, 351 RTE_FLOW_ITEM_TYPE_END, 352 }; 353 354 /* IPV6 GTPU (EH) */ 355 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu[] = { 356 RTE_FLOW_ITEM_TYPE_ETH, 357 RTE_FLOW_ITEM_TYPE_IPV6, 358 RTE_FLOW_ITEM_TYPE_UDP, 359 RTE_FLOW_ITEM_TYPE_GTPU, 360 RTE_FLOW_ITEM_TYPE_END, 361 }; 362 363 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_eh[] = { 364 RTE_FLOW_ITEM_TYPE_ETH, 365 RTE_FLOW_ITEM_TYPE_IPV6, 366 RTE_FLOW_ITEM_TYPE_UDP, 367 RTE_FLOW_ITEM_TYPE_GTPU, 368 RTE_FLOW_ITEM_TYPE_GTP_PSC, 369 RTE_FLOW_ITEM_TYPE_END, 370 }; 371 372 /* IPV4 GTPU IPv4 */ 373 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_ipv4[] = { 374 RTE_FLOW_ITEM_TYPE_ETH, 375 RTE_FLOW_ITEM_TYPE_IPV4, 376 RTE_FLOW_ITEM_TYPE_UDP, 377 RTE_FLOW_ITEM_TYPE_GTPU, 378 RTE_FLOW_ITEM_TYPE_IPV4, 379 RTE_FLOW_ITEM_TYPE_END, 380 }; 381 382 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_ipv4_udp[] = { 383 RTE_FLOW_ITEM_TYPE_ETH, 384 RTE_FLOW_ITEM_TYPE_IPV4, 385 RTE_FLOW_ITEM_TYPE_UDP, 386 RTE_FLOW_ITEM_TYPE_GTPU, 387 RTE_FLOW_ITEM_TYPE_IPV4, 388 RTE_FLOW_ITEM_TYPE_UDP, 389 RTE_FLOW_ITEM_TYPE_END, 390 }; 391 392 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_ipv4_tcp[] = { 393 RTE_FLOW_ITEM_TYPE_ETH, 394 RTE_FLOW_ITEM_TYPE_IPV4, 395 RTE_FLOW_ITEM_TYPE_UDP, 396 RTE_FLOW_ITEM_TYPE_GTPU, 397 RTE_FLOW_ITEM_TYPE_IPV4, 398 RTE_FLOW_ITEM_TYPE_TCP, 399 RTE_FLOW_ITEM_TYPE_END, 400 }; 401 402 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_ipv4_icmp[] = { 403 RTE_FLOW_ITEM_TYPE_ETH, 404 RTE_FLOW_ITEM_TYPE_IPV4, 405 RTE_FLOW_ITEM_TYPE_UDP, 406 RTE_FLOW_ITEM_TYPE_GTPU, 407 RTE_FLOW_ITEM_TYPE_IPV4, 408 RTE_FLOW_ITEM_TYPE_ICMP, 409 RTE_FLOW_ITEM_TYPE_END, 410 }; 411 412 /* IPV4 GTPU IPv6 */ 413 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_ipv6[] = { 414 RTE_FLOW_ITEM_TYPE_ETH, 415 RTE_FLOW_ITEM_TYPE_IPV4, 416 RTE_FLOW_ITEM_TYPE_UDP, 417 RTE_FLOW_ITEM_TYPE_GTPU, 418 RTE_FLOW_ITEM_TYPE_IPV6, 419 RTE_FLOW_ITEM_TYPE_END, 420 }; 421 422 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_ipv6_udp[] = { 423 RTE_FLOW_ITEM_TYPE_ETH, 424 RTE_FLOW_ITEM_TYPE_IPV4, 425 RTE_FLOW_ITEM_TYPE_UDP, 426 RTE_FLOW_ITEM_TYPE_GTPU, 427 RTE_FLOW_ITEM_TYPE_IPV6, 428 RTE_FLOW_ITEM_TYPE_UDP, 429 RTE_FLOW_ITEM_TYPE_END, 430 }; 431 432 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_ipv6_tcp[] = { 433 RTE_FLOW_ITEM_TYPE_ETH, 434 RTE_FLOW_ITEM_TYPE_IPV4, 435 RTE_FLOW_ITEM_TYPE_UDP, 436 RTE_FLOW_ITEM_TYPE_GTPU, 437 RTE_FLOW_ITEM_TYPE_IPV6, 438 RTE_FLOW_ITEM_TYPE_TCP, 439 RTE_FLOW_ITEM_TYPE_END, 440 }; 441 442 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_ipv6_icmp[] = { 443 RTE_FLOW_ITEM_TYPE_ETH, 444 RTE_FLOW_ITEM_TYPE_IPV4, 445 RTE_FLOW_ITEM_TYPE_UDP, 446 RTE_FLOW_ITEM_TYPE_GTPU, 447 RTE_FLOW_ITEM_TYPE_IPV6, 448 RTE_FLOW_ITEM_TYPE_ICMP, 449 RTE_FLOW_ITEM_TYPE_END, 450 }; 451 452 /* IPV6 GTPU IPv4 */ 453 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_ipv4[] = { 454 RTE_FLOW_ITEM_TYPE_ETH, 455 RTE_FLOW_ITEM_TYPE_IPV6, 456 RTE_FLOW_ITEM_TYPE_UDP, 457 RTE_FLOW_ITEM_TYPE_GTPU, 458 RTE_FLOW_ITEM_TYPE_IPV4, 459 RTE_FLOW_ITEM_TYPE_END, 460 }; 461 462 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_ipv4_udp[] = { 463 RTE_FLOW_ITEM_TYPE_ETH, 464 RTE_FLOW_ITEM_TYPE_IPV6, 465 RTE_FLOW_ITEM_TYPE_UDP, 466 RTE_FLOW_ITEM_TYPE_GTPU, 467 RTE_FLOW_ITEM_TYPE_IPV4, 468 RTE_FLOW_ITEM_TYPE_UDP, 469 RTE_FLOW_ITEM_TYPE_END, 470 }; 471 472 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_ipv4_tcp[] = { 473 RTE_FLOW_ITEM_TYPE_ETH, 474 RTE_FLOW_ITEM_TYPE_IPV6, 475 RTE_FLOW_ITEM_TYPE_UDP, 476 RTE_FLOW_ITEM_TYPE_GTPU, 477 RTE_FLOW_ITEM_TYPE_IPV4, 478 RTE_FLOW_ITEM_TYPE_TCP, 479 RTE_FLOW_ITEM_TYPE_END, 480 }; 481 482 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_ipv4_icmp[] = { 483 RTE_FLOW_ITEM_TYPE_ETH, 484 RTE_FLOW_ITEM_TYPE_IPV6, 485 RTE_FLOW_ITEM_TYPE_UDP, 486 RTE_FLOW_ITEM_TYPE_GTPU, 487 RTE_FLOW_ITEM_TYPE_IPV4, 488 RTE_FLOW_ITEM_TYPE_ICMP, 489 RTE_FLOW_ITEM_TYPE_END, 490 }; 491 492 /* IPV6 GTPU IPv6 */ 493 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_ipv6[] = { 494 RTE_FLOW_ITEM_TYPE_ETH, 495 RTE_FLOW_ITEM_TYPE_IPV6, 496 RTE_FLOW_ITEM_TYPE_UDP, 497 RTE_FLOW_ITEM_TYPE_GTPU, 498 RTE_FLOW_ITEM_TYPE_IPV6, 499 RTE_FLOW_ITEM_TYPE_END, 500 }; 501 502 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_ipv6_udp[] = { 503 RTE_FLOW_ITEM_TYPE_ETH, 504 RTE_FLOW_ITEM_TYPE_IPV6, 505 RTE_FLOW_ITEM_TYPE_UDP, 506 RTE_FLOW_ITEM_TYPE_GTPU, 507 RTE_FLOW_ITEM_TYPE_IPV6, 508 RTE_FLOW_ITEM_TYPE_UDP, 509 RTE_FLOW_ITEM_TYPE_END, 510 }; 511 512 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_ipv6_tcp[] = { 513 RTE_FLOW_ITEM_TYPE_ETH, 514 RTE_FLOW_ITEM_TYPE_IPV6, 515 RTE_FLOW_ITEM_TYPE_UDP, 516 RTE_FLOW_ITEM_TYPE_GTPU, 517 RTE_FLOW_ITEM_TYPE_IPV6, 518 RTE_FLOW_ITEM_TYPE_TCP, 519 RTE_FLOW_ITEM_TYPE_END, 520 }; 521 522 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_ipv6_icmp[] = { 523 RTE_FLOW_ITEM_TYPE_ETH, 524 RTE_FLOW_ITEM_TYPE_IPV6, 525 RTE_FLOW_ITEM_TYPE_UDP, 526 RTE_FLOW_ITEM_TYPE_GTPU, 527 RTE_FLOW_ITEM_TYPE_IPV6, 528 RTE_FLOW_ITEM_TYPE_ICMP, 529 RTE_FLOW_ITEM_TYPE_END, 530 }; 531 532 /* IPV4 GTPU EH IPv4 */ 533 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_eh_ipv4[] = { 534 RTE_FLOW_ITEM_TYPE_ETH, 535 RTE_FLOW_ITEM_TYPE_IPV4, 536 RTE_FLOW_ITEM_TYPE_UDP, 537 RTE_FLOW_ITEM_TYPE_GTPU, 538 RTE_FLOW_ITEM_TYPE_GTP_PSC, 539 RTE_FLOW_ITEM_TYPE_IPV4, 540 RTE_FLOW_ITEM_TYPE_END, 541 }; 542 543 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_eh_ipv4_udp[] = { 544 RTE_FLOW_ITEM_TYPE_ETH, 545 RTE_FLOW_ITEM_TYPE_IPV4, 546 RTE_FLOW_ITEM_TYPE_UDP, 547 RTE_FLOW_ITEM_TYPE_GTPU, 548 RTE_FLOW_ITEM_TYPE_GTP_PSC, 549 RTE_FLOW_ITEM_TYPE_IPV4, 550 RTE_FLOW_ITEM_TYPE_UDP, 551 RTE_FLOW_ITEM_TYPE_END, 552 }; 553 554 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_eh_ipv4_tcp[] = { 555 RTE_FLOW_ITEM_TYPE_ETH, 556 RTE_FLOW_ITEM_TYPE_IPV4, 557 RTE_FLOW_ITEM_TYPE_UDP, 558 RTE_FLOW_ITEM_TYPE_GTPU, 559 RTE_FLOW_ITEM_TYPE_GTP_PSC, 560 RTE_FLOW_ITEM_TYPE_IPV4, 561 RTE_FLOW_ITEM_TYPE_TCP, 562 RTE_FLOW_ITEM_TYPE_END, 563 }; 564 565 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_eh_ipv4_icmp[] = { 566 RTE_FLOW_ITEM_TYPE_ETH, 567 RTE_FLOW_ITEM_TYPE_IPV4, 568 RTE_FLOW_ITEM_TYPE_UDP, 569 RTE_FLOW_ITEM_TYPE_GTPU, 570 RTE_FLOW_ITEM_TYPE_GTP_PSC, 571 RTE_FLOW_ITEM_TYPE_IPV4, 572 RTE_FLOW_ITEM_TYPE_ICMP, 573 RTE_FLOW_ITEM_TYPE_END, 574 }; 575 576 /* IPV4 GTPU EH IPv6 */ 577 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_eh_ipv6[] = { 578 RTE_FLOW_ITEM_TYPE_ETH, 579 RTE_FLOW_ITEM_TYPE_IPV4, 580 RTE_FLOW_ITEM_TYPE_UDP, 581 RTE_FLOW_ITEM_TYPE_GTPU, 582 RTE_FLOW_ITEM_TYPE_GTP_PSC, 583 RTE_FLOW_ITEM_TYPE_IPV6, 584 RTE_FLOW_ITEM_TYPE_END, 585 }; 586 587 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_eh_ipv6_udp[] = { 588 RTE_FLOW_ITEM_TYPE_ETH, 589 RTE_FLOW_ITEM_TYPE_IPV4, 590 RTE_FLOW_ITEM_TYPE_UDP, 591 RTE_FLOW_ITEM_TYPE_GTPU, 592 RTE_FLOW_ITEM_TYPE_GTP_PSC, 593 RTE_FLOW_ITEM_TYPE_IPV6, 594 RTE_FLOW_ITEM_TYPE_UDP, 595 RTE_FLOW_ITEM_TYPE_END, 596 }; 597 598 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_eh_ipv6_tcp[] = { 599 RTE_FLOW_ITEM_TYPE_ETH, 600 RTE_FLOW_ITEM_TYPE_IPV4, 601 RTE_FLOW_ITEM_TYPE_UDP, 602 RTE_FLOW_ITEM_TYPE_GTPU, 603 RTE_FLOW_ITEM_TYPE_GTP_PSC, 604 RTE_FLOW_ITEM_TYPE_IPV6, 605 RTE_FLOW_ITEM_TYPE_TCP, 606 RTE_FLOW_ITEM_TYPE_END, 607 }; 608 609 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_eh_ipv6_icmp[] = { 610 RTE_FLOW_ITEM_TYPE_ETH, 611 RTE_FLOW_ITEM_TYPE_IPV4, 612 RTE_FLOW_ITEM_TYPE_UDP, 613 RTE_FLOW_ITEM_TYPE_GTPU, 614 RTE_FLOW_ITEM_TYPE_GTP_PSC, 615 RTE_FLOW_ITEM_TYPE_IPV6, 616 RTE_FLOW_ITEM_TYPE_ICMP, 617 RTE_FLOW_ITEM_TYPE_END, 618 }; 619 620 /* IPV6 GTPU EH IPv4 */ 621 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_eh_ipv4[] = { 622 RTE_FLOW_ITEM_TYPE_ETH, 623 RTE_FLOW_ITEM_TYPE_IPV6, 624 RTE_FLOW_ITEM_TYPE_UDP, 625 RTE_FLOW_ITEM_TYPE_GTPU, 626 RTE_FLOW_ITEM_TYPE_GTP_PSC, 627 RTE_FLOW_ITEM_TYPE_IPV4, 628 RTE_FLOW_ITEM_TYPE_END, 629 }; 630 631 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_eh_ipv4_udp[] = { 632 RTE_FLOW_ITEM_TYPE_ETH, 633 RTE_FLOW_ITEM_TYPE_IPV6, 634 RTE_FLOW_ITEM_TYPE_UDP, 635 RTE_FLOW_ITEM_TYPE_GTPU, 636 RTE_FLOW_ITEM_TYPE_GTP_PSC, 637 RTE_FLOW_ITEM_TYPE_IPV4, 638 RTE_FLOW_ITEM_TYPE_UDP, 639 RTE_FLOW_ITEM_TYPE_END, 640 }; 641 642 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_eh_ipv4_tcp[] = { 643 RTE_FLOW_ITEM_TYPE_ETH, 644 RTE_FLOW_ITEM_TYPE_IPV6, 645 RTE_FLOW_ITEM_TYPE_UDP, 646 RTE_FLOW_ITEM_TYPE_GTPU, 647 RTE_FLOW_ITEM_TYPE_GTP_PSC, 648 RTE_FLOW_ITEM_TYPE_IPV4, 649 RTE_FLOW_ITEM_TYPE_TCP, 650 RTE_FLOW_ITEM_TYPE_END, 651 }; 652 653 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_eh_ipv4_icmp[] = { 654 RTE_FLOW_ITEM_TYPE_ETH, 655 RTE_FLOW_ITEM_TYPE_IPV6, 656 RTE_FLOW_ITEM_TYPE_UDP, 657 RTE_FLOW_ITEM_TYPE_GTPU, 658 RTE_FLOW_ITEM_TYPE_GTP_PSC, 659 RTE_FLOW_ITEM_TYPE_IPV4, 660 RTE_FLOW_ITEM_TYPE_ICMP, 661 RTE_FLOW_ITEM_TYPE_END, 662 }; 663 664 /* IPV6 GTPU EH IPv6 */ 665 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_eh_ipv6[] = { 666 RTE_FLOW_ITEM_TYPE_ETH, 667 RTE_FLOW_ITEM_TYPE_IPV6, 668 RTE_FLOW_ITEM_TYPE_UDP, 669 RTE_FLOW_ITEM_TYPE_GTPU, 670 RTE_FLOW_ITEM_TYPE_GTP_PSC, 671 RTE_FLOW_ITEM_TYPE_IPV6, 672 RTE_FLOW_ITEM_TYPE_END, 673 }; 674 675 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_eh_ipv6_udp[] = { 676 RTE_FLOW_ITEM_TYPE_ETH, 677 RTE_FLOW_ITEM_TYPE_IPV6, 678 RTE_FLOW_ITEM_TYPE_UDP, 679 RTE_FLOW_ITEM_TYPE_GTPU, 680 RTE_FLOW_ITEM_TYPE_GTP_PSC, 681 RTE_FLOW_ITEM_TYPE_IPV6, 682 RTE_FLOW_ITEM_TYPE_UDP, 683 RTE_FLOW_ITEM_TYPE_END, 684 }; 685 686 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_eh_ipv6_tcp[] = { 687 RTE_FLOW_ITEM_TYPE_ETH, 688 RTE_FLOW_ITEM_TYPE_IPV6, 689 RTE_FLOW_ITEM_TYPE_UDP, 690 RTE_FLOW_ITEM_TYPE_GTPU, 691 RTE_FLOW_ITEM_TYPE_GTP_PSC, 692 RTE_FLOW_ITEM_TYPE_IPV6, 693 RTE_FLOW_ITEM_TYPE_TCP, 694 RTE_FLOW_ITEM_TYPE_END, 695 }; 696 697 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_eh_ipv6_icmp[] = { 698 RTE_FLOW_ITEM_TYPE_ETH, 699 RTE_FLOW_ITEM_TYPE_IPV6, 700 RTE_FLOW_ITEM_TYPE_UDP, 701 RTE_FLOW_ITEM_TYPE_GTPU, 702 RTE_FLOW_ITEM_TYPE_GTP_PSC, 703 RTE_FLOW_ITEM_TYPE_IPV6, 704 RTE_FLOW_ITEM_TYPE_ICMP, 705 RTE_FLOW_ITEM_TYPE_END, 706 }; 707 708 /* ESP */ 709 enum rte_flow_item_type iavf_pattern_eth_ipv4_esp[] = { 710 RTE_FLOW_ITEM_TYPE_ETH, 711 RTE_FLOW_ITEM_TYPE_IPV4, 712 RTE_FLOW_ITEM_TYPE_ESP, 713 RTE_FLOW_ITEM_TYPE_END, 714 }; 715 716 enum rte_flow_item_type iavf_pattern_eth_ipv4_udp_esp[] = { 717 RTE_FLOW_ITEM_TYPE_ETH, 718 RTE_FLOW_ITEM_TYPE_IPV4, 719 RTE_FLOW_ITEM_TYPE_UDP, 720 RTE_FLOW_ITEM_TYPE_ESP, 721 RTE_FLOW_ITEM_TYPE_END, 722 }; 723 724 enum rte_flow_item_type iavf_pattern_eth_ipv6_esp[] = { 725 RTE_FLOW_ITEM_TYPE_ETH, 726 RTE_FLOW_ITEM_TYPE_IPV6, 727 RTE_FLOW_ITEM_TYPE_ESP, 728 RTE_FLOW_ITEM_TYPE_END, 729 }; 730 731 enum rte_flow_item_type iavf_pattern_eth_ipv6_udp_esp[] = { 732 RTE_FLOW_ITEM_TYPE_ETH, 733 RTE_FLOW_ITEM_TYPE_IPV6, 734 RTE_FLOW_ITEM_TYPE_UDP, 735 RTE_FLOW_ITEM_TYPE_ESP, 736 RTE_FLOW_ITEM_TYPE_END, 737 }; 738 739 /* AH */ 740 enum rte_flow_item_type iavf_pattern_eth_ipv4_ah[] = { 741 RTE_FLOW_ITEM_TYPE_ETH, 742 RTE_FLOW_ITEM_TYPE_IPV4, 743 RTE_FLOW_ITEM_TYPE_AH, 744 RTE_FLOW_ITEM_TYPE_END, 745 }; 746 747 enum rte_flow_item_type iavf_pattern_eth_ipv6_ah[] = { 748 RTE_FLOW_ITEM_TYPE_ETH, 749 RTE_FLOW_ITEM_TYPE_IPV6, 750 RTE_FLOW_ITEM_TYPE_AH, 751 RTE_FLOW_ITEM_TYPE_END, 752 }; 753 754 /* L2TPV3 */ 755 enum rte_flow_item_type iavf_pattern_eth_ipv4_l2tpv3[] = { 756 RTE_FLOW_ITEM_TYPE_ETH, 757 RTE_FLOW_ITEM_TYPE_IPV4, 758 RTE_FLOW_ITEM_TYPE_L2TPV3OIP, 759 RTE_FLOW_ITEM_TYPE_END, 760 }; 761 762 enum rte_flow_item_type iavf_pattern_eth_ipv6_l2tpv3[] = { 763 RTE_FLOW_ITEM_TYPE_ETH, 764 RTE_FLOW_ITEM_TYPE_IPV6, 765 RTE_FLOW_ITEM_TYPE_L2TPV3OIP, 766 RTE_FLOW_ITEM_TYPE_END, 767 }; 768 769 /* PFCP */ 770 enum rte_flow_item_type iavf_pattern_eth_ipv4_pfcp[] = { 771 RTE_FLOW_ITEM_TYPE_ETH, 772 RTE_FLOW_ITEM_TYPE_IPV4, 773 RTE_FLOW_ITEM_TYPE_UDP, 774 RTE_FLOW_ITEM_TYPE_PFCP, 775 RTE_FLOW_ITEM_TYPE_END, 776 }; 777 778 enum rte_flow_item_type iavf_pattern_eth_ipv6_pfcp[] = { 779 RTE_FLOW_ITEM_TYPE_ETH, 780 RTE_FLOW_ITEM_TYPE_IPV6, 781 RTE_FLOW_ITEM_TYPE_UDP, 782 RTE_FLOW_ITEM_TYPE_PFCP, 783 RTE_FLOW_ITEM_TYPE_END, 784 }; 785 786 typedef struct iavf_flow_engine * (*parse_engine_t)(struct iavf_adapter *ad, 787 struct rte_flow *flow, 788 struct iavf_parser_list *parser_list, 789 const struct rte_flow_item pattern[], 790 const struct rte_flow_action actions[], 791 struct rte_flow_error *error); 792 793 void 794 iavf_register_flow_engine(struct iavf_flow_engine *engine) 795 { 796 TAILQ_INSERT_TAIL(&engine_list, engine, node); 797 } 798 799 int 800 iavf_flow_init(struct iavf_adapter *ad) 801 { 802 int ret; 803 struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad); 804 void *temp; 805 struct iavf_flow_engine *engine; 806 807 TAILQ_INIT(&vf->flow_list); 808 TAILQ_INIT(&vf->rss_parser_list); 809 TAILQ_INIT(&vf->dist_parser_list); 810 rte_spinlock_init(&vf->flow_ops_lock); 811 812 TAILQ_FOREACH_SAFE(engine, &engine_list, node, temp) { 813 if (engine->init == NULL) { 814 PMD_INIT_LOG(ERR, "Invalid engine type (%d)", 815 engine->type); 816 return -ENOTSUP; 817 } 818 819 ret = engine->init(ad); 820 if (ret && ret != -ENOTSUP) { 821 PMD_INIT_LOG(ERR, "Failed to initialize engine %d", 822 engine->type); 823 return ret; 824 } 825 } 826 return 0; 827 } 828 829 void 830 iavf_flow_uninit(struct iavf_adapter *ad) 831 { 832 struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad); 833 struct iavf_flow_engine *engine; 834 struct rte_flow *p_flow; 835 struct iavf_flow_parser_node *p_parser; 836 void *temp; 837 838 TAILQ_FOREACH_SAFE(engine, &engine_list, node, temp) { 839 if (engine->uninit) 840 engine->uninit(ad); 841 } 842 843 /* Remove all flows */ 844 while ((p_flow = TAILQ_FIRST(&vf->flow_list))) { 845 TAILQ_REMOVE(&vf->flow_list, p_flow, node); 846 if (p_flow->engine->free) 847 p_flow->engine->free(p_flow); 848 rte_free(p_flow); 849 } 850 851 /* Cleanup parser list */ 852 while ((p_parser = TAILQ_FIRST(&vf->rss_parser_list))) { 853 TAILQ_REMOVE(&vf->rss_parser_list, p_parser, node); 854 rte_free(p_parser); 855 } 856 857 while ((p_parser = TAILQ_FIRST(&vf->dist_parser_list))) { 858 TAILQ_REMOVE(&vf->dist_parser_list, p_parser, node); 859 rte_free(p_parser); 860 } 861 } 862 863 int 864 iavf_register_parser(struct iavf_flow_parser *parser, 865 struct iavf_adapter *ad) 866 { 867 struct iavf_parser_list *list = NULL; 868 struct iavf_flow_parser_node *parser_node; 869 struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad); 870 871 parser_node = rte_zmalloc("iavf_parser", sizeof(*parser_node), 0); 872 if (parser_node == NULL) { 873 PMD_DRV_LOG(ERR, "Failed to allocate memory."); 874 return -ENOMEM; 875 } 876 parser_node->parser = parser; 877 878 if (parser->engine->type == IAVF_FLOW_ENGINE_HASH) { 879 list = &vf->rss_parser_list; 880 TAILQ_INSERT_TAIL(list, parser_node, node); 881 } else if (parser->engine->type == IAVF_FLOW_ENGINE_FDIR) { 882 list = &vf->dist_parser_list; 883 TAILQ_INSERT_HEAD(list, parser_node, node); 884 } else { 885 return -EINVAL; 886 } 887 888 return 0; 889 } 890 891 void 892 iavf_unregister_parser(struct iavf_flow_parser *parser, 893 struct iavf_adapter *ad) 894 { 895 struct iavf_parser_list *list = NULL; 896 struct iavf_flow_parser_node *p_parser; 897 struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad); 898 void *temp; 899 900 if (parser->engine->type == IAVF_FLOW_ENGINE_HASH) 901 list = &vf->rss_parser_list; 902 else if (parser->engine->type == IAVF_FLOW_ENGINE_FDIR) 903 list = &vf->dist_parser_list; 904 905 if (list == NULL) 906 return; 907 908 TAILQ_FOREACH_SAFE(p_parser, list, node, temp) { 909 if (p_parser->parser->engine->type == parser->engine->type) { 910 TAILQ_REMOVE(list, p_parser, node); 911 rte_free(p_parser); 912 } 913 } 914 } 915 916 static int 917 iavf_flow_valid_attr(const struct rte_flow_attr *attr, 918 struct rte_flow_error *error) 919 { 920 /* Must be input direction */ 921 if (!attr->ingress) { 922 rte_flow_error_set(error, EINVAL, 923 RTE_FLOW_ERROR_TYPE_ATTR_INGRESS, 924 attr, "Only support ingress."); 925 return -rte_errno; 926 } 927 928 /* Not supported */ 929 if (attr->egress) { 930 rte_flow_error_set(error, EINVAL, 931 RTE_FLOW_ERROR_TYPE_ATTR_EGRESS, 932 attr, "Not support egress."); 933 return -rte_errno; 934 } 935 936 /* Not supported */ 937 if (attr->priority) { 938 rte_flow_error_set(error, EINVAL, 939 RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY, 940 attr, "Not support priority."); 941 return -rte_errno; 942 } 943 944 /* Not supported */ 945 if (attr->group) { 946 rte_flow_error_set(error, EINVAL, 947 RTE_FLOW_ERROR_TYPE_ATTR_GROUP, 948 attr, "Not support group."); 949 return -rte_errno; 950 } 951 952 return 0; 953 } 954 955 /* Find the first VOID or non-VOID item pointer */ 956 static const struct rte_flow_item * 957 iavf_find_first_item(const struct rte_flow_item *item, bool is_void) 958 { 959 bool is_find; 960 961 while (item->type != RTE_FLOW_ITEM_TYPE_END) { 962 if (is_void) 963 is_find = item->type == RTE_FLOW_ITEM_TYPE_VOID; 964 else 965 is_find = item->type != RTE_FLOW_ITEM_TYPE_VOID; 966 if (is_find) 967 break; 968 item++; 969 } 970 return item; 971 } 972 973 /* Skip all VOID items of the pattern */ 974 static void 975 iavf_pattern_skip_void_item(struct rte_flow_item *items, 976 const struct rte_flow_item *pattern) 977 { 978 uint32_t cpy_count = 0; 979 const struct rte_flow_item *pb = pattern, *pe = pattern; 980 981 for (;;) { 982 /* Find a non-void item first */ 983 pb = iavf_find_first_item(pb, false); 984 if (pb->type == RTE_FLOW_ITEM_TYPE_END) { 985 pe = pb; 986 break; 987 } 988 989 /* Find a void item */ 990 pe = iavf_find_first_item(pb + 1, true); 991 992 cpy_count = pe - pb; 993 rte_memcpy(items, pb, sizeof(struct rte_flow_item) * cpy_count); 994 995 items += cpy_count; 996 997 if (pe->type == RTE_FLOW_ITEM_TYPE_END) 998 break; 999 1000 pb = pe + 1; 1001 } 1002 /* Copy the END item. */ 1003 rte_memcpy(items, pe, sizeof(struct rte_flow_item)); 1004 } 1005 1006 /* Check if the pattern matches a supported item type array */ 1007 static bool 1008 iavf_match_pattern(enum rte_flow_item_type *item_array, 1009 const struct rte_flow_item *pattern) 1010 { 1011 const struct rte_flow_item *item = pattern; 1012 1013 while ((*item_array == item->type) && 1014 (*item_array != RTE_FLOW_ITEM_TYPE_END)) { 1015 item_array++; 1016 item++; 1017 } 1018 1019 return (*item_array == RTE_FLOW_ITEM_TYPE_END && 1020 item->type == RTE_FLOW_ITEM_TYPE_END); 1021 } 1022 1023 struct iavf_pattern_match_item * 1024 iavf_search_pattern_match_item(const struct rte_flow_item pattern[], 1025 struct iavf_pattern_match_item *array, 1026 uint32_t array_len, 1027 struct rte_flow_error *error) 1028 { 1029 uint16_t i = 0; 1030 struct iavf_pattern_match_item *pattern_match_item; 1031 /* need free by each filter */ 1032 struct rte_flow_item *items; /* used for pattern without VOID items */ 1033 uint32_t item_num = 0; /* non-void item number */ 1034 1035 /* Get the non-void item number of pattern */ 1036 while ((pattern + i)->type != RTE_FLOW_ITEM_TYPE_END) { 1037 if ((pattern + i)->type != RTE_FLOW_ITEM_TYPE_VOID) 1038 item_num++; 1039 i++; 1040 } 1041 item_num++; 1042 1043 items = rte_zmalloc("iavf_pattern", 1044 item_num * sizeof(struct rte_flow_item), 0); 1045 if (!items) { 1046 rte_flow_error_set(error, ENOMEM, RTE_FLOW_ERROR_TYPE_ITEM_NUM, 1047 NULL, "No memory for PMD internal items."); 1048 return NULL; 1049 } 1050 pattern_match_item = rte_zmalloc("iavf_pattern_match_item", 1051 sizeof(struct iavf_pattern_match_item), 0); 1052 if (!pattern_match_item) { 1053 rte_flow_error_set(error, ENOMEM, RTE_FLOW_ERROR_TYPE_HANDLE, 1054 NULL, "Failed to allocate memory."); 1055 return NULL; 1056 } 1057 1058 iavf_pattern_skip_void_item(items, pattern); 1059 1060 for (i = 0; i < array_len; i++) 1061 if (iavf_match_pattern(array[i].pattern_list, 1062 items)) { 1063 pattern_match_item->input_set_mask = 1064 array[i].input_set_mask; 1065 pattern_match_item->pattern_list = 1066 array[i].pattern_list; 1067 pattern_match_item->meta = array[i].meta; 1068 rte_free(items); 1069 return pattern_match_item; 1070 } 1071 rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, 1072 pattern, "Unsupported pattern"); 1073 1074 rte_free(items); 1075 rte_free(pattern_match_item); 1076 return NULL; 1077 } 1078 1079 static struct iavf_flow_engine * 1080 iavf_parse_engine_create(struct iavf_adapter *ad, 1081 struct rte_flow *flow, 1082 struct iavf_parser_list *parser_list, 1083 const struct rte_flow_item pattern[], 1084 const struct rte_flow_action actions[], 1085 struct rte_flow_error *error) 1086 { 1087 struct iavf_flow_engine *engine = NULL; 1088 struct iavf_flow_parser_node *parser_node; 1089 void *temp; 1090 void *meta = NULL; 1091 1092 TAILQ_FOREACH_SAFE(parser_node, parser_list, node, temp) { 1093 if (parser_node->parser->parse_pattern_action(ad, 1094 parser_node->parser->array, 1095 parser_node->parser->array_len, 1096 pattern, actions, &meta, error) < 0) 1097 continue; 1098 1099 engine = parser_node->parser->engine; 1100 1101 RTE_ASSERT(engine->create != NULL); 1102 if (!(engine->create(ad, flow, meta, error))) 1103 return engine; 1104 } 1105 return NULL; 1106 } 1107 1108 static struct iavf_flow_engine * 1109 iavf_parse_engine_validate(struct iavf_adapter *ad, 1110 struct rte_flow *flow, 1111 struct iavf_parser_list *parser_list, 1112 const struct rte_flow_item pattern[], 1113 const struct rte_flow_action actions[], 1114 struct rte_flow_error *error) 1115 { 1116 struct iavf_flow_engine *engine = NULL; 1117 struct iavf_flow_parser_node *parser_node; 1118 void *temp; 1119 void *meta = NULL; 1120 1121 TAILQ_FOREACH_SAFE(parser_node, parser_list, node, temp) { 1122 if (parser_node->parser->parse_pattern_action(ad, 1123 parser_node->parser->array, 1124 parser_node->parser->array_len, 1125 pattern, actions, &meta, error) < 0) 1126 continue; 1127 1128 engine = parser_node->parser->engine; 1129 if (engine->validation == NULL) { 1130 rte_flow_error_set(error, EINVAL, 1131 RTE_FLOW_ERROR_TYPE_HANDLE, 1132 NULL, "Validation not support"); 1133 continue; 1134 } 1135 1136 if (engine->validation(ad, flow, meta, error)) { 1137 rte_flow_error_set(error, EINVAL, 1138 RTE_FLOW_ERROR_TYPE_HANDLE, 1139 NULL, "Validation failed"); 1140 break; 1141 } 1142 } 1143 return engine; 1144 } 1145 1146 1147 static int 1148 iavf_flow_process_filter(struct rte_eth_dev *dev, 1149 struct rte_flow *flow, 1150 const struct rte_flow_attr *attr, 1151 const struct rte_flow_item pattern[], 1152 const struct rte_flow_action actions[], 1153 struct iavf_flow_engine **engine, 1154 parse_engine_t iavf_parse_engine, 1155 struct rte_flow_error *error) 1156 { 1157 int ret = IAVF_ERR_CONFIG; 1158 struct iavf_adapter *ad = 1159 IAVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private); 1160 struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad); 1161 1162 if (!pattern) { 1163 rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM_NUM, 1164 NULL, "NULL pattern."); 1165 return -rte_errno; 1166 } 1167 1168 if (!actions) { 1169 rte_flow_error_set(error, EINVAL, 1170 RTE_FLOW_ERROR_TYPE_ACTION_NUM, 1171 NULL, "NULL action."); 1172 return -rte_errno; 1173 } 1174 1175 if (!attr) { 1176 rte_flow_error_set(error, EINVAL, 1177 RTE_FLOW_ERROR_TYPE_ATTR, 1178 NULL, "NULL attribute."); 1179 return -rte_errno; 1180 } 1181 1182 ret = iavf_flow_valid_attr(attr, error); 1183 if (ret) 1184 return ret; 1185 1186 *engine = iavf_parse_engine(ad, flow, &vf->rss_parser_list, pattern, 1187 actions, error); 1188 if (*engine) 1189 return 0; 1190 1191 *engine = iavf_parse_engine(ad, flow, &vf->dist_parser_list, pattern, 1192 actions, error); 1193 1194 if (!*engine) { 1195 rte_flow_error_set(error, EINVAL, 1196 RTE_FLOW_ERROR_TYPE_HANDLE, NULL, 1197 "Failed to create parser engine."); 1198 return -rte_errno; 1199 } 1200 1201 return 0; 1202 } 1203 1204 static int 1205 iavf_flow_validate(struct rte_eth_dev *dev, 1206 const struct rte_flow_attr *attr, 1207 const struct rte_flow_item pattern[], 1208 const struct rte_flow_action actions[], 1209 struct rte_flow_error *error) 1210 { 1211 struct iavf_flow_engine *engine; 1212 1213 return iavf_flow_process_filter(dev, NULL, attr, pattern, actions, 1214 &engine, iavf_parse_engine_validate, error); 1215 } 1216 1217 static struct rte_flow * 1218 iavf_flow_create(struct rte_eth_dev *dev, 1219 const struct rte_flow_attr *attr, 1220 const struct rte_flow_item pattern[], 1221 const struct rte_flow_action actions[], 1222 struct rte_flow_error *error) 1223 { 1224 struct iavf_adapter *ad = 1225 IAVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private); 1226 struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad); 1227 struct iavf_flow_engine *engine = NULL; 1228 struct rte_flow *flow = NULL; 1229 int ret; 1230 1231 flow = rte_zmalloc("iavf_flow", sizeof(struct rte_flow), 0); 1232 if (!flow) { 1233 rte_flow_error_set(error, ENOMEM, 1234 RTE_FLOW_ERROR_TYPE_HANDLE, NULL, 1235 "Failed to allocate memory"); 1236 return flow; 1237 } 1238 1239 ret = iavf_flow_process_filter(dev, flow, attr, pattern, actions, 1240 &engine, iavf_parse_engine_create, error); 1241 if (ret < 0) { 1242 PMD_DRV_LOG(ERR, "Failed to create flow"); 1243 rte_free(flow); 1244 flow = NULL; 1245 goto free_flow; 1246 } 1247 1248 flow->engine = engine; 1249 TAILQ_INSERT_TAIL(&vf->flow_list, flow, node); 1250 PMD_DRV_LOG(INFO, "Succeeded to create (%d) flow", engine->type); 1251 1252 free_flow: 1253 rte_spinlock_unlock(&vf->flow_ops_lock); 1254 return flow; 1255 } 1256 1257 static bool 1258 iavf_flow_is_valid(struct rte_flow *flow) 1259 { 1260 struct iavf_flow_engine *engine; 1261 void *temp; 1262 1263 if (flow && flow->engine) { 1264 TAILQ_FOREACH_SAFE(engine, &engine_list, node, temp) { 1265 if (engine == flow->engine) 1266 return true; 1267 } 1268 } 1269 1270 return false; 1271 } 1272 1273 static int 1274 iavf_flow_destroy(struct rte_eth_dev *dev, 1275 struct rte_flow *flow, 1276 struct rte_flow_error *error) 1277 { 1278 struct iavf_adapter *ad = 1279 IAVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private); 1280 struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad); 1281 int ret = 0; 1282 1283 if (!iavf_flow_is_valid(flow) || !flow->engine->destroy) { 1284 rte_flow_error_set(error, EINVAL, 1285 RTE_FLOW_ERROR_TYPE_HANDLE, 1286 NULL, "Invalid flow destroy"); 1287 return -rte_errno; 1288 } 1289 1290 rte_spinlock_lock(&vf->flow_ops_lock); 1291 1292 ret = flow->engine->destroy(ad, flow, error); 1293 1294 if (!ret) { 1295 TAILQ_REMOVE(&vf->flow_list, flow, node); 1296 rte_free(flow); 1297 } else { 1298 PMD_DRV_LOG(ERR, "Failed to destroy flow"); 1299 } 1300 1301 rte_spinlock_unlock(&vf->flow_ops_lock); 1302 1303 return ret; 1304 } 1305 1306 int 1307 iavf_flow_flush(struct rte_eth_dev *dev, 1308 struct rte_flow_error *error) 1309 { 1310 struct iavf_adapter *ad = 1311 IAVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private); 1312 struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad); 1313 struct rte_flow *p_flow; 1314 void *temp; 1315 int ret = 0; 1316 1317 TAILQ_FOREACH_SAFE(p_flow, &vf->flow_list, node, temp) { 1318 ret = iavf_flow_destroy(dev, p_flow, error); 1319 if (ret) { 1320 PMD_DRV_LOG(ERR, "Failed to flush flows"); 1321 return -EINVAL; 1322 } 1323 } 1324 1325 return ret; 1326 } 1327 1328 static int 1329 iavf_flow_query(struct rte_eth_dev *dev, 1330 struct rte_flow *flow, 1331 const struct rte_flow_action *actions, 1332 void *data, 1333 struct rte_flow_error *error) 1334 { 1335 int ret = -EINVAL; 1336 struct iavf_adapter *ad = 1337 IAVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private); 1338 struct rte_flow_query_count *count = data; 1339 1340 if (!iavf_flow_is_valid(flow) || !flow->engine->query_count) { 1341 rte_flow_error_set(error, EINVAL, 1342 RTE_FLOW_ERROR_TYPE_HANDLE, 1343 NULL, "Invalid flow query"); 1344 return -rte_errno; 1345 } 1346 1347 for (; actions->type != RTE_FLOW_ACTION_TYPE_END; actions++) { 1348 switch (actions->type) { 1349 case RTE_FLOW_ACTION_TYPE_VOID: 1350 break; 1351 case RTE_FLOW_ACTION_TYPE_COUNT: 1352 ret = flow->engine->query_count(ad, flow, count, error); 1353 break; 1354 default: 1355 return rte_flow_error_set(error, ENOTSUP, 1356 RTE_FLOW_ERROR_TYPE_ACTION, 1357 actions, 1358 "action not supported"); 1359 } 1360 } 1361 return ret; 1362 } 1363 1364