Dear [Support Team / DPDK Developers / Intel Support],

I hope this message finds you well.

I'm currently developing a server application based on DPDK 24.11, using an Intel X710 NIC with the i40e driver. In my application, I'm leveraging RTE Flow to filter UDP packets based on specific IP addresses and ports.

To direct matching traffic, I initially used the QUEUE action, but I observed that only one CPU core reaches 100% utilization, while the others remain idle. This indicates that RSS is being bypassed, resulting in a processing bottleneck.

To address this, I tried replacing the QUEUE action with RSS, but I encountered the following validation error:

Validation Failure: RSS Queues not supported when pattern specified

This raises a few questions:

• Is this a known limitation of the i40e driver or the X710 hardware?

• Are there specific pattern constraints that prevent RSS from being used in this context?

• Is there a recommended approach to enable per-core packet distribution while still applying fine-grained filtering?

Below is a relevant snippet of the flow rule I'm using:

int flow_filtering(uint16_t port_id, uint32_t ip_addr, uint16_t udp_port) {
    struct rte_flow_error error;
    struct rte_flow_attr attr = { 
        .ingress = 1, 
        .priority = 0 
    };
    struct rte_flow_item pattern[4];
    struct rte_flow_action action[2];
    struct rte_flow *flow;

    // Configuration Ethernet
    memset(pattern, 0, sizeof(pattern));
    pattern[0].type = RTE_FLOW_ITEM_TYPE_ETH;

    // Configuration IPv4
    struct rte_flow_item_ipv4 ipv4_spec = { .hdr.dst_addr = RTE_BE32(ip_addr) };
    struct rte_flow_item_ipv4 ipv4_mask = { .hdr.dst_addr = RTE_BE32(0xFFFFFFFF) };
    pattern[1].type = RTE_FLOW_ITEM_TYPE_IPV4;
    pattern[1].spec = &ipv4_spec;
    pattern[1].mask = &ipv4_mask;

    // Configuration UDP
    struct rte_flow_item_udp udp_spec = { .hdr.dst_port = RTE_BE16(udp_port) };
    struct rte_flow_item_udp udp_mask = { .hdr.dst_port = RTE_BE16(0xFFFF) };
    pattern[2].type = RTE_FLOW_ITEM_TYPE_UDP;
    pattern[2].spec = &udp_spec;
    pattern[2].mask = &udp_mask;

    pattern[3].type = RTE_FLOW_ITEM_TYPE_END;

    // Configuration RSS
    uint16_t rss_queues[] = {0, 1, 2, 3, 4, 5};
    
    struct rte_flow_action_rss rss_conf = {
        .func = RTE_ETH_HASH_FUNCTION_DEFAULT,
        .types = RTE_ETH_RSS_NONFRAG_IPV4_UDP,
        .key_len = 0,
        .queue_num = 6,
        .queue = rss_queues
    };

    action[0].type = RTE_FLOW_ACTION_TYPE_RSS;
    action[0].conf = &rss_conf;
    action[1].type = RTE_FLOW_ACTION_TYPE_END;

    if (rte_flow_validate(port_id, &attr, pattern, action, &error) != 0) {
        printf("Validation failed: %s\n", error.message);
        return -1;
    }
    
    flow = rte_flow_create(port_id, &attr, pattern, action, &error);
    if (flow == NULL) {
        printf("Error creating flow rule: %s\n", error.message);
        return -1;
    }

    printf("Flow rule created for IP %u.%u.%u.%u and UDP port %u\n",
           (ip_addr >> 24) & 0xFF, (ip_addr >> 16) & 0xFF,
           (ip_addr >> 8) & 0xFF, ip_addr & 0xFF, udp_port);

    return 0;
}

Any guidance or clarification would be greatly appreciated.

Best regards,

Sid-Ali