[dpdk-users] Flow Director for IPv6, flex bytes

[Cody Doucette <doucette@bu.edu>]

I'm trying to use Flow Director on an 82599 NIC to match the IPv6 proto and
hop limit fields. I've been able to get something analogous working for
IPv4, but changing the flow type to IPv6 breaks it.

Does anyone have any pointers to working examples of Flow Director for IPv6
flows?

My Flow Director configuration is:

(It seems to be a driver requirement that we use RTE_ETH_RAW_PAYLOAD and
RTE_ETH_FLOW_UNKNOWN below):

.fdir_conf = {
                .mode = RTE_FDIR_MODE_PERFECT,
                .pballoc = RTE_FDIR_PBALLOC_64K,
                .status = RTE_FDIR_REPORT_STATUS_ALWAYS,
                .drop_queue = DROP_QUEUE,
                .mask = {
                        .vlan_tci_mask = 0x0,
                        .ipv4_mask = {
                                .src_ip = 0,
                                .dst_ip = 0,
                        },
                        .ipv6_mask = {
                                .src_ip = { 0, 0, 0, 0},
                                .dst_ip = { 0, 0, 0, 0},
                        },
                        .src_port_mask = 0,
                        .dst_port_mask = 0,
                        .mac_addr_byte_mask = 0,
                        .tunnel_type_mask = 0,
                        .tunnel_id_mask = 0,
                },
                .flex_conf = {
                        .nb_payloads = 1,
                        .nb_flexmasks = 1,
                        .flex_set = {
                                [0] = {
                                        .type = RTE_ETH_RAW_PAYLOAD,
                                        .src_offset = {
                                                FDIR_FLEX_OFFSET,
                                                FDIR_FLEX_OFFSET + 1,
                                        },
                                },
                        },
                        .flex_mask = {
                                [0] = {
                                        .flow_type = RTE_ETH_FLOW_UNKNOWN,
                                        .mask = {
                                                [0] = 0xFF,
                                                [1] = 0xFF,
                                        },
                                },
                        },
                },
},

And then this filter works for IPv4 packets:

        struct rte_eth_fdir_filter filter = {
                .soft_id = soft_id,
                .input = {
                        .flow_type = RTE_ETH_FLOW_IPV4,
                        .flow_ext = {
                                .vlan_tci = 0,
                                .flexbytes = {
                                        0x40,
                                        0x01,
                                },
                                .is_vf = 0,
                                .dst_id = 0,
                        },
                },
                .action = {
                        .rx_queue = queue_id,
                },
        };

But this filter does not work for IPv6 packets (and neither does changing
the flow type to anything else):

        struct rte_eth_fdir_filter filter = {
                .soft_id = soft_id,
                .input = {
                        .flow_type = RTE_ETH_FLOW_IPV6,
                        .flow_ext = {
                                .vlan_tci = 0,
                                .flexbytes = {
                                        0x3A,
                                        0x55,
                                },
                                .is_vf = 0,
                                .dst_id = 0,
                        },
                },
                .action = {
                        .rx_queue = queue_id,
                },
        };