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