From patchwork Tue Oct 25 21:44:03 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Thomas Monjalon X-Patchwork-Id: 119118 X-Patchwork-Delegate: ferruh.yigit@amd.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id BFCF6A0544; Tue, 25 Oct 2022 23:44:48 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id AD51142C4C; Tue, 25 Oct 2022 23:44:48 +0200 (CEST) Received: from out3-smtp.messagingengine.com (out3-smtp.messagingengine.com [66.111.4.27]) by mails.dpdk.org (Postfix) with ESMTP id 1B29A410D2 for ; Tue, 25 Oct 2022 23:44:47 +0200 (CEST) Received: from compute1.internal (compute1.nyi.internal [10.202.2.41]) by mailout.nyi.internal (Postfix) with ESMTP id C7B435C0043; Tue, 25 Oct 2022 17:44:45 -0400 (EDT) Received: from mailfrontend1 ([10.202.2.162]) by compute1.internal (MEProxy); Tue, 25 Oct 2022 17:44:45 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=monjalon.net; h= cc:cc:content-transfer-encoding:date:date:from:from:in-reply-to :in-reply-to:message-id:mime-version:references:reply-to:sender :subject:subject:to:to; s=fm3; t=1666734285; x=1666820685; bh=to pO/WgB21g8c0/ddfeDufeO1a04Y58eh2lv5lzTR7Y=; b=kByC14SjLZN5B5vhEN SF01ODAg/E6TG4LulJtrg33mng1yuJqokSLm7ugWEyUS4xZhtO7xxk9JOQks/agQ l7Pnqc8CzDb+v/dlRTITL3fkEuqCZovSGskcEZMY0lnHuWDMTIywp5EKbRYkjQGH mdwxh4LJskEMAweaskGzDsAzcnQkB0ZluJgF9pZ7QPtb4dJvPZLrUHn8lPESHBkW Dk5gOHRJmR6VeAirIlVIrTXgOaPAbCnAjbWvgXCTPypn36jTs1wO3YJ+5XKlKpsO nayfi7/YGywv5tPmYSrZp07dFZntxRtBGxbgd+NWtkTH9x3KzIVe5SAIEcs29EO5 8NQQ== DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=cc:cc:content-transfer-encoding:date:date :feedback-id:feedback-id:from:from:in-reply-to:in-reply-to :message-id:mime-version:references:reply-to:sender:subject :subject:to:to:x-me-proxy:x-me-proxy:x-me-sender:x-me-sender :x-sasl-enc; s=fm3; t=1666734285; x=1666820685; bh=topO/WgB21g8c 0/ddfeDufeO1a04Y58eh2lv5lzTR7Y=; b=P5pvb5MkgaEXu0ZJr6EluRFIqBSHu 2k2SXkwFCaK7FtBfOqzmblC9NdmvHRAditIeK4Fb0ieMVpYocyXwLE4hggWgPXRr i7V4VdxmG/VE3SWRX4uqXzhgNGnjVO9coqEBH7p2a+3DQdoIdjTVkn0gyAAFiQbY AzIfmXw5/vyOHlktzKdvydHDI3/h9odeghKSOqKKyQnLdN1Mo1nbIVKd2fzwsoR/ RnDRWCoXvoMbulGKfo6mBfxEUOlVCOGdo1bTnORi4NRCBMUh6IcdKXgFrvXRzm/H rntUhynOBg5jXip7pB6BH/ftuqU5pzpa0uB0bDS+rk8DLfVTQ/dmFL+ZA== X-ME-Sender: X-ME-Received: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgedvgedrtddugddtudcutefuodetggdotefrodftvf curfhrohhfihhlvgemucfhrghsthforghilhdpqfgfvfdpuffrtefokffrpgfnqfghnecu uegrihhlohhuthemuceftddtnecusecvtfgvtghiphhivghnthhsucdlqddutddtmdenuc fjughrpefhvfevufffkffojghfggfgsedtkeertdertddtnecuhfhrohhmpefvhhhomhgr shcuofhonhhjrghlohhnuceothhhohhmrghssehmohhnjhgrlhhonhdrnhgvtheqnecugg ftrfgrthhtvghrnhepvdejhfdugeehvddtieejieegteeuudfgjeeukeeiledthfetveek hefhieelhfdtnecuvehluhhsthgvrhfuihiivgeptdenucfrrghrrghmpehmrghilhhfrh homhepthhhohhmrghssehmohhnjhgrlhhonhdrnhgvth X-ME-Proxy: Feedback-ID: i47234305:Fastmail Received: by mail.messagingengine.com (Postfix) with ESMTPA; Tue, 25 Oct 2022 17:44:40 -0400 (EDT) From: Thomas Monjalon To: dev@dpdk.org Cc: ferruh.yigit@amd.com, andrew.rybchenko@oktetlabs.ru, Wisam Jaddo , Ori Kam , Aman Singh , Yuying Zhang , Ajit Khaparde , Somnath Kotur , Chas Williams , "Min Hu (Connor)" , Rahul Lakkireddy , Hemant Agrawal , Sachin Saxena , Simei Su , Wenjun Wu , John Daley , Hyong Youb Kim , Ziyang Xuan , Xiaoyun Wang , Guoyang Zhou , Dongdong Liu , Yisen Zhuang , Beilei Xing , Jingjing Wu , Qiming Yang , Qi Zhang , Junfeng Guo , Rosen Xu , Matan Azrad , Viacheslav Ovsiienko , Liron Himi , Jiawen Wu , Jian Wang Subject: [PATCH 1/8] ethdev: use Ethernet protocol struct for flow matching Date: Tue, 25 Oct 2022 23:44:03 +0200 Message-Id: <20221025214410.715864-2-thomas@monjalon.net> X-Mailer: git-send-email 2.36.1 In-Reply-To: <20221025214410.715864-1-thomas@monjalon.net> References: <20221025214410.715864-1-thomas@monjalon.net> MIME-Version: 1.0 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org As announced in the deprecation notice, flow item structures should re-use the protocol header definitions from the directory lib/net/. The Ethernet headers (including VLAN) structures are used instead of the redundant fields in the flow items. The remaining protocols to clean up are listed for future work in the deprecation list. Some protocols are not even defined in the directory net yet. Signed-off-by: Thomas Monjalon --- app/test-flow-perf/items_gen.c | 4 +- app/test-pmd/cmdline_flow.c | 140 +++++++++++------------ doc/guides/prog_guide/rte_flow.rst | 7 +- doc/guides/rel_notes/deprecation.rst | 38 ++++-- drivers/net/bnxt/bnxt_flow.c | 42 +++---- drivers/net/bnxt/tf_ulp/ulp_rte_parser.c | 58 +++++----- drivers/net/bonding/rte_eth_bond_pmd.c | 12 +- drivers/net/cxgbe/cxgbe_flow.c | 44 +++---- drivers/net/dpaa2/dpaa2_flow.c | 48 ++++---- drivers/net/dpaa2/dpaa2_mux.c | 2 +- drivers/net/e1000/igb_flow.c | 14 +-- drivers/net/enic/enic_flow.c | 24 ++-- drivers/net/enic/enic_fm_flow.c | 16 +-- drivers/net/hinic/hinic_pmd_flow.c | 14 +-- drivers/net/hns3/hns3_flow.c | 28 ++--- drivers/net/i40e/i40e_flow.c | 100 ++++++++-------- drivers/net/i40e/i40e_hash.c | 4 +- drivers/net/iavf/iavf_fdir.c | 10 +- drivers/net/iavf/iavf_fsub.c | 10 +- drivers/net/iavf/iavf_ipsec_crypto.c | 4 +- drivers/net/ice/ice_acl_filter.c | 20 ++-- drivers/net/ice/ice_fdir_filter.c | 14 +-- drivers/net/ice/ice_switch_filter.c | 34 +++--- drivers/net/igc/igc_flow.c | 8 +- drivers/net/ipn3ke/ipn3ke_flow.c | 8 +- drivers/net/ixgbe/ixgbe_flow.c | 40 +++---- drivers/net/mlx4/mlx4_flow.c | 38 +++--- drivers/net/mlx5/mlx5_flow.c | 24 ++-- drivers/net/mlx5/mlx5_flow_dv.c | 100 ++++++++-------- drivers/net/mlx5/mlx5_flow_verbs.c | 30 ++--- drivers/net/mlx5/mlx5_trigger.c | 28 ++--- drivers/net/mvpp2/mrvl_flow.c | 28 ++--- drivers/net/sfc/sfc_flow.c | 46 ++++---- drivers/net/sfc/sfc_mae.c | 38 +++--- drivers/net/tap/tap_flow.c | 58 +++++----- drivers/net/txgbe/txgbe_flow.c | 28 ++--- 36 files changed, 590 insertions(+), 571 deletions(-) diff --git a/app/test-flow-perf/items_gen.c b/app/test-flow-perf/items_gen.c index a73de9031f..b7f51030a1 100644 --- a/app/test-flow-perf/items_gen.c +++ b/app/test-flow-perf/items_gen.c @@ -37,10 +37,10 @@ add_vlan(struct rte_flow_item *items, __rte_unused struct additional_para para) { static struct rte_flow_item_vlan vlan_spec = { - .tci = RTE_BE16(VLAN_VALUE), + .hdr.vlan_tci = RTE_BE16(VLAN_VALUE), }; static struct rte_flow_item_vlan vlan_mask = { - .tci = RTE_BE16(0xffff), + .hdr.vlan_tci = RTE_BE16(0xffff), }; items[items_counter].type = RTE_FLOW_ITEM_TYPE_VLAN; diff --git a/app/test-pmd/cmdline_flow.c b/app/test-pmd/cmdline_flow.c index 64297992d2..68fb4b3fe4 100644 --- a/app/test-pmd/cmdline_flow.c +++ b/app/test-pmd/cmdline_flow.c @@ -3599,19 +3599,19 @@ static const struct token token_list[] = { .name = "dst", .help = "destination MAC", .next = NEXT(item_eth, NEXT_ENTRY(COMMON_MAC_ADDR), item_param), - .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_eth, dst)), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_eth, hdr.dst_addr)), }, [ITEM_ETH_SRC] = { .name = "src", .help = "source MAC", .next = NEXT(item_eth, NEXT_ENTRY(COMMON_MAC_ADDR), item_param), - .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_eth, src)), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_eth, hdr.src_addr)), }, [ITEM_ETH_TYPE] = { .name = "type", .help = "EtherType", .next = NEXT(item_eth, NEXT_ENTRY(COMMON_UNSIGNED), item_param), - .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_eth, type)), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_eth, hdr.ether_type)), }, [ITEM_ETH_HAS_VLAN] = { .name = "has_vlan", @@ -3632,7 +3632,7 @@ static const struct token token_list[] = { .help = "tag control information", .next = NEXT(item_vlan, NEXT_ENTRY(COMMON_UNSIGNED), item_param), - .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_vlan, tci)), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_vlan, hdr.vlan_tci)), }, [ITEM_VLAN_PCP] = { .name = "pcp", @@ -3640,7 +3640,7 @@ static const struct token token_list[] = { .next = NEXT(item_vlan, NEXT_ENTRY(COMMON_UNSIGNED), item_param), .args = ARGS(ARGS_ENTRY_MASK_HTON(struct rte_flow_item_vlan, - tci, "\xe0\x00")), + hdr.vlan_tci, "\xe0\x00")), }, [ITEM_VLAN_DEI] = { .name = "dei", @@ -3648,7 +3648,7 @@ static const struct token token_list[] = { .next = NEXT(item_vlan, NEXT_ENTRY(COMMON_UNSIGNED), item_param), .args = ARGS(ARGS_ENTRY_MASK_HTON(struct rte_flow_item_vlan, - tci, "\x10\x00")), + hdr.vlan_tci, "\x10\x00")), }, [ITEM_VLAN_VID] = { .name = "vid", @@ -3656,7 +3656,7 @@ static const struct token token_list[] = { .next = NEXT(item_vlan, NEXT_ENTRY(COMMON_UNSIGNED), item_param), .args = ARGS(ARGS_ENTRY_MASK_HTON(struct rte_flow_item_vlan, - tci, "\x0f\xff")), + hdr.vlan_tci, "\x0f\xff")), }, [ITEM_VLAN_INNER_TYPE] = { .name = "inner_type", @@ -3664,7 +3664,7 @@ static const struct token token_list[] = { .next = NEXT(item_vlan, NEXT_ENTRY(COMMON_UNSIGNED), item_param), .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_vlan, - inner_type)), + hdr.eth_proto)), }, [ITEM_VLAN_HAS_MORE_VLAN] = { .name = "has_more_vlan", @@ -7402,10 +7402,10 @@ parse_setup_vxlan_encap_data(struct action_vxlan_encap_data *action_vxlan_encap_ .type = RTE_FLOW_ITEM_TYPE_END, }, }, - .item_eth.type = 0, + .item_eth.hdr.ether_type = 0, .item_vlan = { - .tci = vxlan_encap_conf.vlan_tci, - .inner_type = 0, + .hdr.vlan_tci = vxlan_encap_conf.vlan_tci, + .hdr.eth_proto = 0, }, .item_ipv4.hdr = { .src_addr = vxlan_encap_conf.ipv4_src, @@ -7417,9 +7417,9 @@ parse_setup_vxlan_encap_data(struct action_vxlan_encap_data *action_vxlan_encap_ }, .item_vxlan.flags = 0, }; - memcpy(action_vxlan_encap_data->item_eth.dst.addr_bytes, + memcpy(action_vxlan_encap_data->item_eth.hdr.dst_addr.addr_bytes, vxlan_encap_conf.eth_dst, RTE_ETHER_ADDR_LEN); - memcpy(action_vxlan_encap_data->item_eth.src.addr_bytes, + memcpy(action_vxlan_encap_data->item_eth.hdr.src_addr.addr_bytes, vxlan_encap_conf.eth_src, RTE_ETHER_ADDR_LEN); if (!vxlan_encap_conf.select_ipv4) { memcpy(&action_vxlan_encap_data->item_ipv6.hdr.src_addr, @@ -7537,10 +7537,10 @@ parse_setup_nvgre_encap_data(struct action_nvgre_encap_data *action_nvgre_encap_ .type = RTE_FLOW_ITEM_TYPE_END, }, }, - .item_eth.type = 0, + .item_eth.hdr.ether_type = 0, .item_vlan = { - .tci = nvgre_encap_conf.vlan_tci, - .inner_type = 0, + .hdr.vlan_tci = nvgre_encap_conf.vlan_tci, + .hdr.eth_proto = 0, }, .item_ipv4.hdr = { .src_addr = nvgre_encap_conf.ipv4_src, @@ -7550,9 +7550,9 @@ parse_setup_nvgre_encap_data(struct action_nvgre_encap_data *action_nvgre_encap_ .item_nvgre.protocol = RTE_BE16(RTE_ETHER_TYPE_TEB), .item_nvgre.flow_id = 0, }; - memcpy(action_nvgre_encap_data->item_eth.dst.addr_bytes, + memcpy(action_nvgre_encap_data->item_eth.hdr.dst_addr.addr_bytes, nvgre_encap_conf.eth_dst, RTE_ETHER_ADDR_LEN); - memcpy(action_nvgre_encap_data->item_eth.src.addr_bytes, + memcpy(action_nvgre_encap_data->item_eth.hdr.src_addr.addr_bytes, nvgre_encap_conf.eth_src, RTE_ETHER_ADDR_LEN); if (!nvgre_encap_conf.select_ipv4) { memcpy(&action_nvgre_encap_data->item_ipv6.hdr.src_addr, @@ -7613,10 +7613,10 @@ parse_vc_action_l2_encap(struct context *ctx, const struct token *token, struct buffer *out = buf; struct rte_flow_action *action; struct action_raw_encap_data *action_encap_data; - struct rte_flow_item_eth eth = { .type = 0, }; + struct rte_flow_item_eth eth = { .hdr.ether_type = 0, }; struct rte_flow_item_vlan vlan = { - .tci = mplsoudp_encap_conf.vlan_tci, - .inner_type = 0, + .hdr.vlan_tci = mplsoudp_encap_conf.vlan_tci, + .hdr.eth_proto = 0, }; uint8_t *header; int ret; @@ -7643,22 +7643,22 @@ parse_vc_action_l2_encap(struct context *ctx, const struct token *token, }; header = action_encap_data->data; if (l2_encap_conf.select_vlan) - eth.type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN); + eth.hdr.ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN); else if (l2_encap_conf.select_ipv4) - eth.type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4); + eth.hdr.ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4); else - eth.type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6); - memcpy(eth.dst.addr_bytes, + eth.hdr.ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6); + memcpy(eth.hdr.dst_addr.addr_bytes, l2_encap_conf.eth_dst, RTE_ETHER_ADDR_LEN); - memcpy(eth.src.addr_bytes, + memcpy(eth.hdr.src_addr.addr_bytes, l2_encap_conf.eth_src, RTE_ETHER_ADDR_LEN); memcpy(header, ð, sizeof(eth)); header += sizeof(eth); if (l2_encap_conf.select_vlan) { if (l2_encap_conf.select_ipv4) - vlan.inner_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4); + vlan.hdr.eth_proto = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4); else - vlan.inner_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6); + vlan.hdr.eth_proto = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6); memcpy(header, &vlan, sizeof(vlan)); header += sizeof(vlan); } @@ -7677,10 +7677,10 @@ parse_vc_action_l2_decap(struct context *ctx, const struct token *token, struct buffer *out = buf; struct rte_flow_action *action; struct action_raw_decap_data *action_decap_data; - struct rte_flow_item_eth eth = { .type = 0, }; + struct rte_flow_item_eth eth = { .hdr.ether_type = 0, }; struct rte_flow_item_vlan vlan = { - .tci = mplsoudp_encap_conf.vlan_tci, - .inner_type = 0, + .hdr.vlan_tci = mplsoudp_encap_conf.vlan_tci, + .hdr.eth_proto = 0, }; uint8_t *header; int ret; @@ -7707,7 +7707,7 @@ parse_vc_action_l2_decap(struct context *ctx, const struct token *token, }; header = action_decap_data->data; if (l2_decap_conf.select_vlan) - eth.type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN); + eth.hdr.ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN); memcpy(header, ð, sizeof(eth)); header += sizeof(eth); if (l2_decap_conf.select_vlan) { @@ -7731,10 +7731,10 @@ parse_vc_action_mplsogre_encap(struct context *ctx, const struct token *token, struct buffer *out = buf; struct rte_flow_action *action; struct action_raw_encap_data *action_encap_data; - struct rte_flow_item_eth eth = { .type = 0, }; + struct rte_flow_item_eth eth = { .hdr.ether_type = 0, }; struct rte_flow_item_vlan vlan = { - .tci = mplsogre_encap_conf.vlan_tci, - .inner_type = 0, + .hdr.vlan_tci = mplsogre_encap_conf.vlan_tci, + .hdr.eth_proto = 0, }; struct rte_flow_item_ipv4 ipv4 = { .hdr = { @@ -7783,22 +7783,22 @@ parse_vc_action_mplsogre_encap(struct context *ctx, const struct token *token, }; header = action_encap_data->data; if (mplsogre_encap_conf.select_vlan) - eth.type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN); + eth.hdr.ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN); else if (mplsogre_encap_conf.select_ipv4) - eth.type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4); + eth.hdr.ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4); else - eth.type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6); - memcpy(eth.dst.addr_bytes, + eth.hdr.ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6); + memcpy(eth.hdr.dst_addr.addr_bytes, mplsogre_encap_conf.eth_dst, RTE_ETHER_ADDR_LEN); - memcpy(eth.src.addr_bytes, + memcpy(eth.hdr.src_addr.addr_bytes, mplsogre_encap_conf.eth_src, RTE_ETHER_ADDR_LEN); memcpy(header, ð, sizeof(eth)); header += sizeof(eth); if (mplsogre_encap_conf.select_vlan) { if (mplsogre_encap_conf.select_ipv4) - vlan.inner_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4); + vlan.hdr.eth_proto = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4); else - vlan.inner_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6); + vlan.hdr.eth_proto = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6); memcpy(header, &vlan, sizeof(vlan)); header += sizeof(vlan); } @@ -7837,8 +7837,8 @@ parse_vc_action_mplsogre_decap(struct context *ctx, const struct token *token, struct buffer *out = buf; struct rte_flow_action *action; struct action_raw_decap_data *action_decap_data; - struct rte_flow_item_eth eth = { .type = 0, }; - struct rte_flow_item_vlan vlan = {.tci = 0}; + struct rte_flow_item_eth eth = { .hdr.ether_type = 0, }; + struct rte_flow_item_vlan vlan = {.hdr.vlan_tci = 0}; struct rte_flow_item_ipv4 ipv4 = { .hdr = { .next_proto_id = IPPROTO_GRE, @@ -7878,22 +7878,22 @@ parse_vc_action_mplsogre_decap(struct context *ctx, const struct token *token, }; header = action_decap_data->data; if (mplsogre_decap_conf.select_vlan) - eth.type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN); + eth.hdr.ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN); else if (mplsogre_encap_conf.select_ipv4) - eth.type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4); + eth.hdr.ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4); else - eth.type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6); - memcpy(eth.dst.addr_bytes, + eth.hdr.ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6); + memcpy(eth.hdr.dst_addr.addr_bytes, mplsogre_encap_conf.eth_dst, RTE_ETHER_ADDR_LEN); - memcpy(eth.src.addr_bytes, + memcpy(eth.hdr.src_addr.addr_bytes, mplsogre_encap_conf.eth_src, RTE_ETHER_ADDR_LEN); memcpy(header, ð, sizeof(eth)); header += sizeof(eth); if (mplsogre_encap_conf.select_vlan) { if (mplsogre_encap_conf.select_ipv4) - vlan.inner_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4); + vlan.hdr.eth_proto = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4); else - vlan.inner_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6); + vlan.hdr.eth_proto = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6); memcpy(header, &vlan, sizeof(vlan)); header += sizeof(vlan); } @@ -7924,10 +7924,10 @@ parse_vc_action_mplsoudp_encap(struct context *ctx, const struct token *token, struct buffer *out = buf; struct rte_flow_action *action; struct action_raw_encap_data *action_encap_data; - struct rte_flow_item_eth eth = { .type = 0, }; + struct rte_flow_item_eth eth = { .hdr.ether_type = 0, }; struct rte_flow_item_vlan vlan = { - .tci = mplsoudp_encap_conf.vlan_tci, - .inner_type = 0, + .hdr.vlan_tci = mplsoudp_encap_conf.vlan_tci, + .hdr.eth_proto = 0, }; struct rte_flow_item_ipv4 ipv4 = { .hdr = { @@ -7977,22 +7977,22 @@ parse_vc_action_mplsoudp_encap(struct context *ctx, const struct token *token, }; header = action_encap_data->data; if (mplsoudp_encap_conf.select_vlan) - eth.type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN); + eth.hdr.ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN); else if (mplsoudp_encap_conf.select_ipv4) - eth.type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4); + eth.hdr.ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4); else - eth.type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6); - memcpy(eth.dst.addr_bytes, + eth.hdr.ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6); + memcpy(eth.hdr.dst_addr.addr_bytes, mplsoudp_encap_conf.eth_dst, RTE_ETHER_ADDR_LEN); - memcpy(eth.src.addr_bytes, + memcpy(eth.hdr.src_addr.addr_bytes, mplsoudp_encap_conf.eth_src, RTE_ETHER_ADDR_LEN); memcpy(header, ð, sizeof(eth)); header += sizeof(eth); if (mplsoudp_encap_conf.select_vlan) { if (mplsoudp_encap_conf.select_ipv4) - vlan.inner_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4); + vlan.hdr.eth_proto = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4); else - vlan.inner_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6); + vlan.hdr.eth_proto = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6); memcpy(header, &vlan, sizeof(vlan)); header += sizeof(vlan); } @@ -8031,8 +8031,8 @@ parse_vc_action_mplsoudp_decap(struct context *ctx, const struct token *token, struct buffer *out = buf; struct rte_flow_action *action; struct action_raw_decap_data *action_decap_data; - struct rte_flow_item_eth eth = { .type = 0, }; - struct rte_flow_item_vlan vlan = {.tci = 0}; + struct rte_flow_item_eth eth = { .hdr.ether_type = 0, }; + struct rte_flow_item_vlan vlan = {.hdr.vlan_tci = 0}; struct rte_flow_item_ipv4 ipv4 = { .hdr = { .next_proto_id = IPPROTO_UDP, @@ -8074,22 +8074,22 @@ parse_vc_action_mplsoudp_decap(struct context *ctx, const struct token *token, }; header = action_decap_data->data; if (mplsoudp_decap_conf.select_vlan) - eth.type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN); + eth.hdr.ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN); else if (mplsoudp_encap_conf.select_ipv4) - eth.type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4); + eth.hdr.ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4); else - eth.type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6); - memcpy(eth.dst.addr_bytes, + eth.hdr.ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6); + memcpy(eth.hdr.dst_addr.addr_bytes, mplsoudp_encap_conf.eth_dst, RTE_ETHER_ADDR_LEN); - memcpy(eth.src.addr_bytes, + memcpy(eth.hdr.src_addr.addr_bytes, mplsoudp_encap_conf.eth_src, RTE_ETHER_ADDR_LEN); memcpy(header, ð, sizeof(eth)); header += sizeof(eth); if (mplsoudp_encap_conf.select_vlan) { if (mplsoudp_encap_conf.select_ipv4) - vlan.inner_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4); + vlan.hdr.eth_proto = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4); else - vlan.inner_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6); + vlan.hdr.eth_proto = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6); memcpy(header, &vlan, sizeof(vlan)); header += sizeof(vlan); } diff --git a/doc/guides/prog_guide/rte_flow.rst b/doc/guides/prog_guide/rte_flow.rst index 565868aeea..4323681b86 100644 --- a/doc/guides/prog_guide/rte_flow.rst +++ b/doc/guides/prog_guide/rte_flow.rst @@ -840,9 +840,7 @@ instead of using the ``type`` field. If the ``type`` and ``has_vlan`` fields are not specified, then both tagged and untagged packets will match the pattern. -- ``dst``: destination MAC. -- ``src``: source MAC. -- ``type``: EtherType or TPID. +- ``hdr``: header definition (``rte_ether.h``). - ``has_vlan``: packet header contains at least one VLAN. - Default ``mask`` matches destination and source addresses only. @@ -861,8 +859,7 @@ instead of using the ``inner_type field``. If the ``inner_type`` and ``has_more_vlan`` fields are not specified, then any tagged packets will match the pattern. -- ``tci``: tag control information. -- ``inner_type``: inner EtherType or TPID. +- ``hdr``: header definition (``rte_ether.h``). - ``has_more_vlan``: packet header contains at least one more VLAN, after this VLAN. - Default ``mask`` matches the VID part of TCI only (lower 12 bits). diff --git a/doc/guides/rel_notes/deprecation.rst b/doc/guides/rel_notes/deprecation.rst index 05cacb3ea8..368b857e20 100644 --- a/doc/guides/rel_notes/deprecation.rst +++ b/doc/guides/rel_notes/deprecation.rst @@ -58,14 +58,36 @@ Deprecation Notices to using the general ``rte_flow_modify_field`` action. * ethdev: The flow API matching pattern structures, ``struct rte_flow_item_*``, - should start with relevant protocol header. - Some matching pattern structures implements this by duplicating protocol header - fields in the struct. To clarify the intention and to be sure protocol header - is intact, will replace those fields with relevant protocol header struct. - In v21.02 both individual protocol header fields and the protocol header struct - will be added as union, target is switch usage to the protocol header by time. - In v21.11 LTS, protocol header fields will be cleaned and only protocol header - struct will remain. + should start with relevant protocol header structure from lib/net/. + The individual protocol header fields and the protocol header struct + may be kept together in an union as a first migration step. + In future (target is DPDK 23.11), the protocol header fields will be cleaned + and only protocol header struct will remain. + + These items are not compliant (not including struct from lib/net/): + - ``rte_flow_item_ah`` + - ``rte_flow_item_arp_eth_ipv4`` + - ``rte_flow_item_e_tag`` + - ``rte_flow_item_geneve`` + - ``rte_flow_item_geneve_opt`` + - ``rte_flow_item_gre`` + - ``rte_flow_item_gtp`` + - ``rte_flow_item_icmp6`` + - ``rte_flow_item_icmp6_nd_na`` + - ``rte_flow_item_icmp6_nd_ns`` + - ``rte_flow_item_icmp6_nd_opt`` + - ``rte_flow_item_icmp6_nd_opt_sla_eth`` + - ``rte_flow_item_icmp6_nd_opt_tla_eth`` + - ``rte_flow_item_igmp`` + - ``rte_flow_item_ipv6_ext`` + - ``rte_flow_item_l2tpv3oip`` + - ``rte_flow_item_mpls`` + - ``rte_flow_item_nsh`` + - ``rte_flow_item_nvgre`` + - ``rte_flow_item_pfcp`` + - ``rte_flow_item_pppoe`` + - ``rte_flow_item_pppoe_proto_id`` + - ``rte_flow_item_vxlan_gpe`` * ethdev: Queue specific stats fields will be removed from ``struct rte_eth_stats``. Mentioned fields are: ``q_ipackets``, ``q_opackets``, ``q_ibytes``, ``q_obytes``, diff --git a/drivers/net/bnxt/bnxt_flow.c b/drivers/net/bnxt/bnxt_flow.c index 96ef00460c..8f66049340 100644 --- a/drivers/net/bnxt/bnxt_flow.c +++ b/drivers/net/bnxt/bnxt_flow.c @@ -199,10 +199,10 @@ bnxt_validate_and_parse_flow_type(const struct rte_flow_attr *attr, * Destination MAC address mask must not be partially * set. Should be all 1's or all 0's. */ - if ((!rte_is_zero_ether_addr(ð_mask->src) && - !rte_is_broadcast_ether_addr(ð_mask->src)) || - (!rte_is_zero_ether_addr(ð_mask->dst) && - !rte_is_broadcast_ether_addr(ð_mask->dst))) { + if ((!rte_is_zero_ether_addr(ð_mask->hdr.src_addr) && + !rte_is_broadcast_ether_addr(ð_mask->hdr.src_addr)) || + (!rte_is_zero_ether_addr(ð_mask->hdr.dst_addr) && + !rte_is_broadcast_ether_addr(ð_mask->hdr.dst_addr))) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, @@ -212,8 +212,8 @@ bnxt_validate_and_parse_flow_type(const struct rte_flow_attr *attr, } /* Mask is not allowed. Only exact matches are */ - if (eth_mask->type && - eth_mask->type != RTE_BE16(0xffff)) { + if (eth_mask->hdr.ether_type && + eth_mask->hdr.ether_type != RTE_BE16(0xffff)) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, @@ -221,8 +221,8 @@ bnxt_validate_and_parse_flow_type(const struct rte_flow_attr *attr, return -rte_errno; } - if (rte_is_broadcast_ether_addr(ð_mask->dst)) { - dst = ð_spec->dst; + if (rte_is_broadcast_ether_addr(ð_mask->hdr.dst_addr)) { + dst = ð_spec->hdr.dst_addr; if (!rte_is_valid_assigned_ether_addr(dst)) { rte_flow_error_set(error, EINVAL, @@ -234,7 +234,7 @@ bnxt_validate_and_parse_flow_type(const struct rte_flow_attr *attr, return -rte_errno; } rte_memcpy(filter->dst_macaddr, - ð_spec->dst, RTE_ETHER_ADDR_LEN); + ð_spec->hdr.dst_addr, RTE_ETHER_ADDR_LEN); en |= use_ntuple ? NTUPLE_FLTR_ALLOC_INPUT_EN_DST_MACADDR : EM_FLOW_ALLOC_INPUT_EN_DST_MACADDR; @@ -245,8 +245,8 @@ bnxt_validate_and_parse_flow_type(const struct rte_flow_attr *attr, PMD_DRV_LOG(DEBUG, "Creating a priority flow\n"); } - if (rte_is_broadcast_ether_addr(ð_mask->src)) { - src = ð_spec->src; + if (rte_is_broadcast_ether_addr(ð_mask->hdr.src_addr)) { + src = ð_spec->hdr.src_addr; if (!rte_is_valid_assigned_ether_addr(src)) { rte_flow_error_set(error, EINVAL, @@ -258,7 +258,7 @@ bnxt_validate_and_parse_flow_type(const struct rte_flow_attr *attr, return -rte_errno; } rte_memcpy(filter->src_macaddr, - ð_spec->src, RTE_ETHER_ADDR_LEN); + ð_spec->hdr.src_addr, RTE_ETHER_ADDR_LEN); en |= use_ntuple ? NTUPLE_FLTR_ALLOC_INPUT_EN_SRC_MACADDR : EM_FLOW_ALLOC_INPUT_EN_SRC_MACADDR; @@ -270,9 +270,9 @@ bnxt_validate_and_parse_flow_type(const struct rte_flow_attr *attr, * PMD_DRV_LOG(ERR, "Handle this condition\n"); * } */ - if (eth_mask->type) { + if (eth_mask->hdr.ether_type) { filter->ethertype = - rte_be_to_cpu_16(eth_spec->type); + rte_be_to_cpu_16(eth_spec->hdr.ether_type); en |= en_ethertype; } if (inner) @@ -295,11 +295,11 @@ bnxt_validate_and_parse_flow_type(const struct rte_flow_attr *attr, " supported"); return -rte_errno; } - if (vlan_mask->tci && - vlan_mask->tci == RTE_BE16(0x0fff)) { + if (vlan_mask->hdr.vlan_tci && + vlan_mask->hdr.vlan_tci == RTE_BE16(0x0fff)) { /* Only the VLAN ID can be matched. */ filter->l2_ovlan = - rte_be_to_cpu_16(vlan_spec->tci & + rte_be_to_cpu_16(vlan_spec->hdr.vlan_tci & RTE_BE16(0x0fff)); en |= EM_FLOW_ALLOC_INPUT_EN_OVLAN_VID; } else { @@ -310,8 +310,8 @@ bnxt_validate_and_parse_flow_type(const struct rte_flow_attr *attr, "VLAN mask is invalid"); return -rte_errno; } - if (vlan_mask->inner_type && - vlan_mask->inner_type != RTE_BE16(0xffff)) { + if (vlan_mask->hdr.eth_proto && + vlan_mask->hdr.eth_proto != RTE_BE16(0xffff)) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, @@ -319,9 +319,9 @@ bnxt_validate_and_parse_flow_type(const struct rte_flow_attr *attr, " valid"); return -rte_errno; } - if (vlan_mask->inner_type) { + if (vlan_mask->hdr.eth_proto) { filter->ethertype = - rte_be_to_cpu_16(vlan_spec->inner_type); + rte_be_to_cpu_16(vlan_spec->hdr.eth_proto); en |= en_ethertype; } diff --git a/drivers/net/bnxt/tf_ulp/ulp_rte_parser.c b/drivers/net/bnxt/tf_ulp/ulp_rte_parser.c index 1be649a16c..2928598ced 100644 --- a/drivers/net/bnxt/tf_ulp/ulp_rte_parser.c +++ b/drivers/net/bnxt/tf_ulp/ulp_rte_parser.c @@ -627,13 +627,13 @@ ulp_rte_eth_hdr_handler(const struct rte_flow_item *item, /* Perform validations */ if (eth_spec) { /* Todo: work around to avoid multicast and broadcast addr */ - if (ulp_rte_parser_is_bcmc_addr(ð_spec->dst)) + if (ulp_rte_parser_is_bcmc_addr(ð_spec->hdr.dst_addr)) return BNXT_TF_RC_PARSE_ERR; - if (ulp_rte_parser_is_bcmc_addr(ð_spec->src)) + if (ulp_rte_parser_is_bcmc_addr(ð_spec->hdr.src_addr)) return BNXT_TF_RC_PARSE_ERR; - eth_type = eth_spec->type; + eth_type = eth_spec->hdr.ether_type; } if (ulp_rte_prsr_fld_size_validate(params, &idx, @@ -646,22 +646,22 @@ ulp_rte_eth_hdr_handler(const struct rte_flow_item *item, * header fields */ dmac_idx = idx; - size = sizeof(((struct rte_flow_item_eth *)NULL)->dst.addr_bytes); + size = sizeof(((struct rte_flow_item_eth *)NULL)->hdr.dst_addr.addr_bytes); ulp_rte_prsr_fld_mask(params, &idx, size, - ulp_deference_struct(eth_spec, dst.addr_bytes), - ulp_deference_struct(eth_mask, dst.addr_bytes), + ulp_deference_struct(eth_spec, hdr.dst_addr.addr_bytes), + ulp_deference_struct(eth_mask, hdr.dst_addr.addr_bytes), ULP_PRSR_ACT_DEFAULT); - size = sizeof(((struct rte_flow_item_eth *)NULL)->src.addr_bytes); + size = sizeof(((struct rte_flow_item_eth *)NULL)->hdr.src_addr.addr_bytes); ulp_rte_prsr_fld_mask(params, &idx, size, - ulp_deference_struct(eth_spec, src.addr_bytes), - ulp_deference_struct(eth_mask, src.addr_bytes), + ulp_deference_struct(eth_spec, hdr.src_addr.addr_bytes), + ulp_deference_struct(eth_mask, hdr.src_addr.addr_bytes), ULP_PRSR_ACT_DEFAULT); - size = sizeof(((struct rte_flow_item_eth *)NULL)->type); + size = sizeof(((struct rte_flow_item_eth *)NULL)->hdr.ether_type); ulp_rte_prsr_fld_mask(params, &idx, size, - ulp_deference_struct(eth_spec, type), - ulp_deference_struct(eth_mask, type), + ulp_deference_struct(eth_spec, hdr.ether_type), + ulp_deference_struct(eth_mask, hdr.ether_type), ULP_PRSR_ACT_MATCH_IGNORE); /* Update the protocol hdr bitmap */ @@ -706,15 +706,15 @@ ulp_rte_vlan_hdr_handler(const struct rte_flow_item *item, uint32_t size; if (vlan_spec) { - vlan_tag = ntohs(vlan_spec->tci); + vlan_tag = ntohs(vlan_spec->hdr.vlan_tci); priority = htons(vlan_tag >> ULP_VLAN_PRIORITY_SHIFT); vlan_tag &= ULP_VLAN_TAG_MASK; vlan_tag = htons(vlan_tag); - eth_type = vlan_spec->inner_type; + eth_type = vlan_spec->hdr.eth_proto; } if (vlan_mask) { - vlan_tag_mask = ntohs(vlan_mask->tci); + vlan_tag_mask = ntohs(vlan_mask->hdr.vlan_tci); priority_mask = htons(vlan_tag_mask >> ULP_VLAN_PRIORITY_SHIFT); vlan_tag_mask &= 0xfff; @@ -741,7 +741,7 @@ ulp_rte_vlan_hdr_handler(const struct rte_flow_item *item, * Copy the rte_flow_item for vlan into hdr_field using Vlan * header fields */ - size = sizeof(((struct rte_flow_item_vlan *)NULL)->tci); + size = sizeof(((struct rte_flow_item_vlan *)NULL)->hdr.vlan_tci); /* * The priority field is ignored since OVS is setting it as * wild card match and it is not supported. This is a work @@ -757,10 +757,10 @@ ulp_rte_vlan_hdr_handler(const struct rte_flow_item *item, (vlan_mask) ? &vlan_tag_mask : NULL, ULP_PRSR_ACT_DEFAULT); - size = sizeof(((struct rte_flow_item_vlan *)NULL)->inner_type); + size = sizeof(((struct rte_flow_item_vlan *)NULL)->hdr.eth_proto); ulp_rte_prsr_fld_mask(params, &idx, size, - ulp_deference_struct(vlan_spec, inner_type), - ulp_deference_struct(vlan_mask, inner_type), + ulp_deference_struct(vlan_spec, hdr.eth_proto), + ulp_deference_struct(vlan_mask, hdr.eth_proto), ULP_PRSR_ACT_MATCH_IGNORE); /* Get the outer tag and inner tag counts */ @@ -1673,14 +1673,14 @@ ulp_rte_enc_eth_hdr_handler(struct ulp_rte_parser_params *params, uint32_t size; field = ¶ms->enc_field[BNXT_ULP_ENC_FIELD_ETH_DMAC]; - size = sizeof(eth_spec->dst.addr_bytes); - field = ulp_rte_parser_fld_copy(field, eth_spec->dst.addr_bytes, size); + size = sizeof(eth_spec->hdr.dst_addr.addr_bytes); + field = ulp_rte_parser_fld_copy(field, eth_spec->hdr.dst_addr.addr_bytes, size); - size = sizeof(eth_spec->src.addr_bytes); - field = ulp_rte_parser_fld_copy(field, eth_spec->src.addr_bytes, size); + size = sizeof(eth_spec->hdr.src_addr.addr_bytes); + field = ulp_rte_parser_fld_copy(field, eth_spec->hdr.src_addr.addr_bytes, size); - size = sizeof(eth_spec->type); - field = ulp_rte_parser_fld_copy(field, ð_spec->type, size); + size = sizeof(eth_spec->hdr.ether_type); + field = ulp_rte_parser_fld_copy(field, ð_spec->hdr.ether_type, size); ULP_BITMAP_SET(params->enc_hdr_bitmap.bits, BNXT_ULP_HDR_BIT_O_ETH); } @@ -1704,11 +1704,11 @@ ulp_rte_enc_vlan_hdr_handler(struct ulp_rte_parser_params *params, BNXT_ULP_HDR_BIT_OI_VLAN); } - size = sizeof(vlan_spec->tci); - field = ulp_rte_parser_fld_copy(field, &vlan_spec->tci, size); + size = sizeof(vlan_spec->hdr.vlan_tci); + field = ulp_rte_parser_fld_copy(field, &vlan_spec->hdr.vlan_tci, size); - size = sizeof(vlan_spec->inner_type); - field = ulp_rte_parser_fld_copy(field, &vlan_spec->inner_type, size); + size = sizeof(vlan_spec->hdr.eth_proto); + field = ulp_rte_parser_fld_copy(field, &vlan_spec->hdr.eth_proto, size); } /* Function to handle the parsing of RTE Flow item ipv4 Header. */ diff --git a/drivers/net/bonding/rte_eth_bond_pmd.c b/drivers/net/bonding/rte_eth_bond_pmd.c index 4081b21338..47b6a930a9 100644 --- a/drivers/net/bonding/rte_eth_bond_pmd.c +++ b/drivers/net/bonding/rte_eth_bond_pmd.c @@ -122,15 +122,15 @@ is_lacp_packets(uint16_t ethertype, uint8_t subtype, struct rte_mbuf *mbuf) */ static struct rte_flow_item_eth flow_item_eth_type_8023ad = { - .dst.addr_bytes = { 0 }, - .src.addr_bytes = { 0 }, - .type = RTE_BE16(RTE_ETHER_TYPE_SLOW), + .hdr.dst_addr.addr_bytes = { 0 }, + .hdr.src_addr.addr_bytes = { 0 }, + .hdr.ether_type = RTE_BE16(RTE_ETHER_TYPE_SLOW), }; static struct rte_flow_item_eth flow_item_eth_mask_type_8023ad = { - .dst.addr_bytes = { 0 }, - .src.addr_bytes = { 0 }, - .type = 0xFFFF, + .hdr.dst_addr.addr_bytes = { 0 }, + .hdr.src_addr.addr_bytes = { 0 }, + .hdr.ether_type = 0xFFFF, }; static struct rte_flow_item flow_item_8023ad[] = { diff --git a/drivers/net/cxgbe/cxgbe_flow.c b/drivers/net/cxgbe/cxgbe_flow.c index d66672a9e6..f5787c247f 100644 --- a/drivers/net/cxgbe/cxgbe_flow.c +++ b/drivers/net/cxgbe/cxgbe_flow.c @@ -188,22 +188,22 @@ ch_rte_parsetype_eth(const void *dmask, const struct rte_flow_item *item, return 0; /* we don't support SRC_MAC filtering*/ - if (!rte_is_zero_ether_addr(&spec->src) || - (umask && !rte_is_zero_ether_addr(&umask->src))) + if (!rte_is_zero_ether_addr(&spec->hdr.src_addr) || + (umask && !rte_is_zero_ether_addr(&umask->hdr.src_addr))) return rte_flow_error_set(e, ENOTSUP, RTE_FLOW_ERROR_TYPE_ITEM, item, "src mac filtering not supported"); - if (!rte_is_zero_ether_addr(&spec->dst) || - (umask && !rte_is_zero_ether_addr(&umask->dst))) { + if (!rte_is_zero_ether_addr(&spec->hdr.dst_addr) || + (umask && !rte_is_zero_ether_addr(&umask->hdr.dst_addr))) { CXGBE_FILL_FS(0, 0x1ff, macidx); - CXGBE_FILL_FS_MEMCPY(spec->dst.addr_bytes, mask->dst.addr_bytes, + CXGBE_FILL_FS_MEMCPY(spec->hdr.dst_addr.addr_bytes, mask->hdr.dst_addr.addr_bytes, dmac); } - if (spec->type || (umask && umask->type)) - CXGBE_FILL_FS(be16_to_cpu(spec->type), - be16_to_cpu(mask->type), ethtype); + if (spec->hdr.ether_type || (umask && umask->hdr.ether_type)) + CXGBE_FILL_FS(be16_to_cpu(spec->hdr.ether_type), + be16_to_cpu(mask->hdr.ether_type), ethtype); return 0; } @@ -239,26 +239,26 @@ ch_rte_parsetype_vlan(const void *dmask, const struct rte_flow_item *item, if (fs->val.ethtype == RTE_ETHER_TYPE_QINQ) { CXGBE_FILL_FS(1, 1, ovlan_vld); if (spec) { - if (spec->tci || (umask && umask->tci)) - CXGBE_FILL_FS(be16_to_cpu(spec->tci), - be16_to_cpu(mask->tci), ovlan); + if (spec->hdr.vlan_tci || (umask && umask->hdr.vlan_tci)) + CXGBE_FILL_FS(be16_to_cpu(spec->hdr.vlan_tci), + be16_to_cpu(mask->hdr.vlan_tci), ovlan); fs->mask.ethtype = 0; fs->val.ethtype = 0; } } else { CXGBE_FILL_FS(1, 1, ivlan_vld); if (spec) { - if (spec->tci || (umask && umask->tci)) - CXGBE_FILL_FS(be16_to_cpu(spec->tci), - be16_to_cpu(mask->tci), ivlan); + if (spec->hdr.vlan_tci || (umask && umask->hdr.vlan_tci)) + CXGBE_FILL_FS(be16_to_cpu(spec->hdr.vlan_tci), + be16_to_cpu(mask->hdr.vlan_tci), ivlan); fs->mask.ethtype = 0; fs->val.ethtype = 0; } } - if (spec && (spec->inner_type || (umask && umask->inner_type))) - CXGBE_FILL_FS(be16_to_cpu(spec->inner_type), - be16_to_cpu(mask->inner_type), ethtype); + if (spec && (spec->hdr.eth_proto || (umask && umask->hdr.eth_proto))) + CXGBE_FILL_FS(be16_to_cpu(spec->hdr.eth_proto), + be16_to_cpu(mask->hdr.eth_proto), ethtype); return 0; } @@ -889,17 +889,17 @@ static struct chrte_fparse parseitem[] = { [RTE_FLOW_ITEM_TYPE_ETH] = { .fptr = ch_rte_parsetype_eth, .dmask = &(const struct rte_flow_item_eth){ - .dst.addr_bytes = "\xff\xff\xff\xff\xff\xff", - .src.addr_bytes = "\x00\x00\x00\x00\x00\x00", - .type = 0xffff, + .hdr.dst_addr.addr_bytes = "\xff\xff\xff\xff\xff\xff", + .hdr.src_addr.addr_bytes = "\x00\x00\x00\x00\x00\x00", + .hdr.ether_type = 0xffff, } }, [RTE_FLOW_ITEM_TYPE_VLAN] = { .fptr = ch_rte_parsetype_vlan, .dmask = &(const struct rte_flow_item_vlan){ - .tci = 0xffff, - .inner_type = 0xffff, + .hdr.vlan_tci = 0xffff, + .hdr.eth_proto = 0xffff, } }, diff --git a/drivers/net/dpaa2/dpaa2_flow.c b/drivers/net/dpaa2/dpaa2_flow.c index df06c3862e..eec7e60650 100644 --- a/drivers/net/dpaa2/dpaa2_flow.c +++ b/drivers/net/dpaa2/dpaa2_flow.c @@ -100,13 +100,13 @@ enum rte_flow_action_type dpaa2_supported_fs_action_type[] = { #ifndef __cplusplus static const struct rte_flow_item_eth dpaa2_flow_item_eth_mask = { - .dst.addr_bytes = "\xff\xff\xff\xff\xff\xff", - .src.addr_bytes = "\xff\xff\xff\xff\xff\xff", - .type = RTE_BE16(0xffff), + .hdr.dst_addr.addr_bytes = "\xff\xff\xff\xff\xff\xff", + .hdr.src_addr.addr_bytes = "\xff\xff\xff\xff\xff\xff", + .hdr.ether_type = RTE_BE16(0xffff), }; static const struct rte_flow_item_vlan dpaa2_flow_item_vlan_mask = { - .tci = RTE_BE16(0xffff), + .hdr.vlan_tci = RTE_BE16(0xffff), }; static const struct rte_flow_item_ipv4 dpaa2_flow_item_ipv4_mask = { @@ -966,7 +966,7 @@ dpaa2_configure_flow_eth(struct rte_flow *flow, return -1; } - if (memcmp((const char *)&mask->src, zero_cmp, RTE_ETHER_ADDR_LEN)) { + if (memcmp((const char *)&mask->hdr.src_addr, zero_cmp, RTE_ETHER_ADDR_LEN)) { index = dpaa2_flow_extract_search( &priv->extract.qos_key_extract.dpkg, NET_PROT_ETH, NH_FLD_ETH_SA); @@ -1009,8 +1009,8 @@ dpaa2_configure_flow_eth(struct rte_flow *flow, &flow->qos_rule, NET_PROT_ETH, NH_FLD_ETH_SA, - &spec->src.addr_bytes, - &mask->src.addr_bytes, + &spec->hdr.src_addr.addr_bytes, + &mask->hdr.src_addr.addr_bytes, sizeof(struct rte_ether_addr)); if (ret) { DPAA2_PMD_ERR("QoS NH_FLD_ETH_SA rule data set failed"); @@ -1022,8 +1022,8 @@ dpaa2_configure_flow_eth(struct rte_flow *flow, &flow->fs_rule, NET_PROT_ETH, NH_FLD_ETH_SA, - &spec->src.addr_bytes, - &mask->src.addr_bytes, + &spec->hdr.src_addr.addr_bytes, + &mask->hdr.src_addr.addr_bytes, sizeof(struct rte_ether_addr)); if (ret) { DPAA2_PMD_ERR("FS NH_FLD_ETH_SA rule data set failed"); @@ -1031,7 +1031,7 @@ dpaa2_configure_flow_eth(struct rte_flow *flow, } } - if (memcmp((const char *)&mask->dst, zero_cmp, RTE_ETHER_ADDR_LEN)) { + if (memcmp((const char *)&mask->hdr.dst_addr, zero_cmp, RTE_ETHER_ADDR_LEN)) { index = dpaa2_flow_extract_search( &priv->extract.qos_key_extract.dpkg, NET_PROT_ETH, NH_FLD_ETH_DA); @@ -1076,8 +1076,8 @@ dpaa2_configure_flow_eth(struct rte_flow *flow, &flow->qos_rule, NET_PROT_ETH, NH_FLD_ETH_DA, - &spec->dst.addr_bytes, - &mask->dst.addr_bytes, + &spec->hdr.dst_addr.addr_bytes, + &mask->hdr.dst_addr.addr_bytes, sizeof(struct rte_ether_addr)); if (ret) { DPAA2_PMD_ERR("QoS NH_FLD_ETH_DA rule data set failed"); @@ -1089,8 +1089,8 @@ dpaa2_configure_flow_eth(struct rte_flow *flow, &flow->fs_rule, NET_PROT_ETH, NH_FLD_ETH_DA, - &spec->dst.addr_bytes, - &mask->dst.addr_bytes, + &spec->hdr.dst_addr.addr_bytes, + &mask->hdr.dst_addr.addr_bytes, sizeof(struct rte_ether_addr)); if (ret) { DPAA2_PMD_ERR("FS NH_FLD_ETH_DA rule data set failed"); @@ -1098,7 +1098,7 @@ dpaa2_configure_flow_eth(struct rte_flow *flow, } } - if (memcmp((const char *)&mask->type, zero_cmp, sizeof(rte_be16_t))) { + if (memcmp((const char *)&mask->hdr.ether_type, zero_cmp, sizeof(rte_be16_t))) { index = dpaa2_flow_extract_search( &priv->extract.qos_key_extract.dpkg, NET_PROT_ETH, NH_FLD_ETH_TYPE); @@ -1142,8 +1142,8 @@ dpaa2_configure_flow_eth(struct rte_flow *flow, &flow->qos_rule, NET_PROT_ETH, NH_FLD_ETH_TYPE, - &spec->type, - &mask->type, + &spec->hdr.ether_type, + &mask->hdr.ether_type, sizeof(rte_be16_t)); if (ret) { DPAA2_PMD_ERR("QoS NH_FLD_ETH_TYPE rule data set failed"); @@ -1155,8 +1155,8 @@ dpaa2_configure_flow_eth(struct rte_flow *flow, &flow->fs_rule, NET_PROT_ETH, NH_FLD_ETH_TYPE, - &spec->type, - &mask->type, + &spec->hdr.ether_type, + &mask->hdr.ether_type, sizeof(rte_be16_t)); if (ret) { DPAA2_PMD_ERR("FS NH_FLD_ETH_TYPE rule data set failed"); @@ -1266,7 +1266,7 @@ dpaa2_configure_flow_vlan(struct rte_flow *flow, return -1; } - if (!mask->tci) + if (!mask->hdr.vlan_tci) return 0; index = dpaa2_flow_extract_search( @@ -1314,8 +1314,8 @@ dpaa2_configure_flow_vlan(struct rte_flow *flow, &flow->qos_rule, NET_PROT_VLAN, NH_FLD_VLAN_TCI, - &spec->tci, - &mask->tci, + &spec->hdr.vlan_tci, + &mask->hdr.vlan_tci, sizeof(rte_be16_t)); if (ret) { DPAA2_PMD_ERR("QoS NH_FLD_VLAN_TCI rule data set failed"); @@ -1327,8 +1327,8 @@ dpaa2_configure_flow_vlan(struct rte_flow *flow, &flow->fs_rule, NET_PROT_VLAN, NH_FLD_VLAN_TCI, - &spec->tci, - &mask->tci, + &spec->hdr.vlan_tci, + &mask->hdr.vlan_tci, sizeof(rte_be16_t)); if (ret) { DPAA2_PMD_ERR("FS NH_FLD_VLAN_TCI rule data set failed"); diff --git a/drivers/net/dpaa2/dpaa2_mux.c b/drivers/net/dpaa2/dpaa2_mux.c index 7456f43f42..2ff1a98fda 100644 --- a/drivers/net/dpaa2/dpaa2_mux.c +++ b/drivers/net/dpaa2/dpaa2_mux.c @@ -150,7 +150,7 @@ rte_pmd_dpaa2_mux_flow_create(uint32_t dpdmux_id, kg_cfg.num_extracts = 1; spec = (const struct rte_flow_item_eth *)pattern[0]->spec; - eth_type = rte_constant_bswap16(spec->type); + eth_type = rte_constant_bswap16(spec->hdr.ether_type); memcpy((void *)key_iova, (const void *)ð_type, sizeof(rte_be16_t)); memcpy(mask_iova, pattern[0]->mask, sizeof(uint16_t)); diff --git a/drivers/net/e1000/igb_flow.c b/drivers/net/e1000/igb_flow.c index b775310651..ea9b290e1c 100644 --- a/drivers/net/e1000/igb_flow.c +++ b/drivers/net/e1000/igb_flow.c @@ -555,16 +555,16 @@ cons_parse_ethertype_filter(const struct rte_flow_attr *attr, * Mask bits of destination MAC address must be full * of 1 or full of 0. */ - if (!rte_is_zero_ether_addr(ð_mask->src) || - (!rte_is_zero_ether_addr(ð_mask->dst) && - !rte_is_broadcast_ether_addr(ð_mask->dst))) { + if (!rte_is_zero_ether_addr(ð_mask->hdr.src_addr) || + (!rte_is_zero_ether_addr(ð_mask->hdr.dst_addr) && + !rte_is_broadcast_ether_addr(ð_mask->hdr.dst_addr))) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, "Invalid ether address mask"); return -rte_errno; } - if ((eth_mask->type & UINT16_MAX) != UINT16_MAX) { + if ((eth_mask->hdr.ether_type & UINT16_MAX) != UINT16_MAX) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, "Invalid ethertype mask"); @@ -574,13 +574,13 @@ cons_parse_ethertype_filter(const struct rte_flow_attr *attr, /* If mask bits of destination MAC address * are full of 1, set RTE_ETHTYPE_FLAGS_MAC. */ - if (rte_is_broadcast_ether_addr(ð_mask->dst)) { - filter->mac_addr = eth_spec->dst; + if (rte_is_broadcast_ether_addr(ð_mask->hdr.dst_addr)) { + filter->mac_addr = eth_spec->hdr.dst_addr; filter->flags |= RTE_ETHTYPE_FLAGS_MAC; } else { filter->flags &= ~RTE_ETHTYPE_FLAGS_MAC; } - filter->ether_type = rte_be_to_cpu_16(eth_spec->type); + filter->ether_type = rte_be_to_cpu_16(eth_spec->hdr.ether_type); /* Check if the next non-void item is END. */ index++; diff --git a/drivers/net/enic/enic_flow.c b/drivers/net/enic/enic_flow.c index cf51793cfe..e6c9ad442a 100644 --- a/drivers/net/enic/enic_flow.c +++ b/drivers/net/enic/enic_flow.c @@ -656,17 +656,17 @@ enic_copy_item_eth_v2(struct copy_item_args *arg) if (!mask) mask = &rte_flow_item_eth_mask; - memcpy(enic_spec.dst_addr.addr_bytes, spec->dst.addr_bytes, + memcpy(enic_spec.dst_addr.addr_bytes, spec->hdr.dst_addr.addr_bytes, RTE_ETHER_ADDR_LEN); - memcpy(enic_spec.src_addr.addr_bytes, spec->src.addr_bytes, + memcpy(enic_spec.src_addr.addr_bytes, spec->hdr.src_addr.addr_bytes, RTE_ETHER_ADDR_LEN); - memcpy(enic_mask.dst_addr.addr_bytes, mask->dst.addr_bytes, + memcpy(enic_mask.dst_addr.addr_bytes, mask->hdr.dst_addr.addr_bytes, RTE_ETHER_ADDR_LEN); - memcpy(enic_mask.src_addr.addr_bytes, mask->src.addr_bytes, + memcpy(enic_mask.src_addr.addr_bytes, mask->hdr.src_addr.addr_bytes, RTE_ETHER_ADDR_LEN); - enic_spec.ether_type = spec->type; - enic_mask.ether_type = mask->type; + enic_spec.ether_type = spec->hdr.ether_type; + enic_mask.ether_type = mask->hdr.ether_type; /* outer header */ memcpy(gp->layer[FILTER_GENERIC_1_L2].mask, &enic_mask, @@ -715,16 +715,16 @@ enic_copy_item_vlan_v2(struct copy_item_args *arg) struct rte_vlan_hdr *vlan; vlan = (struct rte_vlan_hdr *)(eth_mask + 1); - vlan->eth_proto = mask->inner_type; + vlan->eth_proto = mask->hdr.eth_proto; vlan = (struct rte_vlan_hdr *)(eth_val + 1); - vlan->eth_proto = spec->inner_type; + vlan->eth_proto = spec->hdr.eth_proto; } else { - eth_mask->ether_type = mask->inner_type; - eth_val->ether_type = spec->inner_type; + eth_mask->ether_type = mask->hdr.eth_proto; + eth_val->ether_type = spec->hdr.eth_proto; } /* For TCI, use the vlan mask/val fields (little endian). */ - gp->mask_vlan = rte_be_to_cpu_16(mask->tci); - gp->val_vlan = rte_be_to_cpu_16(spec->tci); + gp->mask_vlan = rte_be_to_cpu_16(mask->hdr.vlan_tci); + gp->val_vlan = rte_be_to_cpu_16(spec->hdr.vlan_tci); return 0; } diff --git a/drivers/net/enic/enic_fm_flow.c b/drivers/net/enic/enic_fm_flow.c index c87d3af847..90027dc676 100644 --- a/drivers/net/enic/enic_fm_flow.c +++ b/drivers/net/enic/enic_fm_flow.c @@ -462,10 +462,10 @@ enic_fm_copy_item_vlan(struct copy_item_args *arg) eth_val = (void *)&fm_data->l2.eth; /* - * Outer TPID cannot be matched. If inner_type is 0, use what is + * Outer TPID cannot be matched. If protocol is 0, use what is * in the eth header. */ - if (eth_mask->ether_type && mask->inner_type) + if (eth_mask->ether_type && mask->hdr.eth_proto) return -ENOTSUP; /* @@ -473,14 +473,14 @@ enic_fm_copy_item_vlan(struct copy_item_args *arg) * L2, regardless of vlan stripping settings. So, the inner type * from vlan becomes the ether type of the eth header. */ - if (mask->inner_type) { - eth_mask->ether_type = mask->inner_type; - eth_val->ether_type = spec->inner_type; + if (mask->hdr.eth_proto) { + eth_mask->ether_type = mask->hdr.eth_proto; + eth_val->ether_type = spec->hdr.eth_proto; } fm_data->fk_header_select |= FKH_ETHER | FKH_QTAG; fm_mask->fk_header_select |= FKH_ETHER | FKH_QTAG; - fm_data->fk_vlan = rte_be_to_cpu_16(spec->tci); - fm_mask->fk_vlan = rte_be_to_cpu_16(mask->tci); + fm_data->fk_vlan = rte_be_to_cpu_16(spec->hdr.vlan_tci); + fm_mask->fk_vlan = rte_be_to_cpu_16(mask->hdr.vlan_tci); return 0; } @@ -1385,7 +1385,7 @@ enic_fm_copy_vxlan_encap(struct enic_flowman *fm, ENICPMD_LOG(DEBUG, "vxlan-encap: vlan"); spec = item->spec; - fm_op.encap.outer_vlan = rte_be_to_cpu_16(spec->tci); + fm_op.encap.outer_vlan = rte_be_to_cpu_16(spec->hdr.vlan_tci); item++; flow_item_skip_void(&item); } diff --git a/drivers/net/hinic/hinic_pmd_flow.c b/drivers/net/hinic/hinic_pmd_flow.c index 358b372e07..d1a564a163 100644 --- a/drivers/net/hinic/hinic_pmd_flow.c +++ b/drivers/net/hinic/hinic_pmd_flow.c @@ -310,15 +310,15 @@ static int cons_parse_ethertype_filter(const struct rte_flow_attr *attr, * Mask bits of destination MAC address must be full * of 1 or full of 0. */ - if (!rte_is_zero_ether_addr(ð_mask->src) || - (!rte_is_zero_ether_addr(ð_mask->dst) && - !rte_is_broadcast_ether_addr(ð_mask->dst))) { + if (!rte_is_zero_ether_addr(ð_mask->hdr.src_addr) || + (!rte_is_zero_ether_addr(ð_mask->hdr.dst_addr) && + !rte_is_broadcast_ether_addr(ð_mask->hdr.dst_addr))) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, "Invalid ether address mask"); return -rte_errno; } - if ((eth_mask->type & UINT16_MAX) != UINT16_MAX) { + if ((eth_mask->hdr.ether_type & UINT16_MAX) != UINT16_MAX) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, "Invalid ethertype mask"); return -rte_errno; @@ -328,13 +328,13 @@ static int cons_parse_ethertype_filter(const struct rte_flow_attr *attr, * If mask bits of destination MAC address * are full of 1, set RTE_ETHTYPE_FLAGS_MAC. */ - if (rte_is_broadcast_ether_addr(ð_mask->dst)) { - filter->mac_addr = eth_spec->dst; + if (rte_is_broadcast_ether_addr(ð_mask->hdr.dst_addr)) { + filter->mac_addr = eth_spec->hdr.dst_addr; filter->flags |= RTE_ETHTYPE_FLAGS_MAC; } else { filter->flags &= ~RTE_ETHTYPE_FLAGS_MAC; } - filter->ether_type = rte_be_to_cpu_16(eth_spec->type); + filter->ether_type = rte_be_to_cpu_16(eth_spec->hdr.ether_type); /* Check if the next non-void item is END. */ item = next_no_void_pattern(pattern, item); diff --git a/drivers/net/hns3/hns3_flow.c b/drivers/net/hns3/hns3_flow.c index a2c1589c39..ef1832982d 100644 --- a/drivers/net/hns3/hns3_flow.c +++ b/drivers/net/hns3/hns3_flow.c @@ -493,28 +493,28 @@ hns3_parse_eth(const struct rte_flow_item *item, struct hns3_fdir_rule *rule, if (item->mask) { eth_mask = item->mask; - if (eth_mask->type) { + if (eth_mask->hdr.ether_type) { hns3_set_bit(rule->input_set, INNER_ETH_TYPE, 1); rule->key_conf.mask.ether_type = - rte_be_to_cpu_16(eth_mask->type); + rte_be_to_cpu_16(eth_mask->hdr.ether_type); } - if (!rte_is_zero_ether_addr(ð_mask->src)) { + if (!rte_is_zero_ether_addr(ð_mask->hdr.src_addr)) { hns3_set_bit(rule->input_set, INNER_SRC_MAC, 1); memcpy(rule->key_conf.mask.src_mac, - eth_mask->src.addr_bytes, RTE_ETHER_ADDR_LEN); + eth_mask->hdr.src_addr.addr_bytes, RTE_ETHER_ADDR_LEN); } - if (!rte_is_zero_ether_addr(ð_mask->dst)) { + if (!rte_is_zero_ether_addr(ð_mask->hdr.dst_addr)) { hns3_set_bit(rule->input_set, INNER_DST_MAC, 1); memcpy(rule->key_conf.mask.dst_mac, - eth_mask->dst.addr_bytes, RTE_ETHER_ADDR_LEN); + eth_mask->hdr.dst_addr.addr_bytes, RTE_ETHER_ADDR_LEN); } } eth_spec = item->spec; - rule->key_conf.spec.ether_type = rte_be_to_cpu_16(eth_spec->type); - memcpy(rule->key_conf.spec.src_mac, eth_spec->src.addr_bytes, + rule->key_conf.spec.ether_type = rte_be_to_cpu_16(eth_spec->hdr.ether_type); + memcpy(rule->key_conf.spec.src_mac, eth_spec->hdr.src_addr.addr_bytes, RTE_ETHER_ADDR_LEN); - memcpy(rule->key_conf.spec.dst_mac, eth_spec->dst.addr_bytes, + memcpy(rule->key_conf.spec.dst_mac, eth_spec->hdr.dst_addr.addr_bytes, RTE_ETHER_ADDR_LEN); return 0; } @@ -538,17 +538,17 @@ hns3_parse_vlan(const struct rte_flow_item *item, struct hns3_fdir_rule *rule, if (item->mask) { vlan_mask = item->mask; - if (vlan_mask->tci) { + if (vlan_mask->hdr.vlan_tci) { if (rule->key_conf.vlan_num == 1) { hns3_set_bit(rule->input_set, INNER_VLAN_TAG1, 1); rule->key_conf.mask.vlan_tag1 = - rte_be_to_cpu_16(vlan_mask->tci); + rte_be_to_cpu_16(vlan_mask->hdr.vlan_tci); } else { hns3_set_bit(rule->input_set, INNER_VLAN_TAG2, 1); rule->key_conf.mask.vlan_tag2 = - rte_be_to_cpu_16(vlan_mask->tci); + rte_be_to_cpu_16(vlan_mask->hdr.vlan_tci); } } } @@ -556,10 +556,10 @@ hns3_parse_vlan(const struct rte_flow_item *item, struct hns3_fdir_rule *rule, vlan_spec = item->spec; if (rule->key_conf.vlan_num == 1) rule->key_conf.spec.vlan_tag1 = - rte_be_to_cpu_16(vlan_spec->tci); + rte_be_to_cpu_16(vlan_spec->hdr.vlan_tci); else rule->key_conf.spec.vlan_tag2 = - rte_be_to_cpu_16(vlan_spec->tci); + rte_be_to_cpu_16(vlan_spec->hdr.vlan_tci); return 0; } diff --git a/drivers/net/i40e/i40e_flow.c b/drivers/net/i40e/i40e_flow.c index 65a826d51c..0acbd5a061 100644 --- a/drivers/net/i40e/i40e_flow.c +++ b/drivers/net/i40e/i40e_flow.c @@ -1322,9 +1322,9 @@ i40e_flow_parse_ethertype_pattern(struct rte_eth_dev *dev, * Mask bits of destination MAC address must be full * of 1 or full of 0. */ - if (!rte_is_zero_ether_addr(ð_mask->src) || - (!rte_is_zero_ether_addr(ð_mask->dst) && - !rte_is_broadcast_ether_addr(ð_mask->dst))) { + if (!rte_is_zero_ether_addr(ð_mask->hdr.src_addr) || + (!rte_is_zero_ether_addr(ð_mask->hdr.dst_addr) && + !rte_is_broadcast_ether_addr(ð_mask->hdr.dst_addr))) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, @@ -1332,7 +1332,7 @@ i40e_flow_parse_ethertype_pattern(struct rte_eth_dev *dev, return -rte_errno; } - if ((eth_mask->type & UINT16_MAX) != UINT16_MAX) { + if ((eth_mask->hdr.ether_type & UINT16_MAX) != UINT16_MAX) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, @@ -1343,13 +1343,13 @@ i40e_flow_parse_ethertype_pattern(struct rte_eth_dev *dev, /* If mask bits of destination MAC address * are full of 1, set RTE_ETHTYPE_FLAGS_MAC. */ - if (rte_is_broadcast_ether_addr(ð_mask->dst)) { - filter->mac_addr = eth_spec->dst; + if (rte_is_broadcast_ether_addr(ð_mask->hdr.dst_addr)) { + filter->mac_addr = eth_spec->hdr.dst_addr; filter->flags |= RTE_ETHTYPE_FLAGS_MAC; } else { filter->flags &= ~RTE_ETHTYPE_FLAGS_MAC; } - filter->ether_type = rte_be_to_cpu_16(eth_spec->type); + filter->ether_type = rte_be_to_cpu_16(eth_spec->hdr.ether_type); if (filter->ether_type == RTE_ETHER_TYPE_IPV4 || filter->ether_type == RTE_ETHER_TYPE_IPV6 || @@ -1662,25 +1662,25 @@ i40e_flow_parse_fdir_pattern(struct rte_eth_dev *dev, } if (eth_spec && eth_mask) { - if (rte_is_broadcast_ether_addr(ð_mask->dst) && - rte_is_zero_ether_addr(ð_mask->src)) { + if (rte_is_broadcast_ether_addr(ð_mask->hdr.dst_addr) && + rte_is_zero_ether_addr(ð_mask->hdr.src_addr)) { filter->input.flow.l2_flow.dst = - eth_spec->dst; + eth_spec->hdr.dst_addr; input_set |= I40E_INSET_DMAC; - } else if (rte_is_zero_ether_addr(ð_mask->dst) && - rte_is_broadcast_ether_addr(ð_mask->src)) { + } else if (rte_is_zero_ether_addr(ð_mask->hdr.dst_addr) && + rte_is_broadcast_ether_addr(ð_mask->hdr.src_addr)) { filter->input.flow.l2_flow.src = - eth_spec->src; + eth_spec->hdr.src_addr; input_set |= I40E_INSET_SMAC; - } else if (rte_is_broadcast_ether_addr(ð_mask->dst) && - rte_is_broadcast_ether_addr(ð_mask->src)) { + } else if (rte_is_broadcast_ether_addr(ð_mask->hdr.dst_addr) && + rte_is_broadcast_ether_addr(ð_mask->hdr.src_addr)) { filter->input.flow.l2_flow.dst = - eth_spec->dst; + eth_spec->hdr.dst_addr; filter->input.flow.l2_flow.src = - eth_spec->src; + eth_spec->hdr.src_addr; input_set |= (I40E_INSET_DMAC | I40E_INSET_SMAC); - } else if (!rte_is_zero_ether_addr(ð_mask->src) || - !rte_is_zero_ether_addr(ð_mask->dst)) { + } else if (!rte_is_zero_ether_addr(ð_mask->hdr.src_addr) || + !rte_is_zero_ether_addr(ð_mask->hdr.dst_addr)) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, @@ -1690,7 +1690,7 @@ i40e_flow_parse_fdir_pattern(struct rte_eth_dev *dev, } if (eth_spec && eth_mask && next_type == RTE_FLOW_ITEM_TYPE_END) { - if (eth_mask->type != RTE_BE16(0xffff)) { + if (eth_mask->hdr.ether_type != RTE_BE16(0xffff)) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, @@ -1698,7 +1698,7 @@ i40e_flow_parse_fdir_pattern(struct rte_eth_dev *dev, return -rte_errno; } - ether_type = rte_be_to_cpu_16(eth_spec->type); + ether_type = rte_be_to_cpu_16(eth_spec->hdr.ether_type); if (next_type == RTE_FLOW_ITEM_TYPE_VLAN || ether_type == RTE_ETHER_TYPE_IPV4 || @@ -1712,7 +1712,7 @@ i40e_flow_parse_fdir_pattern(struct rte_eth_dev *dev, } input_set |= I40E_INSET_LAST_ETHER_TYPE; filter->input.flow.l2_flow.ether_type = - eth_spec->type; + eth_spec->hdr.ether_type; } pctype = I40E_FILTER_PCTYPE_L2_PAYLOAD; @@ -1725,13 +1725,13 @@ i40e_flow_parse_fdir_pattern(struct rte_eth_dev *dev, RTE_ASSERT(!(input_set & I40E_INSET_LAST_ETHER_TYPE)); if (vlan_spec && vlan_mask) { - if (vlan_mask->tci != + if (vlan_mask->hdr.vlan_tci != rte_cpu_to_be_16(I40E_VLAN_TCI_MASK) && - vlan_mask->tci != + vlan_mask->hdr.vlan_tci != rte_cpu_to_be_16(I40E_VLAN_PRI_MASK) && - vlan_mask->tci != + vlan_mask->hdr.vlan_tci != rte_cpu_to_be_16(I40E_VLAN_CFI_MASK) && - vlan_mask->tci != + vlan_mask->hdr.vlan_tci != rte_cpu_to_be_16(I40E_VLAN_VID_MASK)) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, @@ -1740,10 +1740,10 @@ i40e_flow_parse_fdir_pattern(struct rte_eth_dev *dev, } input_set |= I40E_INSET_VLAN_INNER; filter->input.flow_ext.vlan_tci = - vlan_spec->tci; + vlan_spec->hdr.vlan_tci; } - if (vlan_spec && vlan_mask && vlan_mask->inner_type) { - if (vlan_mask->inner_type != RTE_BE16(0xffff)) { + if (vlan_spec && vlan_mask && vlan_mask->hdr.eth_proto) { + if (vlan_mask->hdr.eth_proto != RTE_BE16(0xffff)) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, @@ -1753,7 +1753,7 @@ i40e_flow_parse_fdir_pattern(struct rte_eth_dev *dev, } ether_type = - rte_be_to_cpu_16(vlan_spec->inner_type); + rte_be_to_cpu_16(vlan_spec->hdr.eth_proto); if (ether_type == RTE_ETHER_TYPE_IPV4 || ether_type == RTE_ETHER_TYPE_IPV6 || @@ -1766,7 +1766,7 @@ i40e_flow_parse_fdir_pattern(struct rte_eth_dev *dev, } input_set |= I40E_INSET_LAST_ETHER_TYPE; filter->input.flow.l2_flow.ether_type = - vlan_spec->inner_type; + vlan_spec->hdr.eth_proto; } pctype = I40E_FILTER_PCTYPE_L2_PAYLOAD; @@ -2908,9 +2908,9 @@ i40e_flow_parse_vxlan_pattern(__rte_unused struct rte_eth_dev *dev, /* DST address of inner MAC shouldn't be masked. * SRC address of Inner MAC should be masked. */ - if (!rte_is_broadcast_ether_addr(ð_mask->dst) || - !rte_is_zero_ether_addr(ð_mask->src) || - eth_mask->type) { + if (!rte_is_broadcast_ether_addr(ð_mask->hdr.dst_addr) || + !rte_is_zero_ether_addr(ð_mask->hdr.src_addr) || + eth_mask->hdr.ether_type) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, @@ -2920,12 +2920,12 @@ i40e_flow_parse_vxlan_pattern(__rte_unused struct rte_eth_dev *dev, if (!vxlan_flag) { rte_memcpy(&filter->outer_mac, - ð_spec->dst, + ð_spec->hdr.dst_addr, RTE_ETHER_ADDR_LEN); filter_type |= RTE_ETH_TUNNEL_FILTER_OMAC; } else { rte_memcpy(&filter->inner_mac, - ð_spec->dst, + ð_spec->hdr.dst_addr, RTE_ETHER_ADDR_LEN); filter_type |= RTE_ETH_TUNNEL_FILTER_IMAC; } @@ -2935,7 +2935,7 @@ i40e_flow_parse_vxlan_pattern(__rte_unused struct rte_eth_dev *dev, vlan_spec = item->spec; vlan_mask = item->mask; if (!(vlan_spec && vlan_mask) || - vlan_mask->inner_type) { + vlan_mask->hdr.eth_proto) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, @@ -2944,10 +2944,10 @@ i40e_flow_parse_vxlan_pattern(__rte_unused struct rte_eth_dev *dev, } if (vlan_spec && vlan_mask) { - if (vlan_mask->tci == + if (vlan_mask->hdr.vlan_tci == rte_cpu_to_be_16(I40E_VLAN_TCI_MASK)) filter->inner_vlan = - rte_be_to_cpu_16(vlan_spec->tci) & + rte_be_to_cpu_16(vlan_spec->hdr.vlan_tci) & I40E_VLAN_TCI_MASK; filter_type |= RTE_ETH_TUNNEL_FILTER_IVLAN; } @@ -3138,9 +3138,9 @@ i40e_flow_parse_nvgre_pattern(__rte_unused struct rte_eth_dev *dev, /* DST address of inner MAC shouldn't be masked. * SRC address of Inner MAC should be masked. */ - if (!rte_is_broadcast_ether_addr(ð_mask->dst) || - !rte_is_zero_ether_addr(ð_mask->src) || - eth_mask->type) { + if (!rte_is_broadcast_ether_addr(ð_mask->hdr.dst_addr) || + !rte_is_zero_ether_addr(ð_mask->hdr.src_addr) || + eth_mask->hdr.ether_type) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, @@ -3150,12 +3150,12 @@ i40e_flow_parse_nvgre_pattern(__rte_unused struct rte_eth_dev *dev, if (!nvgre_flag) { rte_memcpy(&filter->outer_mac, - ð_spec->dst, + ð_spec->hdr.dst_addr, RTE_ETHER_ADDR_LEN); filter_type |= RTE_ETH_TUNNEL_FILTER_OMAC; } else { rte_memcpy(&filter->inner_mac, - ð_spec->dst, + ð_spec->hdr.dst_addr, RTE_ETHER_ADDR_LEN); filter_type |= RTE_ETH_TUNNEL_FILTER_IMAC; } @@ -3166,7 +3166,7 @@ i40e_flow_parse_nvgre_pattern(__rte_unused struct rte_eth_dev *dev, vlan_spec = item->spec; vlan_mask = item->mask; if (!(vlan_spec && vlan_mask) || - vlan_mask->inner_type) { + vlan_mask->hdr.eth_proto) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, @@ -3175,10 +3175,10 @@ i40e_flow_parse_nvgre_pattern(__rte_unused struct rte_eth_dev *dev, } if (vlan_spec && vlan_mask) { - if (vlan_mask->tci == + if (vlan_mask->hdr.vlan_tci == rte_cpu_to_be_16(I40E_VLAN_TCI_MASK)) filter->inner_vlan = - rte_be_to_cpu_16(vlan_spec->tci) & + rte_be_to_cpu_16(vlan_spec->hdr.vlan_tci) & I40E_VLAN_TCI_MASK; filter_type |= RTE_ETH_TUNNEL_FILTER_IVLAN; } @@ -3675,7 +3675,7 @@ i40e_flow_parse_qinq_pattern(__rte_unused struct rte_eth_dev *dev, vlan_mask = item->mask; if (!(vlan_spec && vlan_mask) || - vlan_mask->inner_type) { + vlan_mask->hdr.eth_proto) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, @@ -3701,8 +3701,8 @@ i40e_flow_parse_qinq_pattern(__rte_unused struct rte_eth_dev *dev, /* Get filter specification */ if (o_vlan_mask != NULL && i_vlan_mask != NULL) { - filter->outer_vlan = rte_be_to_cpu_16(o_vlan_spec->tci); - filter->inner_vlan = rte_be_to_cpu_16(i_vlan_spec->tci); + filter->outer_vlan = rte_be_to_cpu_16(o_vlan_spec->hdr.vlan_tci); + filter->inner_vlan = rte_be_to_cpu_16(i_vlan_spec->hdr.vlan_tci); } else { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, diff --git a/drivers/net/i40e/i40e_hash.c b/drivers/net/i40e/i40e_hash.c index a1ff85fceb..3f6285720f 100644 --- a/drivers/net/i40e/i40e_hash.c +++ b/drivers/net/i40e/i40e_hash.c @@ -990,7 +990,7 @@ i40e_hash_parse_queue_region(const struct rte_eth_dev *dev, vlan_spec = pattern->spec; vlan_mask = pattern->mask; if (!vlan_spec || !vlan_mask || - (rte_be_to_cpu_16(vlan_mask->tci) >> 13) != 7) + (rte_be_to_cpu_16(vlan_mask->hdr.vlan_tci) >> 13) != 7) return rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, pattern, "Pattern error."); @@ -1037,7 +1037,7 @@ i40e_hash_parse_queue_region(const struct rte_eth_dev *dev, rss_conf->region_queue_num = (uint8_t)rss_act->queue_num; rss_conf->region_queue_start = rss_act->queue[0]; - rss_conf->region_priority = rte_be_to_cpu_16(vlan_spec->tci) >> 13; + rss_conf->region_priority = rte_be_to_cpu_16(vlan_spec->hdr.vlan_tci) >> 13; return 0; } diff --git a/drivers/net/iavf/iavf_fdir.c b/drivers/net/iavf/iavf_fdir.c index 8f80873925..a6c88cb55b 100644 --- a/drivers/net/iavf/iavf_fdir.c +++ b/drivers/net/iavf/iavf_fdir.c @@ -850,27 +850,27 @@ iavf_fdir_parse_pattern(__rte_unused struct iavf_adapter *ad, } if (eth_spec && eth_mask) { - if (!rte_is_zero_ether_addr(ð_mask->dst)) { + if (!rte_is_zero_ether_addr(ð_mask->hdr.dst_addr)) { input_set |= IAVF_INSET_DMAC; VIRTCHNL_ADD_PROTO_HDR_FIELD_BIT(hdr1, ETH, DST); - } else if (!rte_is_zero_ether_addr(ð_mask->src)) { + } else if (!rte_is_zero_ether_addr(ð_mask->hdr.src_addr)) { input_set |= IAVF_INSET_SMAC; VIRTCHNL_ADD_PROTO_HDR_FIELD_BIT(hdr1, ETH, SRC); } - if (eth_mask->type) { - if (eth_mask->type != RTE_BE16(0xffff)) { + if (eth_mask->hdr.ether_type) { + if (eth_mask->hdr.ether_type != RTE_BE16(0xffff)) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, "Invalid type mask."); return -rte_errno; } - ether_type = rte_be_to_cpu_16(eth_spec->type); + ether_type = rte_be_to_cpu_16(eth_spec->hdr.ether_type); if (ether_type == RTE_ETHER_TYPE_IPV4 || ether_type == RTE_ETHER_TYPE_IPV6) { rte_flow_error_set(error, EINVAL, diff --git a/drivers/net/iavf/iavf_fsub.c b/drivers/net/iavf/iavf_fsub.c index 3be75923a5..4760b9bae3 100644 --- a/drivers/net/iavf/iavf_fsub.c +++ b/drivers/net/iavf/iavf_fsub.c @@ -189,7 +189,7 @@ iavf_fsub_parse_pattern(const struct rte_flow_item pattern[], if (eth_spec && eth_mask) { input = &outer_input_set; - if (!rte_is_zero_ether_addr(ð_mask->dst)) { + if (!rte_is_zero_ether_addr(ð_mask->hdr.dst_addr)) { *input |= IAVF_INSET_DMAC; input_set_byte += 6; } else { @@ -197,12 +197,12 @@ iavf_fsub_parse_pattern(const struct rte_flow_item pattern[], input_set_byte += 6; } - if (!rte_is_zero_ether_addr(ð_mask->src)) { + if (!rte_is_zero_ether_addr(ð_mask->hdr.src_addr)) { *input |= IAVF_INSET_SMAC; input_set_byte += 6; } - if (eth_mask->type) { + if (eth_mask->hdr.ether_type) { *input |= IAVF_INSET_ETHERTYPE; input_set_byte += 2; } @@ -419,10 +419,10 @@ iavf_fsub_parse_pattern(const struct rte_flow_item pattern[], *input |= IAVF_INSET_VLAN_OUTER; - if (vlan_mask->tci) + if (vlan_mask->hdr.vlan_tci) input_set_byte += 2; - if (vlan_mask->inner_type) { + if (vlan_mask->hdr.eth_proto) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, diff --git a/drivers/net/iavf/iavf_ipsec_crypto.c b/drivers/net/iavf/iavf_ipsec_crypto.c index afd7f8f467..259594c3df 100644 --- a/drivers/net/iavf/iavf_ipsec_crypto.c +++ b/drivers/net/iavf/iavf_ipsec_crypto.c @@ -1690,9 +1690,9 @@ parse_eth_item(const struct rte_flow_item_eth *item, struct rte_ether_hdr *eth) { memcpy(eth->src_addr.addr_bytes, - item->src.addr_bytes, sizeof(eth->src_addr)); + item->hdr.src_addr.addr_bytes, sizeof(eth->src_addr)); memcpy(eth->dst_addr.addr_bytes, - item->dst.addr_bytes, sizeof(eth->dst_addr)); + item->hdr.dst_addr.addr_bytes, sizeof(eth->dst_addr)); } static void diff --git a/drivers/net/ice/ice_acl_filter.c b/drivers/net/ice/ice_acl_filter.c index 8fe6f5aeb0..f2ddbd7b9b 100644 --- a/drivers/net/ice/ice_acl_filter.c +++ b/drivers/net/ice/ice_acl_filter.c @@ -675,36 +675,36 @@ ice_acl_parse_pattern(__rte_unused struct ice_adapter *ad, eth_mask = item->mask; if (eth_spec && eth_mask) { - if (rte_is_broadcast_ether_addr(ð_mask->src) || - rte_is_broadcast_ether_addr(ð_mask->dst)) { + if (rte_is_broadcast_ether_addr(ð_mask->hdr.src_addr) || + rte_is_broadcast_ether_addr(ð_mask->hdr.dst_addr)) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, "Invalid mac addr mask"); return -rte_errno; } - if (!rte_is_zero_ether_addr(ð_spec->src) && - !rte_is_zero_ether_addr(ð_mask->src)) { + if (!rte_is_zero_ether_addr(ð_spec->hdr.src_addr) && + !rte_is_zero_ether_addr(ð_mask->hdr.src_addr)) { input_set |= ICE_INSET_SMAC; ice_memcpy(&filter->input.ext_data.src_mac, - ð_spec->src, + ð_spec->hdr.src_addr, RTE_ETHER_ADDR_LEN, ICE_NONDMA_TO_NONDMA); ice_memcpy(&filter->input.ext_mask.src_mac, - ð_mask->src, + ð_mask->hdr.src_addr, RTE_ETHER_ADDR_LEN, ICE_NONDMA_TO_NONDMA); } - if (!rte_is_zero_ether_addr(ð_spec->dst) && - !rte_is_zero_ether_addr(ð_mask->dst)) { + if (!rte_is_zero_ether_addr(ð_spec->hdr.dst_addr) && + !rte_is_zero_ether_addr(ð_mask->hdr.dst_addr)) { input_set |= ICE_INSET_DMAC; ice_memcpy(&filter->input.ext_data.dst_mac, - ð_spec->dst, + ð_spec->hdr.dst_addr, RTE_ETHER_ADDR_LEN, ICE_NONDMA_TO_NONDMA); ice_memcpy(&filter->input.ext_mask.dst_mac, - ð_mask->dst, + ð_mask->hdr.dst_addr, RTE_ETHER_ADDR_LEN, ICE_NONDMA_TO_NONDMA); } diff --git a/drivers/net/ice/ice_fdir_filter.c b/drivers/net/ice/ice_fdir_filter.c index 7914ba9407..5d297afc29 100644 --- a/drivers/net/ice/ice_fdir_filter.c +++ b/drivers/net/ice/ice_fdir_filter.c @@ -1971,17 +1971,17 @@ ice_fdir_parse_pattern(__rte_unused struct ice_adapter *ad, if (!(eth_spec && eth_mask)) break; - if (!rte_is_zero_ether_addr(ð_mask->dst)) + if (!rte_is_zero_ether_addr(ð_mask->hdr.dst_addr)) *input_set |= ICE_INSET_DMAC; - if (!rte_is_zero_ether_addr(ð_mask->src)) + if (!rte_is_zero_ether_addr(ð_mask->hdr.src_addr)) *input_set |= ICE_INSET_SMAC; next_type = (item + 1)->type; /* Ignore this field except for ICE_FLTR_PTYPE_NON_IP_L2 */ - if (eth_mask->type == RTE_BE16(0xffff) && + if (eth_mask->hdr.ether_type == RTE_BE16(0xffff) && next_type == RTE_FLOW_ITEM_TYPE_END) { *input_set |= ICE_INSET_ETHERTYPE; - ether_type = rte_be_to_cpu_16(eth_spec->type); + ether_type = rte_be_to_cpu_16(eth_spec->hdr.ether_type); if (ether_type == RTE_ETHER_TYPE_IPV4 || ether_type == RTE_ETHER_TYPE_IPV6) { @@ -1997,11 +1997,11 @@ ice_fdir_parse_pattern(__rte_unused struct ice_adapter *ad, &filter->input.ext_data_outer : &filter->input.ext_data; rte_memcpy(&p_ext_data->src_mac, - ð_spec->src, RTE_ETHER_ADDR_LEN); + ð_spec->hdr.src_addr, RTE_ETHER_ADDR_LEN); rte_memcpy(&p_ext_data->dst_mac, - ð_spec->dst, RTE_ETHER_ADDR_LEN); + ð_spec->hdr.dst_addr, RTE_ETHER_ADDR_LEN); rte_memcpy(&p_ext_data->ether_type, - ð_spec->type, sizeof(eth_spec->type)); + ð_spec->hdr.ether_type, sizeof(eth_spec->hdr.ether_type)); break; case RTE_FLOW_ITEM_TYPE_IPV4: flow_type = ICE_FLTR_PTYPE_NONF_IPV4_OTHER; diff --git a/drivers/net/ice/ice_switch_filter.c b/drivers/net/ice/ice_switch_filter.c index 60f7934a16..d84061340e 100644 --- a/drivers/net/ice/ice_switch_filter.c +++ b/drivers/net/ice/ice_switch_filter.c @@ -592,8 +592,8 @@ ice_switch_parse_pattern(const struct rte_flow_item pattern[], eth_spec = item->spec; eth_mask = item->mask; if (eth_spec && eth_mask) { - const uint8_t *a = eth_mask->src.addr_bytes; - const uint8_t *b = eth_mask->dst.addr_bytes; + const uint8_t *a = eth_mask->hdr.src_addr.addr_bytes; + const uint8_t *b = eth_mask->hdr.dst_addr.addr_bytes; if (tunnel_valid) input = &inner_input_set; else @@ -610,7 +610,7 @@ ice_switch_parse_pattern(const struct rte_flow_item pattern[], break; } } - if (eth_mask->type) + if (eth_mask->hdr.ether_type) *input |= ICE_INSET_ETHERTYPE; list[t].type = (tunnel_valid == 0) ? ICE_MAC_OFOS : ICE_MAC_IL; @@ -620,31 +620,31 @@ ice_switch_parse_pattern(const struct rte_flow_item pattern[], h = &list[t].h_u.eth_hdr; m = &list[t].m_u.eth_hdr; for (j = 0; j < RTE_ETHER_ADDR_LEN; j++) { - if (eth_mask->src.addr_bytes[j]) { + if (eth_mask->hdr.src_addr.addr_bytes[j]) { h->src_addr[j] = - eth_spec->src.addr_bytes[j]; + eth_spec->hdr.src_addr.addr_bytes[j]; m->src_addr[j] = - eth_mask->src.addr_bytes[j]; + eth_mask->hdr.src_addr.addr_bytes[j]; i = 1; input_set_byte++; } - if (eth_mask->dst.addr_bytes[j]) { + if (eth_mask->hdr.dst_addr.addr_bytes[j]) { h->dst_addr[j] = - eth_spec->dst.addr_bytes[j]; + eth_spec->hdr.dst_addr.addr_bytes[j]; m->dst_addr[j] = - eth_mask->dst.addr_bytes[j]; + eth_mask->hdr.dst_addr.addr_bytes[j]; i = 1; input_set_byte++; } } if (i) t++; - if (eth_mask->type) { + if (eth_mask->hdr.ether_type) { list[t].type = ICE_ETYPE_OL; list[t].h_u.ethertype.ethtype_id = - eth_spec->type; + eth_spec->hdr.ether_type; list[t].m_u.ethertype.ethtype_id = - eth_mask->type; + eth_mask->hdr.ether_type; input_set_byte += 2; t++; } @@ -1087,14 +1087,14 @@ ice_switch_parse_pattern(const struct rte_flow_item pattern[], *input |= ICE_INSET_VLAN_INNER; } - if (vlan_mask->tci) { + if (vlan_mask->hdr.vlan_tci) { list[t].h_u.vlan_hdr.vlan = - vlan_spec->tci; + vlan_spec->hdr.vlan_tci; list[t].m_u.vlan_hdr.vlan = - vlan_mask->tci; + vlan_mask->hdr.vlan_tci; input_set_byte += 2; } - if (vlan_mask->inner_type) { + if (vlan_mask->hdr.eth_proto) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, @@ -1879,7 +1879,7 @@ ice_switch_parse_pattern_action(struct ice_adapter *ad, eth_mask = item->mask; else continue; - if (eth_mask->type == UINT16_MAX) + if (eth_mask->hdr.ether_type == UINT16_MAX) tun_type = ICE_SW_TUN_AND_NON_TUN; } diff --git a/drivers/net/igc/igc_flow.c b/drivers/net/igc/igc_flow.c index 58a6a8a539..b677a0d613 100644 --- a/drivers/net/igc/igc_flow.c +++ b/drivers/net/igc/igc_flow.c @@ -327,14 +327,14 @@ igc_parse_pattern_ether(const struct rte_flow_item *item, IGC_SET_FILTER_MASK(filter, IGC_FILTER_MASK_ETHER); /* destination and source MAC address are not supported */ - if (!rte_is_zero_ether_addr(&mask->src) || - !rte_is_zero_ether_addr(&mask->dst)) + if (!rte_is_zero_ether_addr(&mask->hdr.src_addr) || + !rte_is_zero_ether_addr(&mask->hdr.dst_addr)) return rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM_MASK, item, "Only support ether-type"); /* ether-type mask bits must be all 1 */ - if (IGC_NOT_ALL_BITS_SET(mask->type)) + if (IGC_NOT_ALL_BITS_SET(mask->hdr.ether_type)) return rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM_MASK, item, "Ethernet type mask bits must be all 1"); @@ -342,7 +342,7 @@ igc_parse_pattern_ether(const struct rte_flow_item *item, ether = &filter->ethertype; /* get ether-type */ - ether->ether_type = rte_be_to_cpu_16(spec->type); + ether->ether_type = rte_be_to_cpu_16(spec->hdr.ether_type); /* ether-type should not be IPv4 and IPv6 */ if (ether->ether_type == RTE_ETHER_TYPE_IPV4 || diff --git a/drivers/net/ipn3ke/ipn3ke_flow.c b/drivers/net/ipn3ke/ipn3ke_flow.c index 5b57ee9341..ee56d0f43d 100644 --- a/drivers/net/ipn3ke/ipn3ke_flow.c +++ b/drivers/net/ipn3ke/ipn3ke_flow.c @@ -101,7 +101,7 @@ ipn3ke_pattern_vxlan(const struct rte_flow_item patterns[], eth = item->spec; rte_memcpy(&parser->key[0], - eth->src.addr_bytes, + eth->hdr.src_addr.addr_bytes, RTE_ETHER_ADDR_LEN); break; @@ -165,7 +165,7 @@ ipn3ke_pattern_mac(const struct rte_flow_item patterns[], eth = item->spec; rte_memcpy(parser->key, - eth->src.addr_bytes, + eth->hdr.src_addr.addr_bytes, RTE_ETHER_ADDR_LEN); break; @@ -227,13 +227,13 @@ ipn3ke_pattern_qinq(const struct rte_flow_item patterns[], if (!outer_vlan) { outer_vlan = item->spec; - tci = rte_be_to_cpu_16(outer_vlan->tci); + tci = rte_be_to_cpu_16(outer_vlan->hdr.vlan_tci); parser->key[0] = (tci & 0xff0) >> 4; parser->key[1] |= (tci & 0x00f) << 4; } else { inner_vlan = item->spec; - tci = rte_be_to_cpu_16(inner_vlan->tci); + tci = rte_be_to_cpu_16(inner_vlan->hdr.vlan_tci); parser->key[1] |= (tci & 0xf00) >> 8; parser->key[2] = (tci & 0x0ff); } diff --git a/drivers/net/ixgbe/ixgbe_flow.c b/drivers/net/ixgbe/ixgbe_flow.c index 1250c2dc12..6bcd4f7126 100644 --- a/drivers/net/ixgbe/ixgbe_flow.c +++ b/drivers/net/ixgbe/ixgbe_flow.c @@ -744,16 +744,16 @@ cons_parse_ethertype_filter(const struct rte_flow_attr *attr, * Mask bits of destination MAC address must be full * of 1 or full of 0. */ - if (!rte_is_zero_ether_addr(ð_mask->src) || - (!rte_is_zero_ether_addr(ð_mask->dst) && - !rte_is_broadcast_ether_addr(ð_mask->dst))) { + if (!rte_is_zero_ether_addr(ð_mask->hdr.src_addr) || + (!rte_is_zero_ether_addr(ð_mask->hdr.dst_addr) && + !rte_is_broadcast_ether_addr(ð_mask->hdr.dst_addr))) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, "Invalid ether address mask"); return -rte_errno; } - if ((eth_mask->type & UINT16_MAX) != UINT16_MAX) { + if ((eth_mask->hdr.ether_type & UINT16_MAX) != UINT16_MAX) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, "Invalid ethertype mask"); @@ -763,13 +763,13 @@ cons_parse_ethertype_filter(const struct rte_flow_attr *attr, /* If mask bits of destination MAC address * are full of 1, set RTE_ETHTYPE_FLAGS_MAC. */ - if (rte_is_broadcast_ether_addr(ð_mask->dst)) { - filter->mac_addr = eth_spec->dst; + if (rte_is_broadcast_ether_addr(ð_mask->hdr.dst_addr)) { + filter->mac_addr = eth_spec->hdr.dst_addr; filter->flags |= RTE_ETHTYPE_FLAGS_MAC; } else { filter->flags &= ~RTE_ETHTYPE_FLAGS_MAC; } - filter->ether_type = rte_be_to_cpu_16(eth_spec->type); + filter->ether_type = rte_be_to_cpu_16(eth_spec->hdr.ether_type); /* Check if the next non-void item is END. */ item = next_no_void_pattern(pattern, item); @@ -1698,7 +1698,7 @@ ixgbe_parse_fdir_filter_normal(struct rte_eth_dev *dev, /* Get the dst MAC. */ for (j = 0; j < RTE_ETHER_ADDR_LEN; j++) { rule->ixgbe_fdir.formatted.inner_mac[j] = - eth_spec->dst.addr_bytes[j]; + eth_spec->hdr.dst_addr.addr_bytes[j]; } } @@ -1709,7 +1709,7 @@ ixgbe_parse_fdir_filter_normal(struct rte_eth_dev *dev, eth_mask = item->mask; /* Ether type should be masked. */ - if (eth_mask->type || + if (eth_mask->hdr.ether_type || rule->mode == RTE_FDIR_MODE_SIGNATURE) { memset(rule, 0, sizeof(struct ixgbe_fdir_rule)); rte_flow_error_set(error, EINVAL, @@ -1726,8 +1726,8 @@ ixgbe_parse_fdir_filter_normal(struct rte_eth_dev *dev, * and don't support dst MAC address mask. */ for (j = 0; j < RTE_ETHER_ADDR_LEN; j++) { - if (eth_mask->src.addr_bytes[j] || - eth_mask->dst.addr_bytes[j] != 0xFF) { + if (eth_mask->hdr.src_addr.addr_bytes[j] || + eth_mask->hdr.dst_addr.addr_bytes[j] != 0xFF) { memset(rule, 0, sizeof(struct ixgbe_fdir_rule)); rte_flow_error_set(error, EINVAL, @@ -1790,9 +1790,9 @@ ixgbe_parse_fdir_filter_normal(struct rte_eth_dev *dev, vlan_spec = item->spec; vlan_mask = item->mask; - rule->ixgbe_fdir.formatted.vlan_id = vlan_spec->tci; + rule->ixgbe_fdir.formatted.vlan_id = vlan_spec->hdr.vlan_tci; - rule->mask.vlan_tci_mask = vlan_mask->tci; + rule->mask.vlan_tci_mask = vlan_mask->hdr.vlan_tci; rule->mask.vlan_tci_mask &= rte_cpu_to_be_16(0xEFFF); /* More than one tags are not supported. */ @@ -2642,7 +2642,7 @@ ixgbe_parse_fdir_filter_tunnel(const struct rte_flow_attr *attr, eth_mask = item->mask; /* Ether type should be masked. */ - if (eth_mask->type) { + if (eth_mask->hdr.ether_type) { memset(rule, 0, sizeof(struct ixgbe_fdir_rule)); rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, @@ -2652,7 +2652,7 @@ ixgbe_parse_fdir_filter_tunnel(const struct rte_flow_attr *attr, /* src MAC address should be masked. */ for (j = 0; j < RTE_ETHER_ADDR_LEN; j++) { - if (eth_mask->src.addr_bytes[j]) { + if (eth_mask->hdr.src_addr.addr_bytes[j]) { memset(rule, 0, sizeof(struct ixgbe_fdir_rule)); rte_flow_error_set(error, EINVAL, @@ -2664,9 +2664,9 @@ ixgbe_parse_fdir_filter_tunnel(const struct rte_flow_attr *attr, rule->mask.mac_addr_byte_mask = 0; for (j = 0; j < RTE_ETHER_ADDR_LEN; j++) { /* It's a per byte mask. */ - if (eth_mask->dst.addr_bytes[j] == 0xFF) { + if (eth_mask->hdr.dst_addr.addr_bytes[j] == 0xFF) { rule->mask.mac_addr_byte_mask |= 0x1 << j; - } else if (eth_mask->dst.addr_bytes[j]) { + } else if (eth_mask->hdr.dst_addr.addr_bytes[j]) { memset(rule, 0, sizeof(struct ixgbe_fdir_rule)); rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, @@ -2685,7 +2685,7 @@ ixgbe_parse_fdir_filter_tunnel(const struct rte_flow_attr *attr, /* Get the dst MAC. */ for (j = 0; j < RTE_ETHER_ADDR_LEN; j++) { rule->ixgbe_fdir.formatted.inner_mac[j] = - eth_spec->dst.addr_bytes[j]; + eth_spec->hdr.dst_addr.addr_bytes[j]; } } @@ -2722,9 +2722,9 @@ ixgbe_parse_fdir_filter_tunnel(const struct rte_flow_attr *attr, vlan_spec = item->spec; vlan_mask = item->mask; - rule->ixgbe_fdir.formatted.vlan_id = vlan_spec->tci; + rule->ixgbe_fdir.formatted.vlan_id = vlan_spec->hdr.vlan_tci; - rule->mask.vlan_tci_mask = vlan_mask->tci; + rule->mask.vlan_tci_mask = vlan_mask->hdr.vlan_tci; rule->mask.vlan_tci_mask &= rte_cpu_to_be_16(0xEFFF); /* More than one tags are not supported. */ diff --git a/drivers/net/mlx4/mlx4_flow.c b/drivers/net/mlx4/mlx4_flow.c index 9d7247cf81..8ef9fd2db4 100644 --- a/drivers/net/mlx4/mlx4_flow.c +++ b/drivers/net/mlx4/mlx4_flow.c @@ -207,17 +207,17 @@ mlx4_flow_merge_eth(struct rte_flow *flow, uint32_t sum_dst = 0; uint32_t sum_src = 0; - for (i = 0; i != sizeof(mask->dst.addr_bytes); ++i) { - sum_dst += mask->dst.addr_bytes[i]; - sum_src += mask->src.addr_bytes[i]; + for (i = 0; i != sizeof(mask->hdr.dst_addr.addr_bytes); ++i) { + sum_dst += mask->hdr.dst_addr.addr_bytes[i]; + sum_src += mask->hdr.src_addr.addr_bytes[i]; } if (sum_src) { msg = "mlx4 does not support source MAC matching"; goto error; } else if (!sum_dst) { flow->promisc = 1; - } else if (sum_dst == 1 && mask->dst.addr_bytes[0] == 1) { - if (!(spec->dst.addr_bytes[0] & 1)) { + } else if (sum_dst == 1 && mask->hdr.dst_addr.addr_bytes[0] == 1) { + if (!(spec->hdr.dst_addr.addr_bytes[0] & 1)) { msg = "mlx4 does not support the explicit" " exclusion of all multicast traffic"; goto error; @@ -251,8 +251,8 @@ mlx4_flow_merge_eth(struct rte_flow *flow, flow->promisc = 1; return 0; } - memcpy(eth->val.dst_mac, spec->dst.addr_bytes, RTE_ETHER_ADDR_LEN); - memcpy(eth->mask.dst_mac, mask->dst.addr_bytes, RTE_ETHER_ADDR_LEN); + memcpy(eth->val.dst_mac, spec->hdr.dst_addr.addr_bytes, RTE_ETHER_ADDR_LEN); + memcpy(eth->mask.dst_mac, mask->hdr.dst_addr.addr_bytes, RTE_ETHER_ADDR_LEN); /* Remove unwanted bits from values. */ for (i = 0; i < RTE_ETHER_ADDR_LEN; ++i) eth->val.dst_mac[i] &= eth->mask.dst_mac[i]; @@ -297,12 +297,12 @@ mlx4_flow_merge_vlan(struct rte_flow *flow, struct ibv_flow_spec_eth *eth; const char *msg; - if (!mask || !mask->tci) { + if (!mask || !mask->hdr.vlan_tci) { msg = "mlx4 cannot match all VLAN traffic while excluding" " non-VLAN traffic, TCI VID must be specified"; goto error; } - if (mask->tci != RTE_BE16(0x0fff)) { + if (mask->hdr.vlan_tci != RTE_BE16(0x0fff)) { msg = "mlx4 does not support partial TCI VID matching"; goto error; } @@ -310,8 +310,8 @@ mlx4_flow_merge_vlan(struct rte_flow *flow, return 0; eth = (void *)((uintptr_t)flow->ibv_attr + flow->ibv_attr_size - sizeof(*eth)); - eth->val.vlan_tag = spec->tci; - eth->mask.vlan_tag = mask->tci; + eth->val.vlan_tag = spec->hdr.vlan_tci; + eth->mask.vlan_tag = mask->hdr.vlan_tci; eth->val.vlan_tag &= eth->mask.vlan_tag; if (flow->ibv_attr->type == IBV_FLOW_ATTR_ALL_DEFAULT) flow->ibv_attr->type = IBV_FLOW_ATTR_NORMAL; @@ -582,7 +582,7 @@ static const struct mlx4_flow_proc_item mlx4_flow_proc_item_list[] = { RTE_FLOW_ITEM_TYPE_IPV4), .mask_support = &(const struct rte_flow_item_eth){ /* Only destination MAC can be matched. */ - .dst.addr_bytes = "\xff\xff\xff\xff\xff\xff", + .hdr.dst_addr.addr_bytes = "\xff\xff\xff\xff\xff\xff", }, .mask_default = &rte_flow_item_eth_mask, .mask_sz = sizeof(struct rte_flow_item_eth), @@ -593,7 +593,7 @@ static const struct mlx4_flow_proc_item mlx4_flow_proc_item_list[] = { .next_item = NEXT_ITEM(RTE_FLOW_ITEM_TYPE_IPV4), .mask_support = &(const struct rte_flow_item_vlan){ /* Only TCI VID matching is supported. */ - .tci = RTE_BE16(0x0fff), + .hdr.vlan_tci = RTE_BE16(0x0fff), }, .mask_default = &rte_flow_item_vlan_mask, .mask_sz = sizeof(struct rte_flow_item_vlan), @@ -1304,14 +1304,14 @@ mlx4_flow_internal(struct mlx4_priv *priv, struct rte_flow_error *error) }; struct rte_flow_item_eth eth_spec; const struct rte_flow_item_eth eth_mask = { - .dst.addr_bytes = "\xff\xff\xff\xff\xff\xff", + .hdr.dst_addr.addr_bytes = "\xff\xff\xff\xff\xff\xff", }; const struct rte_flow_item_eth eth_allmulti = { - .dst.addr_bytes = "\x01\x00\x00\x00\x00\x00", + .hdr.dst_addr.addr_bytes = "\x01\x00\x00\x00\x00\x00", }; struct rte_flow_item_vlan vlan_spec; const struct rte_flow_item_vlan vlan_mask = { - .tci = RTE_BE16(0x0fff), + .hdr.vlan_tci = RTE_BE16(0x0fff), }; struct rte_flow_item pattern[] = { { @@ -1356,12 +1356,12 @@ mlx4_flow_internal(struct mlx4_priv *priv, struct rte_flow_error *error) .type = RTE_FLOW_ACTION_TYPE_END, }, }; - struct rte_ether_addr *rule_mac = ð_spec.dst; + struct rte_ether_addr *rule_mac = ð_spec.hdr.dst_addr; rte_be16_t *rule_vlan = (ETH_DEV(priv)->data->dev_conf.rxmode.offloads & RTE_ETH_RX_OFFLOAD_VLAN_FILTER) && !ETH_DEV(priv)->data->promiscuous ? - &vlan_spec.tci : + &vlan_spec.hdr.vlan_tci : NULL; uint16_t vlan = 0; struct rte_flow *flow; @@ -1399,7 +1399,7 @@ mlx4_flow_internal(struct mlx4_priv *priv, struct rte_flow_error *error) if (i < RTE_DIM(priv->mac)) mac = &priv->mac[i]; else - mac = ð_mask.dst; + mac = ð_mask.hdr.dst_addr; if (rte_is_zero_ether_addr(mac)) continue; /* Check if MAC flow rule is already present. */ diff --git a/drivers/net/mlx5/mlx5_flow.c b/drivers/net/mlx5/mlx5_flow.c index e4744b0a67..0f88fa41d9 100644 --- a/drivers/net/mlx5/mlx5_flow.c +++ b/drivers/net/mlx5/mlx5_flow.c @@ -276,13 +276,13 @@ mlx5_flow_expand_rss_item_complete(const struct rte_flow_item *item) return RTE_FLOW_ITEM_TYPE_VOID; switch (item->type) { case RTE_FLOW_ITEM_TYPE_ETH: - MLX5_XSET_ITEM_MASK_SPEC(eth, type); + MLX5_XSET_ITEM_MASK_SPEC(eth, hdr.ether_type); if (!mask) return RTE_FLOW_ITEM_TYPE_VOID; ret = mlx5_ethertype_to_item_type(spec, mask, false); break; case RTE_FLOW_ITEM_TYPE_VLAN: - MLX5_XSET_ITEM_MASK_SPEC(vlan, inner_type); + MLX5_XSET_ITEM_MASK_SPEC(vlan, hdr.eth_proto); if (!mask) return RTE_FLOW_ITEM_TYPE_VOID; ret = mlx5_ethertype_to_item_type(spec, mask, false); @@ -2328,9 +2328,9 @@ mlx5_flow_validate_item_eth(const struct rte_flow_item *item, { const struct rte_flow_item_eth *mask = item->mask; const struct rte_flow_item_eth nic_mask = { - .dst.addr_bytes = "\xff\xff\xff\xff\xff\xff", - .src.addr_bytes = "\xff\xff\xff\xff\xff\xff", - .type = RTE_BE16(0xffff), + .hdr.dst_addr.addr_bytes = "\xff\xff\xff\xff\xff\xff", + .hdr.src_addr.addr_bytes = "\xff\xff\xff\xff\xff\xff", + .hdr.ether_type = RTE_BE16(0xffff), .has_vlan = ext_vlan_sup ? 1 : 0, }; int ret; @@ -2390,8 +2390,8 @@ mlx5_flow_validate_item_vlan(const struct rte_flow_item *item, const struct rte_flow_item_vlan *spec = item->spec; const struct rte_flow_item_vlan *mask = item->mask; const struct rte_flow_item_vlan nic_mask = { - .tci = RTE_BE16(UINT16_MAX), - .inner_type = RTE_BE16(UINT16_MAX), + .hdr.vlan_tci = RTE_BE16(UINT16_MAX), + .hdr.eth_proto = RTE_BE16(UINT16_MAX), }; uint16_t vlan_tag = 0; const int tunnel = !!(item_flags & MLX5_FLOW_LAYER_TUNNEL); @@ -2419,7 +2419,7 @@ mlx5_flow_validate_item_vlan(const struct rte_flow_item *item, MLX5_ITEM_RANGE_NOT_ACCEPTED, error); if (ret) return ret; - if (!tunnel && mask->tci != RTE_BE16(0x0fff)) { + if (!tunnel && mask->hdr.vlan_tci != RTE_BE16(0x0fff)) { struct mlx5_priv *priv = dev->data->dev_private; if (priv->vmwa_context) { @@ -2439,8 +2439,8 @@ mlx5_flow_validate_item_vlan(const struct rte_flow_item *item, } } if (spec) { - vlan_tag = spec->tci; - vlan_tag &= mask->tci; + vlan_tag = spec->hdr.vlan_tci; + vlan_tag &= mask->hdr.vlan_tci; } /* * From verbs perspective an empty VLAN is equivalent @@ -7669,10 +7669,10 @@ mlx5_flow_lacp_miss(struct rte_eth_dev *dev) * a multicast dst mac causes kernel to give low priority to this flow. */ static const struct rte_flow_item_eth lacp_spec = { - .type = RTE_BE16(0x8809), + .hdr.ether_type = RTE_BE16(0x8809), }; static const struct rte_flow_item_eth lacp_mask = { - .type = 0xffff, + .hdr.ether_type = 0xffff, }; const struct rte_flow_attr attr = { .ingress = 1, diff --git a/drivers/net/mlx5/mlx5_flow_dv.c b/drivers/net/mlx5/mlx5_flow_dv.c index 91f287af5c..4987631e79 100644 --- a/drivers/net/mlx5/mlx5_flow_dv.c +++ b/drivers/net/mlx5/mlx5_flow_dv.c @@ -644,17 +644,17 @@ flow_dv_convert_action_modify_mac memset(ð, 0, sizeof(eth)); memset(ð_mask, 0, sizeof(eth_mask)); if (action->type == RTE_FLOW_ACTION_TYPE_SET_MAC_SRC) { - memcpy(ð.src.addr_bytes, &conf->mac_addr, - sizeof(eth.src.addr_bytes)); - memcpy(ð_mask.src.addr_bytes, - &rte_flow_item_eth_mask.src.addr_bytes, - sizeof(eth_mask.src.addr_bytes)); + memcpy(ð.hdr.src_addr.addr_bytes, &conf->mac_addr, + sizeof(eth.hdr.src_addr.addr_bytes)); + memcpy(ð_mask.hdr.src_addr.addr_bytes, + &rte_flow_item_eth_mask.hdr.src_addr.addr_bytes, + sizeof(eth_mask.hdr.src_addr.addr_bytes)); } else { - memcpy(ð.dst.addr_bytes, &conf->mac_addr, - sizeof(eth.dst.addr_bytes)); - memcpy(ð_mask.dst.addr_bytes, - &rte_flow_item_eth_mask.dst.addr_bytes, - sizeof(eth_mask.dst.addr_bytes)); + memcpy(ð.hdr.dst_addr.addr_bytes, &conf->mac_addr, + sizeof(eth.hdr.dst_addr.addr_bytes)); + memcpy(ð_mask.hdr.dst_addr.addr_bytes, + &rte_flow_item_eth_mask.hdr.dst_addr.addr_bytes, + sizeof(eth_mask.hdr.dst_addr.addr_bytes)); } item.spec = ð item.mask = ð_mask; @@ -2303,8 +2303,8 @@ flow_dv_validate_item_vlan(const struct rte_flow_item *item, { const struct rte_flow_item_vlan *mask = item->mask; const struct rte_flow_item_vlan nic_mask = { - .tci = RTE_BE16(UINT16_MAX), - .inner_type = RTE_BE16(UINT16_MAX), + .hdr.vlan_tci = RTE_BE16(UINT16_MAX), + .hdr.eth_proto = RTE_BE16(UINT16_MAX), .has_more_vlan = 1, }; const int tunnel = !!(item_flags & MLX5_FLOW_LAYER_TUNNEL); @@ -2332,7 +2332,7 @@ flow_dv_validate_item_vlan(const struct rte_flow_item *item, MLX5_ITEM_RANGE_NOT_ACCEPTED, error); if (ret) return ret; - if (!tunnel && mask->tci != RTE_BE16(0x0fff)) { + if (!tunnel && mask->hdr.vlan_tci != RTE_BE16(0x0fff)) { struct mlx5_priv *priv = dev->data->dev_private; if (priv->vmwa_context) { @@ -2871,9 +2871,9 @@ flow_dev_get_vlan_info_from_items(const struct rte_flow_item *items, struct rte_vlan_hdr *vlan) { const struct rte_flow_item_vlan nic_mask = { - .tci = RTE_BE16(MLX5DV_FLOW_VLAN_PCP_MASK | + .hdr.vlan_tci = RTE_BE16(MLX5DV_FLOW_VLAN_PCP_MASK | MLX5DV_FLOW_VLAN_VID_MASK), - .inner_type = RTE_BE16(0xffff), + .hdr.eth_proto = RTE_BE16(0xffff), }; if (items == NULL) @@ -2895,23 +2895,23 @@ flow_dev_get_vlan_info_from_items(const struct rte_flow_item *items, if (!vlan_m) vlan_m = &nic_mask; /* Only full match values are accepted */ - if ((vlan_m->tci & MLX5DV_FLOW_VLAN_PCP_MASK_BE) == + if ((vlan_m->hdr.vlan_tci & MLX5DV_FLOW_VLAN_PCP_MASK_BE) == MLX5DV_FLOW_VLAN_PCP_MASK_BE) { vlan->vlan_tci &= ~MLX5DV_FLOW_VLAN_PCP_MASK; vlan->vlan_tci |= - rte_be_to_cpu_16(vlan_v->tci & + rte_be_to_cpu_16(vlan_v->hdr.vlan_tci & MLX5DV_FLOW_VLAN_PCP_MASK_BE); } - if ((vlan_m->tci & MLX5DV_FLOW_VLAN_VID_MASK_BE) == + if ((vlan_m->hdr.vlan_tci & MLX5DV_FLOW_VLAN_VID_MASK_BE) == MLX5DV_FLOW_VLAN_VID_MASK_BE) { vlan->vlan_tci &= ~MLX5DV_FLOW_VLAN_VID_MASK; vlan->vlan_tci |= - rte_be_to_cpu_16(vlan_v->tci & + rte_be_to_cpu_16(vlan_v->hdr.vlan_tci & MLX5DV_FLOW_VLAN_VID_MASK_BE); } - if (vlan_m->inner_type == nic_mask.inner_type) - vlan->eth_proto = rte_be_to_cpu_16(vlan_v->inner_type & - vlan_m->inner_type); + if (vlan_m->hdr.eth_proto == nic_mask.hdr.eth_proto) + vlan->eth_proto = rte_be_to_cpu_16(vlan_v->hdr.eth_proto & + vlan_m->hdr.eth_proto); } } @@ -2961,8 +2961,8 @@ flow_dv_validate_action_push_vlan(struct rte_eth_dev *dev, "push vlan action for VF representor " "not supported on NIC table"); if (vlan_m && - (vlan_m->tci & MLX5DV_FLOW_VLAN_PCP_MASK_BE) && - (vlan_m->tci & MLX5DV_FLOW_VLAN_PCP_MASK_BE) != + (vlan_m->hdr.vlan_tci & MLX5DV_FLOW_VLAN_PCP_MASK_BE) && + (vlan_m->hdr.vlan_tci & MLX5DV_FLOW_VLAN_PCP_MASK_BE) != MLX5DV_FLOW_VLAN_PCP_MASK_BE && !(action_flags & MLX5_FLOW_ACTION_OF_SET_VLAN_PCP) && !(mlx5_flow_find_action @@ -2974,8 +2974,8 @@ flow_dv_validate_action_push_vlan(struct rte_eth_dev *dev, "push VLAN action cannot figure out " "PCP value"); if (vlan_m && - (vlan_m->tci & MLX5DV_FLOW_VLAN_VID_MASK_BE) && - (vlan_m->tci & MLX5DV_FLOW_VLAN_VID_MASK_BE) != + (vlan_m->hdr.vlan_tci & MLX5DV_FLOW_VLAN_VID_MASK_BE) && + (vlan_m->hdr.vlan_tci & MLX5DV_FLOW_VLAN_VID_MASK_BE) != MLX5DV_FLOW_VLAN_VID_MASK_BE && !(action_flags & MLX5_FLOW_ACTION_OF_SET_VLAN_VID) && !(mlx5_flow_find_action @@ -7076,10 +7076,10 @@ flow_dv_validate(struct rte_eth_dev *dev, const struct rte_flow_attr *attr, if (items->mask != NULL && items->spec != NULL) { ether_type = ((const struct rte_flow_item_eth *) - items->spec)->type; + items->spec)->hdr.ether_type; ether_type &= ((const struct rte_flow_item_eth *) - items->mask)->type; + items->mask)->hdr.ether_type; ether_type = rte_be_to_cpu_16(ether_type); } else { ether_type = 0; @@ -7095,10 +7095,10 @@ flow_dv_validate(struct rte_eth_dev *dev, const struct rte_flow_attr *attr, if (items->mask != NULL && items->spec != NULL) { ether_type = ((const struct rte_flow_item_vlan *) - items->spec)->inner_type; + items->spec)->hdr.eth_proto; ether_type &= ((const struct rte_flow_item_vlan *) - items->mask)->inner_type; + items->mask)->hdr.eth_proto; ether_type = rte_be_to_cpu_16(ether_type); } else { ether_type = 0; @@ -8356,9 +8356,9 @@ flow_dv_translate_item_eth(void *matcher, void *key, const struct rte_flow_item_eth *eth_m = item->mask; const struct rte_flow_item_eth *eth_v = item->spec; const struct rte_flow_item_eth nic_mask = { - .dst.addr_bytes = "\xff\xff\xff\xff\xff\xff", - .src.addr_bytes = "\xff\xff\xff\xff\xff\xff", - .type = RTE_BE16(0xffff), + .hdr.dst_addr.addr_bytes = "\xff\xff\xff\xff\xff\xff", + .hdr.src_addr.addr_bytes = "\xff\xff\xff\xff\xff\xff", + .hdr.ether_type = RTE_BE16(0xffff), .has_vlan = 0, }; void *hdrs_m; @@ -8380,17 +8380,17 @@ flow_dv_translate_item_eth(void *matcher, void *key, hdrs_v = MLX5_ADDR_OF(fte_match_param, key, outer_headers); } memcpy(MLX5_ADDR_OF(fte_match_set_lyr_2_4, hdrs_m, dmac_47_16), - ð_m->dst, sizeof(eth_m->dst)); + ð_m->hdr.dst_addr, sizeof(eth_m->hdr.dst_addr)); /* The value must be in the range of the mask. */ l24_v = MLX5_ADDR_OF(fte_match_set_lyr_2_4, hdrs_v, dmac_47_16); - for (i = 0; i < sizeof(eth_m->dst); ++i) - l24_v[i] = eth_m->dst.addr_bytes[i] & eth_v->dst.addr_bytes[i]; + for (i = 0; i < sizeof(eth_m->hdr.dst_addr); ++i) + l24_v[i] = eth_m->hdr.dst_addr.addr_bytes[i] & eth_v->hdr.dst_addr.addr_bytes[i]; memcpy(MLX5_ADDR_OF(fte_match_set_lyr_2_4, hdrs_m, smac_47_16), - ð_m->src, sizeof(eth_m->src)); + ð_m->hdr.src_addr, sizeof(eth_m->hdr.src_addr)); l24_v = MLX5_ADDR_OF(fte_match_set_lyr_2_4, hdrs_v, smac_47_16); /* The value must be in the range of the mask. */ - for (i = 0; i < sizeof(eth_m->dst); ++i) - l24_v[i] = eth_m->src.addr_bytes[i] & eth_v->src.addr_bytes[i]; + for (i = 0; i < sizeof(eth_m->hdr.dst_addr); ++i) + l24_v[i] = eth_m->hdr.src_addr.addr_bytes[i] & eth_v->hdr.src_addr.addr_bytes[i]; /* * HW supports match on one Ethertype, the Ethertype following the last * VLAN tag of the packet (see PRM). @@ -8399,10 +8399,10 @@ flow_dv_translate_item_eth(void *matcher, void *key, * ethertype, and use ip_version field instead. * eCPRI over Ether layer will use type value 0xAEFE. */ - if (eth_m->type == 0xFFFF) { + if (eth_m->hdr.ether_type == 0xFFFF) { /* Set cvlan_tag mask for any single\multi\un-tagged case. */ MLX5_SET(fte_match_set_lyr_2_4, hdrs_m, cvlan_tag, 1); - switch (eth_v->type) { + switch (eth_v->hdr.ether_type) { case RTE_BE16(RTE_ETHER_TYPE_VLAN): MLX5_SET(fte_match_set_lyr_2_4, hdrs_v, cvlan_tag, 1); return; @@ -8432,9 +8432,9 @@ flow_dv_translate_item_eth(void *matcher, void *key, } } MLX5_SET(fte_match_set_lyr_2_4, hdrs_m, ethertype, - rte_be_to_cpu_16(eth_m->type)); + rte_be_to_cpu_16(eth_m->hdr.ether_type)); l24_v = MLX5_ADDR_OF(fte_match_set_lyr_2_4, hdrs_v, ethertype); - *(uint16_t *)(l24_v) = eth_m->type & eth_v->type; + *(uint16_t *)(l24_v) = eth_m->hdr.ether_type & eth_v->hdr.ether_type; } /** @@ -8478,7 +8478,7 @@ flow_dv_translate_item_vlan(struct mlx5_flow *dev_flow, */ if (vlan_v) dev_flow->handle->vf_vlan.tag = - rte_be_to_cpu_16(vlan_v->tci) & 0x0fff; + rte_be_to_cpu_16(vlan_v->hdr.vlan_tci) & 0x0fff; } /* * When VLAN item exists in flow, mark packet as tagged, @@ -8492,8 +8492,8 @@ flow_dv_translate_item_vlan(struct mlx5_flow *dev_flow, return; if (!vlan_m) vlan_m = &rte_flow_item_vlan_mask; - tci_m = rte_be_to_cpu_16(vlan_m->tci); - tci_v = rte_be_to_cpu_16(vlan_m->tci & vlan_v->tci); + tci_m = rte_be_to_cpu_16(vlan_m->hdr.vlan_tci); + tci_v = rte_be_to_cpu_16(vlan_m->hdr.vlan_tci & vlan_v->hdr.vlan_tci); MLX5_SET(fte_match_set_lyr_2_4, hdrs_m, first_vid, tci_m); MLX5_SET(fte_match_set_lyr_2_4, hdrs_v, first_vid, tci_v); MLX5_SET(fte_match_set_lyr_2_4, hdrs_m, first_cfi, tci_m >> 12); @@ -8504,8 +8504,8 @@ flow_dv_translate_item_vlan(struct mlx5_flow *dev_flow, * HW is optimized for IPv4/IPv6. In such cases, avoid setting * ethertype, and use ip_version field instead. */ - if (vlan_m->inner_type == 0xFFFF) { - switch (vlan_v->inner_type) { + if (vlan_m->hdr.eth_proto == 0xFFFF) { + switch (vlan_v->hdr.eth_proto) { case RTE_BE16(RTE_ETHER_TYPE_VLAN): MLX5_SET(fte_match_set_lyr_2_4, hdrs_m, svlan_tag, 1); MLX5_SET(fte_match_set_lyr_2_4, hdrs_v, svlan_tag, 1); @@ -8529,9 +8529,9 @@ flow_dv_translate_item_vlan(struct mlx5_flow *dev_flow, return; } MLX5_SET(fte_match_set_lyr_2_4, hdrs_m, ethertype, - rte_be_to_cpu_16(vlan_m->inner_type)); + rte_be_to_cpu_16(vlan_m->hdr.eth_proto)); MLX5_SET(fte_match_set_lyr_2_4, hdrs_v, ethertype, - rte_be_to_cpu_16(vlan_m->inner_type & vlan_v->inner_type)); + rte_be_to_cpu_16(vlan_m->hdr.eth_proto & vlan_v->hdr.eth_proto)); } /** diff --git a/drivers/net/mlx5/mlx5_flow_verbs.c b/drivers/net/mlx5/mlx5_flow_verbs.c index fd902078f8..a8b84a2119 100644 --- a/drivers/net/mlx5/mlx5_flow_verbs.c +++ b/drivers/net/mlx5/mlx5_flow_verbs.c @@ -430,16 +430,16 @@ flow_verbs_translate_item_eth(struct mlx5_flow *dev_flow, if (spec) { unsigned int i; - memcpy(ð.val.dst_mac, spec->dst.addr_bytes, + memcpy(ð.val.dst_mac, spec->hdr.dst_addr.addr_bytes, RTE_ETHER_ADDR_LEN); - memcpy(ð.val.src_mac, spec->src.addr_bytes, + memcpy(ð.val.src_mac, spec->hdr.src_addr.addr_bytes, RTE_ETHER_ADDR_LEN); - eth.val.ether_type = spec->type; - memcpy(ð.mask.dst_mac, mask->dst.addr_bytes, + eth.val.ether_type = spec->hdr.ether_type; + memcpy(ð.mask.dst_mac, mask->hdr.dst_addr.addr_bytes, RTE_ETHER_ADDR_LEN); - memcpy(ð.mask.src_mac, mask->src.addr_bytes, + memcpy(ð.mask.src_mac, mask->hdr.src_addr.addr_bytes, RTE_ETHER_ADDR_LEN); - eth.mask.ether_type = mask->type; + eth.mask.ether_type = mask->hdr.ether_type; /* Remove unwanted bits from values. */ for (i = 0; i < RTE_ETHER_ADDR_LEN; ++i) { eth.val.dst_mac[i] &= eth.mask.dst_mac[i]; @@ -515,11 +515,11 @@ flow_verbs_translate_item_vlan(struct mlx5_flow *dev_flow, if (!mask) mask = &rte_flow_item_vlan_mask; if (spec) { - eth.val.vlan_tag = spec->tci; - eth.mask.vlan_tag = mask->tci; + eth.val.vlan_tag = spec->hdr.vlan_tci; + eth.mask.vlan_tag = mask->hdr.vlan_tci; eth.val.vlan_tag &= eth.mask.vlan_tag; - eth.val.ether_type = spec->inner_type; - eth.mask.ether_type = mask->inner_type; + eth.val.ether_type = spec->hdr.eth_proto; + eth.mask.ether_type = mask->hdr.eth_proto; eth.val.ether_type &= eth.mask.ether_type; } if (!(item_flags & l2m)) @@ -528,7 +528,7 @@ flow_verbs_translate_item_vlan(struct mlx5_flow *dev_flow, flow_verbs_item_vlan_update(&dev_flow->verbs.attr, ð); if (!tunnel) dev_flow->handle->vf_vlan.tag = - rte_be_to_cpu_16(spec->tci) & 0x0fff; + rte_be_to_cpu_16(spec->hdr.vlan_tci) & 0x0fff; } /** @@ -1268,10 +1268,10 @@ flow_verbs_validate(struct rte_eth_dev *dev, if (items->mask != NULL && items->spec != NULL) { ether_type = ((const struct rte_flow_item_eth *) - items->spec)->type; + items->spec)->hdr.ether_type; ether_type &= ((const struct rte_flow_item_eth *) - items->mask)->type; + items->mask)->hdr.ether_type; if (ether_type == RTE_BE16(RTE_ETHER_TYPE_VLAN)) is_empty_vlan = true; ether_type = rte_be_to_cpu_16(ether_type); @@ -1291,10 +1291,10 @@ flow_verbs_validate(struct rte_eth_dev *dev, if (items->mask != NULL && items->spec != NULL) { ether_type = ((const struct rte_flow_item_vlan *) - items->spec)->inner_type; + items->spec)->hdr.eth_proto; ether_type &= ((const struct rte_flow_item_vlan *) - items->mask)->inner_type; + items->mask)->hdr.eth_proto; ether_type = rte_be_to_cpu_16(ether_type); } else { ether_type = 0; diff --git a/drivers/net/mlx5/mlx5_trigger.c b/drivers/net/mlx5/mlx5_trigger.c index c68b32cf14..be35fc3db2 100644 --- a/drivers/net/mlx5/mlx5_trigger.c +++ b/drivers/net/mlx5/mlx5_trigger.c @@ -1294,19 +1294,19 @@ mlx5_traffic_enable(struct rte_eth_dev *dev) { struct mlx5_priv *priv = dev->data->dev_private; struct rte_flow_item_eth bcast = { - .dst.addr_bytes = "\xff\xff\xff\xff\xff\xff", + .hdr.dst_addr.addr_bytes = "\xff\xff\xff\xff\xff\xff", }; struct rte_flow_item_eth ipv6_multi_spec = { - .dst.addr_bytes = "\x33\x33\x00\x00\x00\x00", + .hdr.dst_addr.addr_bytes = "\x33\x33\x00\x00\x00\x00", }; struct rte_flow_item_eth ipv6_multi_mask = { - .dst.addr_bytes = "\xff\xff\x00\x00\x00\x00", + .hdr.dst_addr.addr_bytes = "\xff\xff\x00\x00\x00\x00", }; struct rte_flow_item_eth unicast = { - .src.addr_bytes = "\x00\x00\x00\x00\x00\x00", + .hdr.src_addr.addr_bytes = "\x00\x00\x00\x00\x00\x00", }; struct rte_flow_item_eth unicast_mask = { - .dst.addr_bytes = "\xff\xff\xff\xff\xff\xff", + .hdr.dst_addr.addr_bytes = "\xff\xff\xff\xff\xff\xff", }; const unsigned int vlan_filter_n = priv->vlan_filter_n; const struct rte_ether_addr cmp = { @@ -1367,9 +1367,9 @@ mlx5_traffic_enable(struct rte_eth_dev *dev) return 0; if (dev->data->promiscuous) { struct rte_flow_item_eth promisc = { - .dst.addr_bytes = "\x00\x00\x00\x00\x00\x00", - .src.addr_bytes = "\x00\x00\x00\x00\x00\x00", - .type = 0, + .hdr.dst_addr.addr_bytes = "\x00\x00\x00\x00\x00\x00", + .hdr.src_addr.addr_bytes = "\x00\x00\x00\x00\x00\x00", + .hdr.ether_type = 0, }; ret = mlx5_ctrl_flow(dev, &promisc, &promisc); @@ -1378,9 +1378,9 @@ mlx5_traffic_enable(struct rte_eth_dev *dev) } if (dev->data->all_multicast) { struct rte_flow_item_eth multicast = { - .dst.addr_bytes = "\x01\x00\x00\x00\x00\x00", - .src.addr_bytes = "\x00\x00\x00\x00\x00\x00", - .type = 0, + .hdr.dst_addr.addr_bytes = "\x01\x00\x00\x00\x00\x00", + .hdr.src_addr.addr_bytes = "\x00\x00\x00\x00\x00\x00", + .hdr.ether_type = 0, }; ret = mlx5_ctrl_flow(dev, &multicast, &multicast); @@ -1392,7 +1392,7 @@ mlx5_traffic_enable(struct rte_eth_dev *dev) uint16_t vlan = priv->vlan_filter[i]; struct rte_flow_item_vlan vlan_spec = { - .tci = rte_cpu_to_be_16(vlan), + .hdr.vlan_tci = rte_cpu_to_be_16(vlan), }; struct rte_flow_item_vlan vlan_mask = rte_flow_item_vlan_mask; @@ -1427,14 +1427,14 @@ mlx5_traffic_enable(struct rte_eth_dev *dev) if (!memcmp(mac, &cmp, sizeof(*mac))) continue; - memcpy(&unicast.dst.addr_bytes, + memcpy(&unicast.hdr.dst_addr.addr_bytes, mac->addr_bytes, RTE_ETHER_ADDR_LEN); for (j = 0; j != vlan_filter_n; ++j) { uint16_t vlan = priv->vlan_filter[j]; struct rte_flow_item_vlan vlan_spec = { - .tci = rte_cpu_to_be_16(vlan), + .hdr.vlan_tci = rte_cpu_to_be_16(vlan), }; struct rte_flow_item_vlan vlan_mask = rte_flow_item_vlan_mask; diff --git a/drivers/net/mvpp2/mrvl_flow.c b/drivers/net/mvpp2/mrvl_flow.c index 99695b91c4..e74a5f83f5 100644 --- a/drivers/net/mvpp2/mrvl_flow.c +++ b/drivers/net/mvpp2/mrvl_flow.c @@ -189,14 +189,14 @@ mrvl_parse_mac(const struct rte_flow_item_eth *spec, const uint8_t *k, *m; if (parse_dst) { - k = spec->dst.addr_bytes; - m = mask->dst.addr_bytes; + k = spec->hdr.dst_addr.addr_bytes; + m = mask->hdr.dst_addr.addr_bytes; flow->table_key.proto_field[flow->rule.num_fields].field.eth = MV_NET_ETH_F_DA; } else { - k = spec->src.addr_bytes; - m = mask->src.addr_bytes; + k = spec->hdr.src_addr.addr_bytes; + m = mask->hdr.src_addr.addr_bytes; flow->table_key.proto_field[flow->rule.num_fields].field.eth = MV_NET_ETH_F_SA; @@ -275,7 +275,7 @@ mrvl_parse_type(const struct rte_flow_item_eth *spec, mrvl_alloc_key_mask(key_field); key_field->size = 2; - k = rte_be_to_cpu_16(spec->type); + k = rte_be_to_cpu_16(spec->hdr.ether_type); snprintf((char *)key_field->key, MRVL_CLS_STR_SIZE_MAX, "%u", k); flow->table_key.proto_field[flow->rule.num_fields].proto = @@ -311,7 +311,7 @@ mrvl_parse_vlan_id(const struct rte_flow_item_vlan *spec, mrvl_alloc_key_mask(key_field); key_field->size = 2; - k = rte_be_to_cpu_16(spec->tci) & MRVL_VLAN_ID_MASK; + k = rte_be_to_cpu_16(spec->hdr.vlan_tci) & MRVL_VLAN_ID_MASK; snprintf((char *)key_field->key, MRVL_CLS_STR_SIZE_MAX, "%u", k); flow->table_key.proto_field[flow->rule.num_fields].proto = @@ -347,7 +347,7 @@ mrvl_parse_vlan_pri(const struct rte_flow_item_vlan *spec, mrvl_alloc_key_mask(key_field); key_field->size = 1; - k = (rte_be_to_cpu_16(spec->tci) & MRVL_VLAN_PRI_MASK) >> 13; + k = (rte_be_to_cpu_16(spec->hdr.vlan_tci) & MRVL_VLAN_PRI_MASK) >> 13; snprintf((char *)key_field->key, MRVL_CLS_STR_SIZE_MAX, "%u", k); flow->table_key.proto_field[flow->rule.num_fields].proto = @@ -856,19 +856,19 @@ mrvl_parse_eth(const struct rte_flow_item *item, struct rte_flow *flow, memset(&zero, 0, sizeof(zero)); - if (memcmp(&mask->dst, &zero, sizeof(mask->dst))) { + if (memcmp(&mask->hdr.dst_addr, &zero, sizeof(mask->hdr.dst_addr))) { ret = mrvl_parse_dmac(spec, mask, flow); if (ret) goto out; } - if (memcmp(&mask->src, &zero, sizeof(mask->src))) { + if (memcmp(&mask->hdr.src_addr, &zero, sizeof(mask->hdr.src_addr))) { ret = mrvl_parse_smac(spec, mask, flow); if (ret) goto out; } - if (mask->type) { + if (mask->hdr.ether_type) { MRVL_LOG(WARNING, "eth type mask is ignored"); ret = mrvl_parse_type(spec, mask, flow); if (ret) @@ -905,7 +905,7 @@ mrvl_parse_vlan(const struct rte_flow_item *item, if (ret) return ret; - m = rte_be_to_cpu_16(mask->tci); + m = rte_be_to_cpu_16(mask->hdr.vlan_tci); if (m & MRVL_VLAN_ID_MASK) { MRVL_LOG(WARNING, "vlan id mask is ignored"); ret = mrvl_parse_vlan_id(spec, mask, flow); @@ -920,12 +920,12 @@ mrvl_parse_vlan(const struct rte_flow_item *item, goto out; } - if (mask->inner_type) { + if (mask->hdr.eth_proto) { struct rte_flow_item_eth spec_eth = { - .type = spec->inner_type, + .hdr.ether_type = spec->hdr.eth_proto, }; struct rte_flow_item_eth mask_eth = { - .type = mask->inner_type, + .hdr.ether_type = mask->hdr.eth_proto, }; /* TPID is not supported so if ETH_TYPE was selected, diff --git a/drivers/net/sfc/sfc_flow.c b/drivers/net/sfc/sfc_flow.c index fb59abd0b5..f098edc6eb 100644 --- a/drivers/net/sfc/sfc_flow.c +++ b/drivers/net/sfc/sfc_flow.c @@ -280,12 +280,12 @@ sfc_flow_parse_eth(const struct rte_flow_item *item, const struct rte_flow_item_eth *spec = NULL; const struct rte_flow_item_eth *mask = NULL; const struct rte_flow_item_eth supp_mask = { - .dst.addr_bytes = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }, - .src.addr_bytes = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }, - .type = 0xffff, + .hdr.dst_addr.addr_bytes = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }, + .hdr.src_addr.addr_bytes = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }, + .hdr.ether_type = 0xffff, }; const struct rte_flow_item_eth ifrm_supp_mask = { - .dst.addr_bytes = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }, + .hdr.dst_addr.addr_bytes = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }, }; const uint8_t ig_mask[EFX_MAC_ADDR_LEN] = { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 @@ -319,15 +319,15 @@ sfc_flow_parse_eth(const struct rte_flow_item *item, if (spec == NULL) return 0; - if (rte_is_same_ether_addr(&mask->dst, &supp_mask.dst)) { + if (rte_is_same_ether_addr(&mask->hdr.dst_addr, &supp_mask.hdr.dst_addr)) { efx_spec->efs_match_flags |= is_ifrm ? EFX_FILTER_MATCH_IFRM_LOC_MAC : EFX_FILTER_MATCH_LOC_MAC; - rte_memcpy(loc_mac, spec->dst.addr_bytes, + rte_memcpy(loc_mac, spec->hdr.dst_addr.addr_bytes, EFX_MAC_ADDR_LEN); - } else if (memcmp(mask->dst.addr_bytes, ig_mask, + } else if (memcmp(mask->hdr.dst_addr.addr_bytes, ig_mask, EFX_MAC_ADDR_LEN) == 0) { - if (rte_is_unicast_ether_addr(&spec->dst)) + if (rte_is_unicast_ether_addr(&spec->hdr.dst_addr)) efx_spec->efs_match_flags |= is_ifrm ? EFX_FILTER_MATCH_IFRM_UNKNOWN_UCAST_DST : EFX_FILTER_MATCH_UNKNOWN_UCAST_DST; @@ -335,7 +335,7 @@ sfc_flow_parse_eth(const struct rte_flow_item *item, efx_spec->efs_match_flags |= is_ifrm ? EFX_FILTER_MATCH_IFRM_UNKNOWN_MCAST_DST : EFX_FILTER_MATCH_UNKNOWN_MCAST_DST; - } else if (!rte_is_zero_ether_addr(&mask->dst)) { + } else if (!rte_is_zero_ether_addr(&mask->hdr.dst_addr)) { goto fail_bad_mask; } @@ -344,11 +344,11 @@ sfc_flow_parse_eth(const struct rte_flow_item *item, * ethertype masks are equal to zero in inner frame, * so these fields are filled in only for the outer frame */ - if (rte_is_same_ether_addr(&mask->src, &supp_mask.src)) { + if (rte_is_same_ether_addr(&mask->hdr.src_addr, &supp_mask.hdr.src_addr)) { efx_spec->efs_match_flags |= EFX_FILTER_MATCH_REM_MAC; - rte_memcpy(efx_spec->efs_rem_mac, spec->src.addr_bytes, + rte_memcpy(efx_spec->efs_rem_mac, spec->hdr.src_addr.addr_bytes, EFX_MAC_ADDR_LEN); - } else if (!rte_is_zero_ether_addr(&mask->src)) { + } else if (!rte_is_zero_ether_addr(&mask->hdr.src_addr)) { goto fail_bad_mask; } @@ -356,10 +356,10 @@ sfc_flow_parse_eth(const struct rte_flow_item *item, * Ether type is in big-endian byte order in item and * in little-endian in efx_spec, so byte swap is used */ - if (mask->type == supp_mask.type) { + if (mask->hdr.ether_type == supp_mask.hdr.ether_type) { efx_spec->efs_match_flags |= EFX_FILTER_MATCH_ETHER_TYPE; - efx_spec->efs_ether_type = rte_bswap16(spec->type); - } else if (mask->type != 0) { + efx_spec->efs_ether_type = rte_bswap16(spec->hdr.ether_type); + } else if (mask->hdr.ether_type != 0) { goto fail_bad_mask; } @@ -394,8 +394,8 @@ sfc_flow_parse_vlan(const struct rte_flow_item *item, const struct rte_flow_item_vlan *spec = NULL; const struct rte_flow_item_vlan *mask = NULL; const struct rte_flow_item_vlan supp_mask = { - .tci = rte_cpu_to_be_16(RTE_ETH_VLAN_ID_MAX), - .inner_type = RTE_BE16(0xffff), + .hdr.vlan_tci = rte_cpu_to_be_16(RTE_ETH_VLAN_ID_MAX), + .hdr.eth_proto = RTE_BE16(0xffff), }; rc = sfc_flow_parse_init(item, @@ -414,9 +414,9 @@ sfc_flow_parse_vlan(const struct rte_flow_item *item, * If two VLAN items are included, the first matches * the outer tag and the next matches the inner tag. */ - if (mask->tci == supp_mask.tci) { + if (mask->hdr.vlan_tci == supp_mask.hdr.vlan_tci) { /* Apply mask to keep VID only */ - vid = rte_bswap16(spec->tci & mask->tci); + vid = rte_bswap16(spec->hdr.vlan_tci & mask->hdr.vlan_tci); if (!(efx_spec->efs_match_flags & EFX_FILTER_MATCH_OUTER_VID)) { @@ -445,13 +445,13 @@ sfc_flow_parse_vlan(const struct rte_flow_item *item, "VLAN TPID matching is not supported"); return -rte_errno; } - if (mask->inner_type == supp_mask.inner_type) { + if (mask->hdr.eth_proto == supp_mask.hdr.eth_proto) { efx_spec->efs_match_flags |= EFX_FILTER_MATCH_ETHER_TYPE; - efx_spec->efs_ether_type = rte_bswap16(spec->inner_type); - } else if (mask->inner_type) { + efx_spec->efs_ether_type = rte_bswap16(spec->hdr.eth_proto); + } else if (mask->hdr.eth_proto) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, - "Bad mask for VLAN inner_type"); + "Bad mask for VLAN inner type"); return -rte_errno; } diff --git a/drivers/net/sfc/sfc_mae.c b/drivers/net/sfc/sfc_mae.c index 421bb6da95..710d04be13 100644 --- a/drivers/net/sfc/sfc_mae.c +++ b/drivers/net/sfc/sfc_mae.c @@ -1701,18 +1701,18 @@ static const struct sfc_mae_field_locator flocs_eth[] = { * The field is handled by sfc_mae_rule_process_pattern_data(). */ SFC_MAE_FIELD_HANDLING_DEFERRED, - RTE_SIZEOF_FIELD(struct rte_flow_item_eth, type), - offsetof(struct rte_flow_item_eth, type), + RTE_SIZEOF_FIELD(struct rte_flow_item_eth, hdr.ether_type), + offsetof(struct rte_flow_item_eth, hdr.ether_type), }, { EFX_MAE_FIELD_ETH_DADDR_BE, - RTE_SIZEOF_FIELD(struct rte_flow_item_eth, dst), - offsetof(struct rte_flow_item_eth, dst), + RTE_SIZEOF_FIELD(struct rte_flow_item_eth, hdr.dst_addr), + offsetof(struct rte_flow_item_eth, hdr.dst_addr), }, { EFX_MAE_FIELD_ETH_SADDR_BE, - RTE_SIZEOF_FIELD(struct rte_flow_item_eth, src), - offsetof(struct rte_flow_item_eth, src), + RTE_SIZEOF_FIELD(struct rte_flow_item_eth, hdr.src_addr), + offsetof(struct rte_flow_item_eth, hdr.src_addr), }, }; @@ -1770,8 +1770,8 @@ sfc_mae_rule_parse_item_eth(const struct rte_flow_item *item, * sfc_mae_rule_process_pattern_data() will consider them * altogether when the rest of the items have been parsed. */ - ethertypes[0].value = item_spec->type; - ethertypes[0].mask = item_mask->type; + ethertypes[0].value = item_spec->hdr.ether_type; + ethertypes[0].mask = item_mask->hdr.ether_type; if (item_mask->has_vlan) { pdata->has_ovlan_mask = B_TRUE; if (item_spec->has_vlan) @@ -1794,8 +1794,8 @@ static const struct sfc_mae_field_locator flocs_vlan[] = { /* Outermost tag */ { EFX_MAE_FIELD_VLAN0_TCI_BE, - RTE_SIZEOF_FIELD(struct rte_flow_item_vlan, tci), - offsetof(struct rte_flow_item_vlan, tci), + RTE_SIZEOF_FIELD(struct rte_flow_item_vlan, hdr.vlan_tci), + offsetof(struct rte_flow_item_vlan, hdr.vlan_tci), }, { /* @@ -1803,15 +1803,15 @@ static const struct sfc_mae_field_locator flocs_vlan[] = { * The field is handled by sfc_mae_rule_process_pattern_data(). */ SFC_MAE_FIELD_HANDLING_DEFERRED, - RTE_SIZEOF_FIELD(struct rte_flow_item_vlan, inner_type), - offsetof(struct rte_flow_item_vlan, inner_type), + RTE_SIZEOF_FIELD(struct rte_flow_item_vlan, hdr.eth_proto), + offsetof(struct rte_flow_item_vlan, hdr.eth_proto), }, /* Innermost tag */ { EFX_MAE_FIELD_VLAN1_TCI_BE, - RTE_SIZEOF_FIELD(struct rte_flow_item_vlan, tci), - offsetof(struct rte_flow_item_vlan, tci), + RTE_SIZEOF_FIELD(struct rte_flow_item_vlan, hdr.vlan_tci), + offsetof(struct rte_flow_item_vlan, hdr.vlan_tci), }, { /* @@ -1819,8 +1819,8 @@ static const struct sfc_mae_field_locator flocs_vlan[] = { * The field is handled by sfc_mae_rule_process_pattern_data(). */ SFC_MAE_FIELD_HANDLING_DEFERRED, - RTE_SIZEOF_FIELD(struct rte_flow_item_vlan, inner_type), - offsetof(struct rte_flow_item_vlan, inner_type), + RTE_SIZEOF_FIELD(struct rte_flow_item_vlan, hdr.eth_proto), + offsetof(struct rte_flow_item_vlan, hdr.eth_proto), }, }; @@ -1899,9 +1899,9 @@ sfc_mae_rule_parse_item_vlan(const struct rte_flow_item *item, * sfc_mae_rule_process_pattern_data() will consider them * altogether when the rest of the items have been parsed. */ - et[pdata->nb_vlan_tags + 1].value = item_spec->inner_type; - et[pdata->nb_vlan_tags + 1].mask = item_mask->inner_type; - pdata->tci_masks[pdata->nb_vlan_tags] = item_mask->tci; + et[pdata->nb_vlan_tags + 1].value = item_spec->hdr.eth_proto; + et[pdata->nb_vlan_tags + 1].mask = item_mask->hdr.eth_proto; + pdata->tci_masks[pdata->nb_vlan_tags] = item_mask->hdr.vlan_tci; if (item_mask->has_more_vlan) { if (pdata->nb_vlan_tags == SFC_MAE_MATCH_VLAN_MAX_NTAGS) { diff --git a/drivers/net/tap/tap_flow.c b/drivers/net/tap/tap_flow.c index efe66fe059..ed4d42f92f 100644 --- a/drivers/net/tap/tap_flow.c +++ b/drivers/net/tap/tap_flow.c @@ -258,9 +258,9 @@ static const struct tap_flow_items tap_flow_items[] = { RTE_FLOW_ITEM_TYPE_IPV4, RTE_FLOW_ITEM_TYPE_IPV6), .mask = &(const struct rte_flow_item_eth){ - .dst.addr_bytes = "\xff\xff\xff\xff\xff\xff", - .src.addr_bytes = "\xff\xff\xff\xff\xff\xff", - .type = -1, + .hdr.dst_addr.addr_bytes = "\xff\xff\xff\xff\xff\xff", + .hdr.src_addr.addr_bytes = "\xff\xff\xff\xff\xff\xff", + .hdr.ether_type = -1, }, .mask_sz = sizeof(struct rte_flow_item_eth), .default_mask = &rte_flow_item_eth_mask, @@ -272,11 +272,11 @@ static const struct tap_flow_items tap_flow_items[] = { .mask = &(const struct rte_flow_item_vlan){ /* DEI matching is not supported */ #if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN - .tci = 0xffef, + .hdr.vlan_tci = 0xffef, #else - .tci = 0xefff, + .hdr.vlan_tci = 0xefff, #endif - .inner_type = -1, + .hdr.eth_proto = -1, }, .mask_sz = sizeof(struct rte_flow_item_vlan), .default_mask = &rte_flow_item_vlan_mask, @@ -391,7 +391,7 @@ static struct remote_rule implicit_rte_flows[TAP_REMOTE_MAX_IDX] = { .items[0] = { .type = RTE_FLOW_ITEM_TYPE_ETH, .mask = &(const struct rte_flow_item_eth){ - .dst.addr_bytes = "\xff\xff\xff\xff\xff\xff", + .hdr.dst_addr.addr_bytes = "\xff\xff\xff\xff\xff\xff", }, }, .items[1] = { @@ -408,10 +408,10 @@ static struct remote_rule implicit_rte_flows[TAP_REMOTE_MAX_IDX] = { .items[0] = { .type = RTE_FLOW_ITEM_TYPE_ETH, .mask = &(const struct rte_flow_item_eth){ - .dst.addr_bytes = "\xff\xff\xff\xff\xff\xff", + .hdr.dst_addr.addr_bytes = "\xff\xff\xff\xff\xff\xff", }, .spec = &(const struct rte_flow_item_eth){ - .dst.addr_bytes = "\xff\xff\xff\xff\xff\xff", + .hdr.dst_addr.addr_bytes = "\xff\xff\xff\xff\xff\xff", }, }, .items[1] = { @@ -428,10 +428,10 @@ static struct remote_rule implicit_rte_flows[TAP_REMOTE_MAX_IDX] = { .items[0] = { .type = RTE_FLOW_ITEM_TYPE_ETH, .mask = &(const struct rte_flow_item_eth){ - .dst.addr_bytes = "\x33\x33\x00\x00\x00\x00", + .hdr.dst_addr.addr_bytes = "\x33\x33\x00\x00\x00\x00", }, .spec = &(const struct rte_flow_item_eth){ - .dst.addr_bytes = "\x33\x33\x00\x00\x00\x00", + .hdr.dst_addr.addr_bytes = "\x33\x33\x00\x00\x00\x00", }, }, .items[1] = { @@ -462,10 +462,10 @@ static struct remote_rule implicit_rte_flows[TAP_REMOTE_MAX_IDX] = { .items[0] = { .type = RTE_FLOW_ITEM_TYPE_ETH, .mask = &(const struct rte_flow_item_eth){ - .dst.addr_bytes = "\x01\x00\x00\x00\x00\x00", + .hdr.dst_addr.addr_bytes = "\x01\x00\x00\x00\x00\x00", }, .spec = &(const struct rte_flow_item_eth){ - .dst.addr_bytes = "\x01\x00\x00\x00\x00\x00", + .hdr.dst_addr.addr_bytes = "\x01\x00\x00\x00\x00\x00", }, }, .items[1] = { @@ -527,31 +527,31 @@ tap_flow_create_eth(const struct rte_flow_item *item, void *data) if (!mask) mask = tap_flow_items[RTE_FLOW_ITEM_TYPE_ETH].default_mask; /* TC does not support eth_type masking. Only accept if exact match. */ - if (mask->type && mask->type != 0xffff) + if (mask->hdr.ether_type && mask->hdr.ether_type != 0xffff) return -1; if (!spec) return 0; /* store eth_type for consistency if ipv4/6 pattern item comes next */ - if (spec->type & mask->type) - info->eth_type = spec->type; + if (spec->hdr.ether_type & mask->hdr.ether_type) + info->eth_type = spec->hdr.ether_type; if (!flow) return 0; msg = &flow->msg; - if (!rte_is_zero_ether_addr(&mask->dst)) { + if (!rte_is_zero_ether_addr(&mask->hdr.dst_addr)) { tap_nlattr_add(&msg->nh, TCA_FLOWER_KEY_ETH_DST, RTE_ETHER_ADDR_LEN, - &spec->dst.addr_bytes); + &spec->hdr.dst_addr.addr_bytes); tap_nlattr_add(&msg->nh, TCA_FLOWER_KEY_ETH_DST_MASK, RTE_ETHER_ADDR_LEN, - &mask->dst.addr_bytes); + &mask->hdr.dst_addr.addr_bytes); } - if (!rte_is_zero_ether_addr(&mask->src)) { + if (!rte_is_zero_ether_addr(&mask->hdr.src_addr)) { tap_nlattr_add(&msg->nh, TCA_FLOWER_KEY_ETH_SRC, RTE_ETHER_ADDR_LEN, - &spec->src.addr_bytes); + &spec->hdr.src_addr.addr_bytes); tap_nlattr_add(&msg->nh, TCA_FLOWER_KEY_ETH_SRC_MASK, RTE_ETHER_ADDR_LEN, - &mask->src.addr_bytes); + &mask->hdr.src_addr.addr_bytes); } return 0; } @@ -587,11 +587,11 @@ tap_flow_create_vlan(const struct rte_flow_item *item, void *data) if (info->vlan) return -1; info->vlan = 1; - if (mask->inner_type) { + if (mask->hdr.eth_proto) { /* TC does not support partial eth_type masking */ - if (mask->inner_type != RTE_BE16(0xffff)) + if (mask->hdr.eth_proto != RTE_BE16(0xffff)) return -1; - info->eth_type = spec->inner_type; + info->eth_type = spec->hdr.eth_proto; } if (!flow) return 0; @@ -601,8 +601,8 @@ tap_flow_create_vlan(const struct rte_flow_item *item, void *data) #define VLAN_ID(tci) ((tci) & 0xfff) if (!spec) return 0; - if (spec->tci) { - uint16_t tci = ntohs(spec->tci) & mask->tci; + if (spec->hdr.vlan_tci) { + uint16_t tci = ntohs(spec->hdr.vlan_tci) & mask->hdr.vlan_tci; uint16_t prio = VLAN_PRIO(tci); uint8_t vid = VLAN_ID(tci); @@ -1681,7 +1681,7 @@ int tap_flow_implicit_create(struct pmd_internals *pmd, }; struct rte_flow_item *items = implicit_rte_flows[idx].items; struct rte_flow_attr *attr = &implicit_rte_flows[idx].attr; - struct rte_flow_item_eth eth_local = { .type = 0 }; + struct rte_flow_item_eth eth_local = { .hdr.ether_type = 0 }; unsigned int if_index = pmd->remote_if_index; struct rte_flow *remote_flow = NULL; struct nlmsg *msg = NULL; @@ -1718,7 +1718,7 @@ int tap_flow_implicit_create(struct pmd_internals *pmd, * eth addr couldn't be set in implicit_rte_flows[] as it is not * known at compile time. */ - memcpy(ð_local.dst, &pmd->eth_addr, sizeof(pmd->eth_addr)); + memcpy(ð_local.hdr.dst_addr, &pmd->eth_addr, sizeof(pmd->eth_addr)); items = items_local; } tc_init_msg(msg, if_index, RTM_NEWTFILTER, flags); diff --git a/drivers/net/txgbe/txgbe_flow.c b/drivers/net/txgbe/txgbe_flow.c index 7b18dca7e8..7ef52d0b0f 100644 --- a/drivers/net/txgbe/txgbe_flow.c +++ b/drivers/net/txgbe/txgbe_flow.c @@ -706,16 +706,16 @@ cons_parse_ethertype_filter(const struct rte_flow_attr *attr, * Mask bits of destination MAC address must be full * of 1 or full of 0. */ - if (!rte_is_zero_ether_addr(ð_mask->src) || - (!rte_is_zero_ether_addr(ð_mask->dst) && - !rte_is_broadcast_ether_addr(ð_mask->dst))) { + if (!rte_is_zero_ether_addr(ð_mask->hdr.src_addr) || + (!rte_is_zero_ether_addr(ð_mask->hdr.dst_addr) && + !rte_is_broadcast_ether_addr(ð_mask->hdr.dst_addr))) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, "Invalid ether address mask"); return -rte_errno; } - if ((eth_mask->type & UINT16_MAX) != UINT16_MAX) { + if ((eth_mask->hdr.ether_type & UINT16_MAX) != UINT16_MAX) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, "Invalid ethertype mask"); @@ -725,13 +725,13 @@ cons_parse_ethertype_filter(const struct rte_flow_attr *attr, /* If mask bits of destination MAC address * are full of 1, set RTE_ETHTYPE_FLAGS_MAC. */ - if (rte_is_broadcast_ether_addr(ð_mask->dst)) { - filter->mac_addr = eth_spec->dst; + if (rte_is_broadcast_ether_addr(ð_mask->hdr.dst_addr)) { + filter->mac_addr = eth_spec->hdr.dst_addr; filter->flags |= RTE_ETHTYPE_FLAGS_MAC; } else { filter->flags &= ~RTE_ETHTYPE_FLAGS_MAC; } - filter->ether_type = rte_be_to_cpu_16(eth_spec->type); + filter->ether_type = rte_be_to_cpu_16(eth_spec->hdr.ether_type); /* Check if the next non-void item is END. */ item = next_no_void_pattern(pattern, item); @@ -1635,7 +1635,7 @@ txgbe_parse_fdir_filter_normal(struct rte_eth_dev *dev __rte_unused, eth_mask = item->mask; /* Ether type should be masked. */ - if (eth_mask->type || + if (eth_mask->hdr.ether_type || rule->mode == RTE_FDIR_MODE_SIGNATURE) { memset(rule, 0, sizeof(struct txgbe_fdir_rule)); rte_flow_error_set(error, EINVAL, @@ -1652,8 +1652,8 @@ txgbe_parse_fdir_filter_normal(struct rte_eth_dev *dev __rte_unused, * and don't support dst MAC address mask. */ for (j = 0; j < RTE_ETHER_ADDR_LEN; j++) { - if (eth_mask->src.addr_bytes[j] || - eth_mask->dst.addr_bytes[j] != 0xFF) { + if (eth_mask->hdr.src_addr.addr_bytes[j] || + eth_mask->hdr.dst_addr.addr_bytes[j] != 0xFF) { memset(rule, 0, sizeof(struct txgbe_fdir_rule)); rte_flow_error_set(error, EINVAL, @@ -2381,7 +2381,7 @@ txgbe_parse_fdir_filter_tunnel(const struct rte_flow_attr *attr, eth_mask = item->mask; /* Ether type should be masked. */ - if (eth_mask->type) { + if (eth_mask->hdr.ether_type) { memset(rule, 0, sizeof(struct txgbe_fdir_rule)); rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, @@ -2391,7 +2391,7 @@ txgbe_parse_fdir_filter_tunnel(const struct rte_flow_attr *attr, /* src MAC address should be masked. */ for (j = 0; j < RTE_ETHER_ADDR_LEN; j++) { - if (eth_mask->src.addr_bytes[j]) { + if (eth_mask->hdr.src_addr.addr_bytes[j]) { memset(rule, 0, sizeof(struct txgbe_fdir_rule)); rte_flow_error_set(error, EINVAL, @@ -2403,9 +2403,9 @@ txgbe_parse_fdir_filter_tunnel(const struct rte_flow_attr *attr, rule->mask.mac_addr_byte_mask = 0; for (j = 0; j < ETH_ADDR_LEN; j++) { /* It's a per byte mask. */ - if (eth_mask->dst.addr_bytes[j] == 0xFF) { + if (eth_mask->hdr.dst_addr.addr_bytes[j] == 0xFF) { rule->mask.mac_addr_byte_mask |= 0x1 << j; - } else if (eth_mask->dst.addr_bytes[j]) { + } else if (eth_mask->hdr.dst_addr.addr_bytes[j]) { memset(rule, 0, sizeof(struct txgbe_fdir_rule)); rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, From patchwork Tue Oct 25 21:44:04 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Thomas Monjalon X-Patchwork-Id: 119119 X-Patchwork-Delegate: ferruh.yigit@amd.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 42D70A0544; Tue, 25 Oct 2022 23:44:58 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 063E942C63; Tue, 25 Oct 2022 23:44:52 +0200 (CEST) Received: from out3-smtp.messagingengine.com (out3-smtp.messagingengine.com [66.111.4.27]) by mails.dpdk.org (Postfix) with ESMTP id AD97342C51 for ; Tue, 25 Oct 2022 23:44:49 +0200 (CEST) Received: from compute5.internal (compute5.nyi.internal [10.202.2.45]) by mailout.nyi.internal (Postfix) with ESMTP id 6CDC95C00BD; Tue, 25 Oct 2022 17:44:49 -0400 (EDT) Received: from mailfrontend1 ([10.202.2.162]) by compute5.internal (MEProxy); Tue, 25 Oct 2022 17:44:49 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=monjalon.net; h= cc:cc:content-transfer-encoding:date:date:from:from:in-reply-to :in-reply-to:message-id:mime-version:references:reply-to:sender :subject:subject:to:to; s=fm3; t=1666734289; x=1666820689; bh=Lm V5SjqUp4bDGhSkqL7tKdxsa5/AeqVEhjxLrLAf3ug=; b=Hu/yqEMIWuS3GHPv6b EtowVe8N8ZiBp0eWoJeNZz9y+KJjYbBuO2K7YZLv7BY2uTi67XFE5SvU12FWrVtt a4ErcWJHBKzbrWLGo7AYS9uLfMStiWCMbMkIleOK/vHGWVmGt6zW+9M6S5Nmuh2R 6pcwBHzTvQmZv+xZNCOn9SzGJt9+M954z3Q+AdE7KLh8Hm6NDuOtAmkL0RgE5xKs yqfcz2b7GfyD/eLd7EOxKW3Rre2neL0oG1KV+Q6Dzt/nGScccLe6bgfd0+v38rbF 2RdAWeZ3hP9erXANBocg4G92XRUzu3SOTFtqyvHzz+lOVokXzf8DcUXz0LLThTXm 3T1g== DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=cc:cc:content-transfer-encoding:date:date :feedback-id:feedback-id:from:from:in-reply-to:in-reply-to :message-id:mime-version:references:reply-to:sender:subject :subject:to:to:x-me-proxy:x-me-proxy:x-me-sender:x-me-sender :x-sasl-enc; s=fm3; t=1666734289; x=1666820689; bh=LmV5SjqUp4bDG hSkqL7tKdxsa5/AeqVEhjxLrLAf3ug=; b=jY0eTyUSwjw4W8eFDT8FYUCDGw9XN cZWYk8c+I0/U9pJEzMjr9ddLw1JJ7aVMxwyOzn5t3F5c2cUrsumEgwd/FPuGAM0w z7QsqFVsoPM1tatsssWKPdyK5M8hRx07JawCjX2E5x/W0/XaeDLcQ6kTpQSDSMwl GL1d+5QRRFmuXZ9EuWPQg4ALpv2WvIKF0yRPzuXZtiZT9NqyiGColKLHiA5OGO1f LFGtm6hdOI1W9Q3R66GQxFM5/E2W0Clhjsiya281Vux6w7z7XuzEXi3erV0fDNgh mEEQjN1LSEfAOMXtB5PrWM+AJ14C6luKwExDTICZ5CEOhM/cDlYx0+S1Q== X-ME-Sender: X-ME-Received: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgedvgedrtddugddtudcutefuodetggdotefrodftvf curfhrohhfihhlvgemucfhrghsthforghilhdpqfgfvfdpuffrtefokffrpgfnqfghnecu uegrihhlohhuthemuceftddtnecusecvtfgvtghiphhivghnthhsucdlqddutddtmdenuc fjughrpefhvfevufffkffojghfggfgsedtkeertdertddtnecuhfhrohhmpefvhhhomhgr shcuofhonhhjrghlohhnuceothhhohhmrghssehmohhnjhgrlhhonhdrnhgvtheqnecugg ftrfgrthhtvghrnhepvdejhfdugeehvddtieejieegteeuudfgjeeukeeiledthfetveek hefhieelhfdtnecuvehluhhsthgvrhfuihiivgeptdenucfrrghrrghmpehmrghilhhfrh homhepthhhohhmrghssehmohhnjhgrlhhonhdrnhgvth X-ME-Proxy: Feedback-ID: i47234305:Fastmail Received: by mail.messagingengine.com (Postfix) with ESMTPA; Tue, 25 Oct 2022 17:44:48 -0400 (EDT) From: Thomas Monjalon To: dev@dpdk.org Cc: ferruh.yigit@amd.com, andrew.rybchenko@oktetlabs.ru, Olivier Matz Subject: [PATCH 2/8] net: add smaller fields for VXLAN Date: Tue, 25 Oct 2022 23:44:04 +0200 Message-Id: <20221025214410.715864-3-thomas@monjalon.net> X-Mailer: git-send-email 2.36.1 In-Reply-To: <20221025214410.715864-1-thomas@monjalon.net> References: <20221025214410.715864-1-thomas@monjalon.net> MIME-Version: 1.0 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org The VXLAN and VXLAN-GPE headers were including reserved fields with other fields in big uint32_t struct members. Some more precise definitions are added as union of the old ones. The new struct members are smaller in size and in names. Signed-off-by: Thomas Monjalon --- lib/net/rte_vxlan.h | 35 +++++++++++++++++++++++++++++------ 1 file changed, 29 insertions(+), 6 deletions(-) diff --git a/lib/net/rte_vxlan.h b/lib/net/rte_vxlan.h index 929fa7a1dd..997fc784fc 100644 --- a/lib/net/rte_vxlan.h +++ b/lib/net/rte_vxlan.h @@ -30,9 +30,20 @@ extern "C" { * Contains the 8-bit flag, 24-bit VXLAN Network Identifier and * Reserved fields (24 bits and 8 bits) */ +__extension__ /* no named member in struct */ struct rte_vxlan_hdr { - rte_be32_t vx_flags; /**< flag (8) + Reserved (24). */ - rte_be32_t vx_vni; /**< VNI (24) + Reserved (8). */ + union { + struct { + rte_be32_t vx_flags; /**< flags (8) + Reserved (24). */ + rte_be32_t vx_vni; /**< VNI (24) + Reserved (8). */ + }; + struct { + uint8_t flags; /**< Should be 8 (I flag). */ + uint8_t rsvd0[3]; /**< Reserved. */ + uint8_t vni[3]; /**< VXLAN identifier. */ + uint8_t rsvd1; /**< Reserved. */ + }; + }; } __rte_packed; /** VXLAN tunnel header length. */ @@ -45,11 +56,23 @@ struct rte_vxlan_hdr { * Contains the 8-bit flag, 8-bit next-protocol, 24-bit VXLAN Network * Identifier and Reserved fields (16 bits and 8 bits). */ +__extension__ /* no named member in struct */ struct rte_vxlan_gpe_hdr { - uint8_t vx_flags; /**< flag (8). */ - uint8_t reserved[2]; /**< Reserved (16). */ - uint8_t proto; /**< next-protocol (8). */ - rte_be32_t vx_vni; /**< VNI (24) + Reserved (8). */ + union { + struct { + uint8_t vx_flags; /**< flag (8). */ + uint8_t reserved[2]; /**< Reserved (16). */ + uint8_t protocol; /**< next-protocol (8). */ + rte_be32_t vx_vni; /**< VNI (24) + Reserved (8). */ + }; + struct { + uint8_t flags; /**< Flags. */ + uint8_t rsvd0[2]; /**< Reserved. */ + uint8_t proto; /**< Next protocol. */ + uint8_t vni[3]; /**< VXLAN identifier. */ + uint8_t rsvd1; /**< Reserved. */ + }; + }; } __rte_packed; /** VXLAN-GPE tunnel header length. */ From patchwork Tue Oct 25 21:44:05 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Thomas Monjalon X-Patchwork-Id: 119120 X-Patchwork-Delegate: ferruh.yigit@amd.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 4997CA0544; Tue, 25 Oct 2022 23:45:05 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id EC57B42C5D; Tue, 25 Oct 2022 23:44:54 +0200 (CEST) Received: from out3-smtp.messagingengine.com (out3-smtp.messagingengine.com [66.111.4.27]) by mails.dpdk.org (Postfix) with ESMTP id 6790C42C6C for ; Tue, 25 Oct 2022 23:44:53 +0200 (CEST) Received: from compute2.internal (compute2.nyi.internal [10.202.2.46]) by mailout.nyi.internal (Postfix) with ESMTP id 256D35C019D; Tue, 25 Oct 2022 17:44:53 -0400 (EDT) Received: from mailfrontend1 ([10.202.2.162]) by compute2.internal (MEProxy); Tue, 25 Oct 2022 17:44:53 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=monjalon.net; h= cc:cc:content-transfer-encoding:date:date:from:from:in-reply-to :in-reply-to:message-id:mime-version:references:reply-to:sender :subject:subject:to:to; s=fm3; t=1666734293; x=1666820693; bh=TL kQJo5C1oSaw6U7fgCSevXbqtcXMQm4khWz7nIIrM4=; b=GYVcWvdHimRIh1ziqT ivsa72bwxlf1xfytxzth9b0bGaLUXYfJxGsFjg1RrOC9uPyTZ5zwkevZu/gj7fjQ y+Nt3QrJLe2VARnILwBdLfoXicHTBe1O22G1i0qrZPCnX7veKN//JpNqui8qVIsN RDLjkYc/aq/F9439auSvfAuEwv0PwajN09qnvkZi1zwfgHEylWMiYFeYjMVBcvLz kTM8tjkkGBOq7DshxYfhVCk9lMrpUTw5PHdlibKp+BmQRNT5UQY4uqCUNsiEDFuY IlyhYBsw1zQJXyCTSli3C33VJGVvLpM2nM75bhpIyg8l4ovvC9J+5szJoNSrYQmz e3Ww== DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=cc:cc:content-transfer-encoding:date:date :feedback-id:feedback-id:from:from:in-reply-to:in-reply-to :message-id:mime-version:references:reply-to:sender:subject :subject:to:to:x-me-proxy:x-me-proxy:x-me-sender:x-me-sender :x-sasl-enc; s=fm3; t=1666734293; x=1666820693; bh=TLkQJo5C1oSaw 6U7fgCSevXbqtcXMQm4khWz7nIIrM4=; b=cZ4rYbQ9ETl9hd0GcfKnVDQwb/0rR 73dd6PNsdCa0njO6AaDbMeo3kaoecMAksdcgpQ5qquOd9L7Ca5gM4JdeqthtSfHW lFot/omy5xdbetidSrqjggC2RxhuKwLH4DZlwi8KLVxpN8nMB+SzwtPztQDVSv41 s2PdtiXaglo4QzTIdGCNe4936Udwkzr624f5vZ+Kk7hIlc+zw2WlZ3TOOv2rN34F KCW0R4dS+trVRcjmnNV2Nwod1NLWWj/QHy0gqf4yZ1sMhpccGmMZE8u9hGGv9swX mV6hZCW5ByKl9xvEiyuI8tMuD6LjWvGcWUzYKt3bf2s7V2qOHMmZFUUuw== X-ME-Sender: X-ME-Received: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgedvgedrtddugddtvdcutefuodetggdotefrodftvf curfhrohhfihhlvgemucfhrghsthforghilhdpqfgfvfdpuffrtefokffrpgfnqfghnecu uegrihhlohhuthemuceftddtnecusecvtfgvtghiphhivghnthhsucdlqddutddtmdenuc fjughrpefhvfevufffkffojghfggfgsedtkeertdertddtnecuhfhrohhmpefvhhhomhgr shcuofhonhhjrghlohhnuceothhhohhmrghssehmohhnjhgrlhhonhdrnhgvtheqnecugg ftrfgrthhtvghrnhepvdejhfdugeehvddtieejieegteeuudfgjeeukeeiledthfetveek hefhieelhfdtnecuvehluhhsthgvrhfuihiivgeptdenucfrrghrrghmpehmrghilhhfrh homhepthhhohhmrghssehmohhnjhgrlhhonhdrnhgvth X-ME-Proxy: Feedback-ID: i47234305:Fastmail Received: by mail.messagingengine.com (Postfix) with ESMTPA; Tue, 25 Oct 2022 17:44:50 -0400 (EDT) From: Thomas Monjalon To: dev@dpdk.org Cc: ferruh.yigit@amd.com, andrew.rybchenko@oktetlabs.ru, Wisam Jaddo , Ori Kam , Aman Singh , Yuying Zhang , Ajit Khaparde , Somnath Kotur , Dongdong Liu , Yisen Zhuang , Beilei Xing , Qiming Yang , Qi Zhang , Rosen Xu , Wenjun Wu , Matan Azrad , Viacheslav Ovsiienko Subject: [PATCH 3/8] ethdev: use VXLAN protocol struct for flow matching Date: Tue, 25 Oct 2022 23:44:05 +0200 Message-Id: <20221025214410.715864-4-thomas@monjalon.net> X-Mailer: git-send-email 2.36.1 In-Reply-To: <20221025214410.715864-1-thomas@monjalon.net> References: <20221025214410.715864-1-thomas@monjalon.net> MIME-Version: 1.0 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org As announced in the deprecation notice, flow item structures should re-use the protocol header definitions from the directory lib/net/. In the case of VXLAN-GPE, the protocol struct is added in an unnamed union, keeping old field names. The VXLAN headers (including VXLAN-GPE) are used in apps and drivers instead of the redundant fields in the flow items. Signed-off-by: Thomas Monjalon --- app/test-flow-perf/actions_gen.c | 2 +- app/test-flow-perf/items_gen.c | 12 +++---- app/test-pmd/cmdline_flow.c | 10 +++--- doc/guides/prog_guide/rte_flow.rst | 11 ++---- doc/guides/rel_notes/deprecation.rst | 1 - drivers/net/bnxt/bnxt_flow.c | 12 ++++--- drivers/net/bnxt/tf_ulp/ulp_rte_parser.c | 42 +++++++++++----------- drivers/net/hns3/hns3_flow.c | 12 +++---- drivers/net/i40e/i40e_flow.c | 4 +-- drivers/net/ice/ice_switch_filter.c | 18 +++++----- drivers/net/ipn3ke/ipn3ke_flow.c | 4 +-- drivers/net/ixgbe/ixgbe_flow.c | 18 +++++----- drivers/net/mlx5/mlx5_flow.c | 16 ++++----- drivers/net/mlx5/mlx5_flow_dv.c | 44 ++++++++++++------------ drivers/net/mlx5/mlx5_flow_verbs.c | 8 ++--- drivers/net/sfc/sfc_flow.c | 6 ++-- drivers/net/sfc/sfc_mae.c | 8 ++--- lib/ethdev/rte_flow.h | 24 +++++++++---- 18 files changed, 128 insertions(+), 124 deletions(-) diff --git a/app/test-flow-perf/actions_gen.c b/app/test-flow-perf/actions_gen.c index 63f05d87fa..f1d5931325 100644 --- a/app/test-flow-perf/actions_gen.c +++ b/app/test-flow-perf/actions_gen.c @@ -874,7 +874,7 @@ add_vxlan_encap(struct rte_flow_action *actions, items[2].type = RTE_FLOW_ITEM_TYPE_UDP; - item_vxlan.vni[2] = 1; + item_vxlan.hdr.vni[2] = 1; items[3].spec = &item_vxlan; items[3].mask = &item_vxlan; items[3].type = RTE_FLOW_ITEM_TYPE_VXLAN; diff --git a/app/test-flow-perf/items_gen.c b/app/test-flow-perf/items_gen.c index b7f51030a1..a58245239b 100644 --- a/app/test-flow-perf/items_gen.c +++ b/app/test-flow-perf/items_gen.c @@ -128,12 +128,12 @@ add_vxlan(struct rte_flow_item *items, /* Set standard vxlan vni */ for (i = 0; i < 3; i++) { - vxlan_specs[ti].vni[2 - i] = vni_value >> (i * 8); - vxlan_masks[ti].vni[2 - i] = 0xff; + vxlan_specs[ti].hdr.vni[2 - i] = vni_value >> (i * 8); + vxlan_masks[ti].hdr.vni[2 - i] = 0xff; } /* Standard vxlan flags */ - vxlan_specs[ti].flags = 0x8; + vxlan_specs[ti].hdr.flags = 0x8; items[items_counter].type = RTE_FLOW_ITEM_TYPE_VXLAN; items[items_counter].spec = &vxlan_specs[ti]; @@ -155,12 +155,12 @@ add_vxlan_gpe(struct rte_flow_item *items, /* Set vxlan-gpe vni */ for (i = 0; i < 3; i++) { - vxlan_gpe_specs[ti].vni[2 - i] = vni_value >> (i * 8); - vxlan_gpe_masks[ti].vni[2 - i] = 0xff; + vxlan_gpe_specs[ti].hdr.vni[2 - i] = vni_value >> (i * 8); + vxlan_gpe_masks[ti].hdr.vni[2 - i] = 0xff; } /* vxlan-gpe flags */ - vxlan_gpe_specs[ti].flags = 0x0c; + vxlan_gpe_specs[ti].hdr.flags = 0x0c; items[items_counter].type = RTE_FLOW_ITEM_TYPE_VXLAN_GPE; items[items_counter].spec = &vxlan_gpe_specs[ti]; diff --git a/app/test-pmd/cmdline_flow.c b/app/test-pmd/cmdline_flow.c index 68fb4b3fe4..fcbd0a2534 100644 --- a/app/test-pmd/cmdline_flow.c +++ b/app/test-pmd/cmdline_flow.c @@ -3950,7 +3950,7 @@ static const struct token token_list[] = { .help = "VXLAN identifier", .next = NEXT(item_vxlan, NEXT_ENTRY(COMMON_UNSIGNED), item_param), - .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_vxlan, vni)), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_vxlan, hdr.vni)), }, [ITEM_VXLAN_LAST_RSVD] = { .name = "last_rsvd", @@ -3958,7 +3958,7 @@ static const struct token token_list[] = { .next = NEXT(item_vxlan, NEXT_ENTRY(COMMON_UNSIGNED), item_param), .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_vxlan, - rsvd1)), + hdr.rsvd1)), }, [ITEM_E_TAG] = { .name = "e_tag", @@ -4176,7 +4176,7 @@ static const struct token token_list[] = { .next = NEXT(item_vxlan_gpe, NEXT_ENTRY(COMMON_UNSIGNED), item_param), .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_vxlan_gpe, - vni)), + hdr.vni)), }, [ITEM_ARP_ETH_IPV4] = { .name = "arp_eth_ipv4", @@ -7415,7 +7415,7 @@ parse_setup_vxlan_encap_data(struct action_vxlan_encap_data *action_vxlan_encap_ .src_port = vxlan_encap_conf.udp_src, .dst_port = vxlan_encap_conf.udp_dst, }, - .item_vxlan.flags = 0, + .item_vxlan.hdr.flags = 0, }; memcpy(action_vxlan_encap_data->item_eth.hdr.dst_addr.addr_bytes, vxlan_encap_conf.eth_dst, RTE_ETHER_ADDR_LEN); @@ -7469,7 +7469,7 @@ parse_setup_vxlan_encap_data(struct action_vxlan_encap_data *action_vxlan_encap_ &ipv6_mask_tos; } } - memcpy(action_vxlan_encap_data->item_vxlan.vni, vxlan_encap_conf.vni, + memcpy(action_vxlan_encap_data->item_vxlan.hdr.vni, vxlan_encap_conf.vni, RTE_DIM(vxlan_encap_conf.vni)); return 0; } diff --git a/doc/guides/prog_guide/rte_flow.rst b/doc/guides/prog_guide/rte_flow.rst index 4323681b86..92d3168d39 100644 --- a/doc/guides/prog_guide/rte_flow.rst +++ b/doc/guides/prog_guide/rte_flow.rst @@ -935,10 +935,7 @@ Item: ``VXLAN`` Matches a VXLAN header (RFC 7348). -- ``flags``: normally 0x08 (I flag). -- ``rsvd0``: reserved, normally 0x000000. -- ``vni``: VXLAN network identifier. -- ``rsvd1``: reserved, normally 0x00. +- ``hdr``: header definition (``rte_vxlan.h``). - Default ``mask`` matches VNI only. Item: ``E_TAG`` @@ -1104,11 +1101,7 @@ Item: ``VXLAN-GPE`` Matches a VXLAN-GPE header (draft-ietf-nvo3-vxlan-gpe-05). -- ``flags``: normally 0x0C (I and P flags). -- ``rsvd0``: reserved, normally 0x0000. -- ``protocol``: protocol type. -- ``vni``: VXLAN network identifier. -- ``rsvd1``: reserved, normally 0x00. +- ``hdr``: header definition (``rte_vxlan.h``). - Default ``mask`` matches VNI only. Item: ``ARP_ETH_IPV4`` diff --git a/doc/guides/rel_notes/deprecation.rst b/doc/guides/rel_notes/deprecation.rst index 368b857e20..52c43bb652 100644 --- a/doc/guides/rel_notes/deprecation.rst +++ b/doc/guides/rel_notes/deprecation.rst @@ -87,7 +87,6 @@ Deprecation Notices - ``rte_flow_item_pfcp`` - ``rte_flow_item_pppoe`` - ``rte_flow_item_pppoe_proto_id`` - - ``rte_flow_item_vxlan_gpe`` * ethdev: Queue specific stats fields will be removed from ``struct rte_eth_stats``. Mentioned fields are: ``q_ipackets``, ``q_opackets``, ``q_ibytes``, ``q_obytes``, diff --git a/drivers/net/bnxt/bnxt_flow.c b/drivers/net/bnxt/bnxt_flow.c index 8f66049340..4a107e81e9 100644 --- a/drivers/net/bnxt/bnxt_flow.c +++ b/drivers/net/bnxt/bnxt_flow.c @@ -563,9 +563,11 @@ bnxt_validate_and_parse_flow_type(const struct rte_flow_attr *attr, break; } - if (vxlan_spec->rsvd1 || vxlan_spec->rsvd0[0] || - vxlan_spec->rsvd0[1] || vxlan_spec->rsvd0[2] || - vxlan_spec->flags != 0x8) { + if ((vxlan_spec->hdr.rsvd0[0] != 0) || + (vxlan_spec->hdr.rsvd0[1] != 0) || + (vxlan_spec->hdr.rsvd0[2] != 0) || + (vxlan_spec->hdr.rsvd1 != 0) || + (vxlan_spec->hdr.flags != 8)) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, @@ -577,7 +579,7 @@ bnxt_validate_and_parse_flow_type(const struct rte_flow_attr *attr, /* Check if VNI is masked. */ if (vxlan_mask != NULL) { vni_masked = - !!memcmp(vxlan_mask->vni, vni_mask, + !!memcmp(vxlan_mask->hdr.vni, vni_mask, RTE_DIM(vni_mask)); if (vni_masked) { rte_flow_error_set @@ -590,7 +592,7 @@ bnxt_validate_and_parse_flow_type(const struct rte_flow_attr *attr, } rte_memcpy(((uint8_t *)&tenant_id_be + 1), - vxlan_spec->vni, 3); + vxlan_spec->hdr.vni, 3); filter->vni = rte_be_to_cpu_32(tenant_id_be); filter->tunnel_type = diff --git a/drivers/net/bnxt/tf_ulp/ulp_rte_parser.c b/drivers/net/bnxt/tf_ulp/ulp_rte_parser.c index 2928598ced..80869b79c3 100644 --- a/drivers/net/bnxt/tf_ulp/ulp_rte_parser.c +++ b/drivers/net/bnxt/tf_ulp/ulp_rte_parser.c @@ -1414,28 +1414,28 @@ ulp_rte_vxlan_hdr_handler(const struct rte_flow_item *item, * Copy the rte_flow_item for vxlan into hdr_field using vxlan * header fields */ - size = sizeof(((struct rte_flow_item_vxlan *)NULL)->flags); + size = sizeof(((struct rte_flow_item_vxlan *)NULL)->hdr.flags); ulp_rte_prsr_fld_mask(params, &idx, size, - ulp_deference_struct(vxlan_spec, flags), - ulp_deference_struct(vxlan_mask, flags), + ulp_deference_struct(vxlan_spec, hdr.flags), + ulp_deference_struct(vxlan_mask, hdr.flags), ULP_PRSR_ACT_DEFAULT); - size = sizeof(((struct rte_flow_item_vxlan *)NULL)->rsvd0); + size = sizeof(((struct rte_flow_item_vxlan *)NULL)->hdr.rsvd0); ulp_rte_prsr_fld_mask(params, &idx, size, - ulp_deference_struct(vxlan_spec, rsvd0), - ulp_deference_struct(vxlan_mask, rsvd0), + ulp_deference_struct(vxlan_spec, hdr.rsvd0), + ulp_deference_struct(vxlan_mask, hdr.rsvd0), ULP_PRSR_ACT_DEFAULT); - size = sizeof(((struct rte_flow_item_vxlan *)NULL)->vni); + size = sizeof(((struct rte_flow_item_vxlan *)NULL)->hdr.vni); ulp_rte_prsr_fld_mask(params, &idx, size, - ulp_deference_struct(vxlan_spec, vni), - ulp_deference_struct(vxlan_mask, vni), + ulp_deference_struct(vxlan_spec, hdr.vni), + ulp_deference_struct(vxlan_mask, hdr.vni), ULP_PRSR_ACT_DEFAULT); - size = sizeof(((struct rte_flow_item_vxlan *)NULL)->rsvd1); + size = sizeof(((struct rte_flow_item_vxlan *)NULL)->hdr.rsvd1); ulp_rte_prsr_fld_mask(params, &idx, size, - ulp_deference_struct(vxlan_spec, rsvd1), - ulp_deference_struct(vxlan_mask, rsvd1), + ulp_deference_struct(vxlan_spec, hdr.rsvd1), + ulp_deference_struct(vxlan_mask, hdr.rsvd1), ULP_PRSR_ACT_DEFAULT); /* Update the hdr_bitmap with vxlan */ @@ -1827,17 +1827,17 @@ ulp_rte_enc_vxlan_hdr_handler(struct ulp_rte_parser_params *params, uint32_t size; field = ¶ms->enc_field[BNXT_ULP_ENC_FIELD_VXLAN_FLAGS]; - size = sizeof(vxlan_spec->flags); - field = ulp_rte_parser_fld_copy(field, &vxlan_spec->flags, size); + size = sizeof(vxlan_spec->hdr.flags); + field = ulp_rte_parser_fld_copy(field, &vxlan_spec->hdr.flags, size); - size = sizeof(vxlan_spec->rsvd0); - field = ulp_rte_parser_fld_copy(field, &vxlan_spec->rsvd0, size); + size = sizeof(vxlan_spec->hdr.rsvd0); + field = ulp_rte_parser_fld_copy(field, &vxlan_spec->hdr.rsvd0, size); - size = sizeof(vxlan_spec->vni); - field = ulp_rte_parser_fld_copy(field, &vxlan_spec->vni, size); + size = sizeof(vxlan_spec->hdr.vni); + field = ulp_rte_parser_fld_copy(field, &vxlan_spec->hdr.vni, size); - size = sizeof(vxlan_spec->rsvd1); - field = ulp_rte_parser_fld_copy(field, &vxlan_spec->rsvd1, size); + size = sizeof(vxlan_spec->hdr.rsvd1); + field = ulp_rte_parser_fld_copy(field, &vxlan_spec->hdr.rsvd1, size); ULP_BITMAP_SET(params->enc_hdr_bitmap.bits, BNXT_ULP_HDR_BIT_T_VXLAN); } @@ -1989,7 +1989,7 @@ ulp_rte_vxlan_encap_act_handler(const struct rte_flow_action *action_item, vxlan_size = sizeof(struct rte_flow_item_vxlan); /* copy the vxlan details */ memcpy(&vxlan_spec, item->spec, vxlan_size); - vxlan_spec.flags = 0x08; + vxlan_spec.hdr.flags = 0x08; vxlan_size = tfp_cpu_to_be_32(vxlan_size); memcpy(&ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_TUN_SZ], &vxlan_size, sizeof(uint32_t)); diff --git a/drivers/net/hns3/hns3_flow.c b/drivers/net/hns3/hns3_flow.c index ef1832982d..e88f9b7e45 100644 --- a/drivers/net/hns3/hns3_flow.c +++ b/drivers/net/hns3/hns3_flow.c @@ -933,23 +933,23 @@ hns3_parse_vxlan(const struct rte_flow_item *item, struct hns3_fdir_rule *rule, vxlan_mask = item->mask; vxlan_spec = item->spec; - if (vxlan_mask->flags) + if (vxlan_mask->hdr.flags) return rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM_MASK, item, "Flags is not supported in VxLAN"); /* VNI must be totally masked or not. */ - if (memcmp(vxlan_mask->vni, full_mask, VNI_OR_TNI_LEN) && - memcmp(vxlan_mask->vni, zero_mask, VNI_OR_TNI_LEN)) + if (memcmp(vxlan_mask->hdr.vni, full_mask, VNI_OR_TNI_LEN) && + memcmp(vxlan_mask->hdr.vni, zero_mask, VNI_OR_TNI_LEN)) return rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM_MASK, item, "VNI must be totally masked or not in VxLAN"); - if (vxlan_mask->vni[0]) { + if (vxlan_mask->hdr.vni[0]) { hns3_set_bit(rule->input_set, OUTER_TUN_VNI, 1); - memcpy(rule->key_conf.mask.outer_tun_vni, vxlan_mask->vni, + memcpy(rule->key_conf.mask.outer_tun_vni, vxlan_mask->hdr.vni, VNI_OR_TNI_LEN); } - memcpy(rule->key_conf.spec.outer_tun_vni, vxlan_spec->vni, + memcpy(rule->key_conf.spec.outer_tun_vni, vxlan_spec->hdr.vni, VNI_OR_TNI_LEN); return 0; } diff --git a/drivers/net/i40e/i40e_flow.c b/drivers/net/i40e/i40e_flow.c index 0acbd5a061..2855b14fe6 100644 --- a/drivers/net/i40e/i40e_flow.c +++ b/drivers/net/i40e/i40e_flow.c @@ -3009,7 +3009,7 @@ i40e_flow_parse_vxlan_pattern(__rte_unused struct rte_eth_dev *dev, /* Check if VNI is masked. */ if (vxlan_spec && vxlan_mask) { is_vni_masked = - !!memcmp(vxlan_mask->vni, vni_mask, + !!memcmp(vxlan_mask->hdr.vni, vni_mask, RTE_DIM(vni_mask)); if (is_vni_masked) { rte_flow_error_set(error, EINVAL, @@ -3020,7 +3020,7 @@ i40e_flow_parse_vxlan_pattern(__rte_unused struct rte_eth_dev *dev, } rte_memcpy(((uint8_t *)&tenant_id_be + 1), - vxlan_spec->vni, 3); + vxlan_spec->hdr.vni, 3); filter->tenant_id = rte_be_to_cpu_32(tenant_id_be); filter_type |= RTE_ETH_TUNNEL_FILTER_TENID; diff --git a/drivers/net/ice/ice_switch_filter.c b/drivers/net/ice/ice_switch_filter.c index d84061340e..7cb20fa0b4 100644 --- a/drivers/net/ice/ice_switch_filter.c +++ b/drivers/net/ice/ice_switch_filter.c @@ -990,17 +990,17 @@ ice_switch_parse_pattern(const struct rte_flow_item pattern[], input = &inner_input_set; if (vxlan_spec && vxlan_mask) { list[t].type = ICE_VXLAN; - if (vxlan_mask->vni[0] || - vxlan_mask->vni[1] || - vxlan_mask->vni[2]) { + if (vxlan_mask->hdr.vni[0] || + vxlan_mask->hdr.vni[1] || + vxlan_mask->hdr.vni[2]) { list[t].h_u.tnl_hdr.vni = - (vxlan_spec->vni[2] << 16) | - (vxlan_spec->vni[1] << 8) | - vxlan_spec->vni[0]; + (vxlan_spec->hdr.vni[2] << 16) | + (vxlan_spec->hdr.vni[1] << 8) | + vxlan_spec->hdr.vni[0]; list[t].m_u.tnl_hdr.vni = - (vxlan_mask->vni[2] << 16) | - (vxlan_mask->vni[1] << 8) | - vxlan_mask->vni[0]; + (vxlan_mask->hdr.vni[2] << 16) | + (vxlan_mask->hdr.vni[1] << 8) | + vxlan_mask->hdr.vni[0]; *input |= ICE_INSET_VXLAN_VNI; input_set_byte += 2; } diff --git a/drivers/net/ipn3ke/ipn3ke_flow.c b/drivers/net/ipn3ke/ipn3ke_flow.c index ee56d0f43d..d20a29b9a2 100644 --- a/drivers/net/ipn3ke/ipn3ke_flow.c +++ b/drivers/net/ipn3ke/ipn3ke_flow.c @@ -108,7 +108,7 @@ ipn3ke_pattern_vxlan(const struct rte_flow_item patterns[], case RTE_FLOW_ITEM_TYPE_VXLAN: vxlan = item->spec; - rte_memcpy(&parser->key[6], vxlan->vni, 3); + rte_memcpy(&parser->key[6], vxlan->hdr.vni, 3); break; default: @@ -576,7 +576,7 @@ ipn3ke_pattern_vxlan_ip_udp(const struct rte_flow_item patterns[], case RTE_FLOW_ITEM_TYPE_VXLAN: vxlan = item->spec; - rte_memcpy(&parser->key[0], vxlan->vni, 3); + rte_memcpy(&parser->key[0], vxlan->hdr.vni, 3); break; case RTE_FLOW_ITEM_TYPE_IPV4: diff --git a/drivers/net/ixgbe/ixgbe_flow.c b/drivers/net/ixgbe/ixgbe_flow.c index 6bcd4f7126..1cbebc9a3e 100644 --- a/drivers/net/ixgbe/ixgbe_flow.c +++ b/drivers/net/ixgbe/ixgbe_flow.c @@ -2481,7 +2481,7 @@ ixgbe_parse_fdir_filter_tunnel(const struct rte_flow_attr *attr, rule->mask.tunnel_type_mask = 1; vxlan_mask = item->mask; - if (vxlan_mask->flags) { + if (vxlan_mask->hdr.flags) { memset(rule, 0, sizeof(struct ixgbe_fdir_rule)); rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, @@ -2489,11 +2489,11 @@ ixgbe_parse_fdir_filter_tunnel(const struct rte_flow_attr *attr, return -rte_errno; } /* VNI must be totally masked or not. */ - if ((vxlan_mask->vni[0] || vxlan_mask->vni[1] || - vxlan_mask->vni[2]) && - ((vxlan_mask->vni[0] != 0xFF) || - (vxlan_mask->vni[1] != 0xFF) || - (vxlan_mask->vni[2] != 0xFF))) { + if ((vxlan_mask->hdr.vni[0] || vxlan_mask->hdr.vni[1] || + vxlan_mask->hdr.vni[2]) && + ((vxlan_mask->hdr.vni[0] != 0xFF) || + (vxlan_mask->hdr.vni[1] != 0xFF) || + (vxlan_mask->hdr.vni[2] != 0xFF))) { memset(rule, 0, sizeof(struct ixgbe_fdir_rule)); rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, @@ -2501,15 +2501,15 @@ ixgbe_parse_fdir_filter_tunnel(const struct rte_flow_attr *attr, return -rte_errno; } - rte_memcpy(&rule->mask.tunnel_id_mask, vxlan_mask->vni, - RTE_DIM(vxlan_mask->vni)); + rte_memcpy(&rule->mask.tunnel_id_mask, vxlan_mask->hdr.vni, + RTE_DIM(vxlan_mask->hdr.vni)); if (item->spec) { rule->b_spec = TRUE; vxlan_spec = item->spec; rte_memcpy(((uint8_t *) &rule->ixgbe_fdir.formatted.tni_vni), - vxlan_spec->vni, RTE_DIM(vxlan_spec->vni)); + vxlan_spec->hdr.vni, RTE_DIM(vxlan_spec->hdr.vni)); } } diff --git a/drivers/net/mlx5/mlx5_flow.c b/drivers/net/mlx5/mlx5_flow.c index 0f88fa41d9..10f6abeb07 100644 --- a/drivers/net/mlx5/mlx5_flow.c +++ b/drivers/net/mlx5/mlx5_flow.c @@ -308,7 +308,7 @@ mlx5_flow_expand_rss_item_complete(const struct rte_flow_item *item) ret = mlx5_ethertype_to_item_type(spec, mask, true); break; case RTE_FLOW_ITEM_TYPE_VXLAN_GPE: - MLX5_XSET_ITEM_MASK_SPEC(vxlan_gpe, protocol); + MLX5_XSET_ITEM_MASK_SPEC(vxlan_gpe, hdr.proto); ret = mlx5_nsh_proto_to_item_type(spec, mask); break; default: @@ -2816,8 +2816,8 @@ mlx5_flow_validate_item_vxlan(struct rte_eth_dev *dev, uint8_t vni[4]; } id = { .vlan_id = 0, }; const struct rte_flow_item_vxlan nic_mask = { - .vni = "\xff\xff\xff", - .rsvd1 = 0xff, + .hdr.vni = "\xff\xff\xff", + .hdr.rsvd1 = 0xff, }; const struct rte_flow_item_vxlan *valid_mask; @@ -2857,8 +2857,8 @@ mlx5_flow_validate_item_vxlan(struct rte_eth_dev *dev, if (ret < 0) return ret; if (spec) { - memcpy(&id.vni[1], spec->vni, 3); - memcpy(&id.vni[1], mask->vni, 3); + memcpy(&id.vni[1], spec->hdr.vni, 3); + memcpy(&id.vni[1], mask->hdr.vni, 3); } if (!(item_flags & MLX5_FLOW_LAYER_OUTER)) return rte_flow_error_set(error, ENOTSUP, @@ -2928,14 +2928,14 @@ mlx5_flow_validate_item_vxlan_gpe(const struct rte_flow_item *item, if (ret < 0) return ret; if (spec) { - if (spec->protocol) + if (spec->hdr.proto) return rte_flow_error_set(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_ITEM, item, "VxLAN-GPE protocol" " not supported"); - memcpy(&id.vni[1], spec->vni, 3); - memcpy(&id.vni[1], mask->vni, 3); + memcpy(&id.vni[1], spec->hdr.vni, 3); + memcpy(&id.vni[1], mask->hdr.vni, 3); } if (!(item_flags & MLX5_FLOW_LAYER_OUTER)) return rte_flow_error_set(error, ENOTSUP, diff --git a/drivers/net/mlx5/mlx5_flow_dv.c b/drivers/net/mlx5/mlx5_flow_dv.c index 4987631e79..a06b6e1860 100644 --- a/drivers/net/mlx5/mlx5_flow_dv.c +++ b/drivers/net/mlx5/mlx5_flow_dv.c @@ -9244,8 +9244,8 @@ flow_dv_translate_item_vxlan(struct rte_eth_dev *dev, uint16_t dport; struct mlx5_priv *priv = dev->data->dev_private; const struct rte_flow_item_vxlan nic_mask = { - .vni = "\xff\xff\xff", - .rsvd1 = 0xff, + .hdr.vni = "\xff\xff\xff", + .hdr.rsvd1 = 0xff, }; if (inner) { @@ -9287,12 +9287,12 @@ flow_dv_translate_item_vxlan(struct rte_eth_dev *dev, misc_m = MLX5_ADDR_OF(fte_match_param, matcher, misc_parameters); misc_v = MLX5_ADDR_OF(fte_match_param, key, misc_parameters); - size = sizeof(vxlan_m->vni); + size = sizeof(vxlan_m->hdr.vni); vni_m = MLX5_ADDR_OF(fte_match_set_misc, misc_m, vxlan_vni); vni_v = MLX5_ADDR_OF(fte_match_set_misc, misc_v, vxlan_vni); - memcpy(vni_m, vxlan_m->vni, size); + memcpy(vni_m, vxlan_m->hdr.vni, size); for (i = 0; i < size; ++i) - vni_v[i] = vni_m[i] & vxlan_v->vni[i]; + vni_v[i] = vni_m[i] & vxlan_v->hdr.vni[i]; return; } misc5_m = MLX5_ADDR_OF(fte_match_param, matcher, misc_parameters_5); @@ -9303,18 +9303,18 @@ flow_dv_translate_item_vxlan(struct rte_eth_dev *dev, tunnel_header_m = (uint32_t *)MLX5_ADDR_OF(fte_match_set_misc5, misc5_m, tunnel_header_1); - *tunnel_header_v = (vxlan_v->vni[0] & vxlan_m->vni[0]) | - (vxlan_v->vni[1] & vxlan_m->vni[1]) << 8 | - (vxlan_v->vni[2] & vxlan_m->vni[2]) << 16; + *tunnel_header_v = (vxlan_v->hdr.vni[0] & vxlan_m->hdr.vni[0]) | + (vxlan_v->hdr.vni[1] & vxlan_m->hdr.vni[1]) << 8 | + (vxlan_v->hdr.vni[2] & vxlan_m->hdr.vni[2]) << 16; if (*tunnel_header_v) - *tunnel_header_m = vxlan_m->vni[0] | - vxlan_m->vni[1] << 8 | - vxlan_m->vni[2] << 16; + *tunnel_header_m = vxlan_m->hdr.vni[0] | + vxlan_m->hdr.vni[1] << 8 | + vxlan_m->hdr.vni[2] << 16; else *tunnel_header_m = 0x0; - *tunnel_header_v |= (vxlan_v->rsvd1 & vxlan_m->rsvd1) << 24; - if (vxlan_v->rsvd1 & vxlan_m->rsvd1) - *tunnel_header_m |= vxlan_m->rsvd1 << 24; + *tunnel_header_v |= (vxlan_v->hdr.rsvd1 & vxlan_m->hdr.rsvd1) << 24; + if (vxlan_v->hdr.rsvd1 & vxlan_m->hdr.rsvd1) + *tunnel_header_m |= vxlan_m->hdr.rsvd1 << 24; } /** @@ -9349,7 +9349,7 @@ flow_dv_translate_item_vxlan_gpe(void *matcher, void *key, MLX5_ADDR_OF(fte_match_set_misc3, misc_m, outer_vxlan_gpe_vni); char *vni_v = MLX5_ADDR_OF(fte_match_set_misc3, misc_v, outer_vxlan_gpe_vni); - int i, size = sizeof(vxlan_m->vni); + int i, size = sizeof(vxlan_m->hdr.vni); uint8_t flags_m = 0xff; uint8_t flags_v = 0xc; uint8_t m_protocol, v_protocol; @@ -9366,17 +9366,17 @@ flow_dv_translate_item_vxlan_gpe(void *matcher, void *key, if (!vxlan_m) vxlan_m = &rte_flow_item_vxlan_gpe_mask; } - memcpy(vni_m, vxlan_m->vni, size); + memcpy(vni_m, vxlan_m->hdr.vni, size); for (i = 0; i < size; ++i) - vni_v[i] = vni_m[i] & vxlan_v->vni[i]; - if (vxlan_m->flags) { - flags_m = vxlan_m->flags; - flags_v = vxlan_v->flags; + vni_v[i] = vni_m[i] & vxlan_v->hdr.vni[i]; + if (vxlan_m->hdr.flags) { + flags_m = vxlan_m->hdr.flags; + flags_v = vxlan_v->hdr.flags; } MLX5_SET(fte_match_set_misc3, misc_m, outer_vxlan_gpe_flags, flags_m); MLX5_SET(fte_match_set_misc3, misc_v, outer_vxlan_gpe_flags, flags_v); - m_protocol = vxlan_m->protocol; - v_protocol = vxlan_v->protocol; + m_protocol = vxlan_m->hdr.proto; + v_protocol = vxlan_v->hdr.proto; if (!m_protocol) { /* Force next protocol to ensure next headers parsing. */ if (pattern_flags & MLX5_FLOW_LAYER_INNER_L2) diff --git a/drivers/net/mlx5/mlx5_flow_verbs.c b/drivers/net/mlx5/mlx5_flow_verbs.c index a8b84a2119..facab1b313 100644 --- a/drivers/net/mlx5/mlx5_flow_verbs.c +++ b/drivers/net/mlx5/mlx5_flow_verbs.c @@ -778,9 +778,9 @@ flow_verbs_translate_item_vxlan(struct mlx5_flow *dev_flow, if (!mask) mask = &rte_flow_item_vxlan_mask; if (spec) { - memcpy(&id.vni[1], spec->vni, 3); + memcpy(&id.vni[1], spec->hdr.vni, 3); vxlan.val.tunnel_id = id.vlan_id; - memcpy(&id.vni[1], mask->vni, 3); + memcpy(&id.vni[1], mask->hdr.vni, 3); vxlan.mask.tunnel_id = id.vlan_id; /* Remove unwanted bits from values. */ vxlan.val.tunnel_id &= vxlan.mask.tunnel_id; @@ -820,9 +820,9 @@ flow_verbs_translate_item_vxlan_gpe(struct mlx5_flow *dev_flow, if (!mask) mask = &rte_flow_item_vxlan_gpe_mask; if (spec) { - memcpy(&id.vni[1], spec->vni, 3); + memcpy(&id.vni[1], spec->hdr.vni, 3); vxlan_gpe.val.tunnel_id = id.vlan_id; - memcpy(&id.vni[1], mask->vni, 3); + memcpy(&id.vni[1], mask->hdr.vni, 3); vxlan_gpe.mask.tunnel_id = id.vlan_id; /* Remove unwanted bits from values. */ vxlan_gpe.val.tunnel_id &= vxlan_gpe.mask.tunnel_id; diff --git a/drivers/net/sfc/sfc_flow.c b/drivers/net/sfc/sfc_flow.c index f098edc6eb..fe1f5ba55f 100644 --- a/drivers/net/sfc/sfc_flow.c +++ b/drivers/net/sfc/sfc_flow.c @@ -921,7 +921,7 @@ sfc_flow_parse_vxlan(const struct rte_flow_item *item, const struct rte_flow_item_vxlan *spec = NULL; const struct rte_flow_item_vxlan *mask = NULL; const struct rte_flow_item_vxlan supp_mask = { - .vni = { 0xff, 0xff, 0xff } + .hdr.vni = { 0xff, 0xff, 0xff } }; rc = sfc_flow_parse_init(item, @@ -945,8 +945,8 @@ sfc_flow_parse_vxlan(const struct rte_flow_item *item, if (spec == NULL) return 0; - rc = sfc_flow_set_efx_spec_vni_or_vsid(efx_spec, spec->vni, - mask->vni, item, error); + rc = sfc_flow_set_efx_spec_vni_or_vsid(efx_spec, spec->hdr.vni, + mask->hdr.vni, item, error); return rc; } diff --git a/drivers/net/sfc/sfc_mae.c b/drivers/net/sfc/sfc_mae.c index 710d04be13..aab697b204 100644 --- a/drivers/net/sfc/sfc_mae.c +++ b/drivers/net/sfc/sfc_mae.c @@ -2223,8 +2223,8 @@ static const struct sfc_mae_field_locator flocs_tunnel[] = { * The size and offset values are relevant * for Geneve and NVGRE, too. */ - .size = RTE_SIZEOF_FIELD(struct rte_flow_item_vxlan, vni), - .ofst = offsetof(struct rte_flow_item_vxlan, vni), + .size = RTE_SIZEOF_FIELD(struct rte_flow_item_vxlan, hdr.vni), + .ofst = offsetof(struct rte_flow_item_vxlan, hdr.vni), }, }; @@ -2359,10 +2359,10 @@ sfc_mae_rule_parse_item_tunnel(const struct rte_flow_item *item, * The extra byte is 0 both in the mask and in the value. */ vxp = (const struct rte_flow_item_vxlan *)spec; - memcpy(vnet_id_v + 1, &vxp->vni, sizeof(vxp->vni)); + memcpy(vnet_id_v + 1, &vxp->hdr.vni, sizeof(vxp->hdr.vni)); vxp = (const struct rte_flow_item_vxlan *)mask; - memcpy(vnet_id_m + 1, &vxp->vni, sizeof(vxp->vni)); + memcpy(vnet_id_m + 1, &vxp->hdr.vni, sizeof(vxp->hdr.vni)); rc = efx_mae_match_spec_field_set(ctx_mae->match_spec, EFX_MAE_FIELD_ENC_VNET_ID_BE, diff --git a/lib/ethdev/rte_flow.h b/lib/ethdev/rte_flow.h index cddbe74c33..6045a352ae 100644 --- a/lib/ethdev/rte_flow.h +++ b/lib/ethdev/rte_flow.h @@ -987,7 +987,7 @@ struct rte_flow_item_vxlan { /** Default mask for RTE_FLOW_ITEM_TYPE_VXLAN. */ #ifndef __cplusplus static const struct rte_flow_item_vxlan rte_flow_item_vxlan_mask = { - .hdr.vx_vni = RTE_BE32(0xffffff00), /* (0xffffff << 8) */ + .hdr.vni = "\xff\xff\xff", }; #endif @@ -1204,18 +1204,28 @@ static const struct rte_flow_item_geneve rte_flow_item_geneve_mask = { * * Matches a VXLAN-GPE header. */ +RTE_STD_C11 struct rte_flow_item_vxlan_gpe { - uint8_t flags; /**< Normally 0x0c (I and P flags). */ - uint8_t rsvd0[2]; /**< Reserved, normally 0x0000. */ - uint8_t protocol; /**< Protocol type. */ - uint8_t vni[3]; /**< VXLAN identifier. */ - uint8_t rsvd1; /**< Reserved, normally 0x00. */ + union { + struct { + /* + * These are old fields kept for compatibility. + * Please prefer hdr field below. + */ + uint8_t flags; /**< Normally 0x0c (I and P flags). */ + uint8_t rsvd0[2]; /**< Reserved, normally 0x0000. */ + uint8_t protocol; /**< Protocol type. */ + uint8_t vni[3]; /**< VXLAN identifier. */ + uint8_t rsvd1; /**< Reserved, normally 0x00. */ + }; + struct rte_vxlan_gpe_hdr hdr; + }; }; /** Default mask for RTE_FLOW_ITEM_TYPE_VXLAN_GPE. */ #ifndef __cplusplus static const struct rte_flow_item_vxlan_gpe rte_flow_item_vxlan_gpe_mask = { - .vni = "\xff\xff\xff", + .hdr.vni = "\xff\xff\xff", }; #endif From patchwork Tue Oct 25 21:44:06 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Thomas Monjalon X-Patchwork-Id: 119121 X-Patchwork-Delegate: ferruh.yigit@amd.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id B6EF3A0544; Tue, 25 Oct 2022 23:45:14 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 21AE942C51; Tue, 25 Oct 2022 23:45:00 +0200 (CEST) Received: from out3-smtp.messagingengine.com (out3-smtp.messagingengine.com [66.111.4.27]) by mails.dpdk.org (Postfix) with ESMTP id 0B3DE42C75 for ; Tue, 25 Oct 2022 23:44:58 +0200 (CEST) Received: from compute2.internal (compute2.nyi.internal [10.202.2.46]) by mailout.nyi.internal (Postfix) with ESMTP id BD17F5C01AC; Tue, 25 Oct 2022 17:44:57 -0400 (EDT) Received: from mailfrontend1 ([10.202.2.162]) by compute2.internal (MEProxy); Tue, 25 Oct 2022 17:44:57 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=monjalon.net; h= cc:cc:content-transfer-encoding:date:date:from:from:in-reply-to :in-reply-to:message-id:mime-version:references:reply-to:sender :subject:subject:to:to; s=fm3; t=1666734297; x=1666820697; bh=IV VtQhy2Cq8xxoRMsKtVjmdHVW//XVe0x0ktVGvwQ1s=; b=avCM6qxRbyYGll9zNU H/o7ICYgwcFuGQNSCw2bq0io/pgHoVqXs0Atn8rzrl1HSPX/tzf+DvbVMoVWsXPk ZgovUAvjYqwyUFewP1LGr2KwMI6+1I66E4IxhXmtxO+x2xW3KC/D7Hmnu12oSUgw VRly55h9rwW8tGaeHRq+JYhCnpzS2l85c0qM/wfhTGL8p1t62des18gBHQuiTSnZ tUq1LNTYIxxkwTSHZY2HDcM96GnDIpAx5wdqxVdBmtBvsLSnn2YmQiNhk7j5omi/ yjVy+rVq2zYp67hqyKLBW//j2qgGbDhHzTbkVVNS6Nvm/KtZpLGroqIokEB/pe2U QetQ== DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=cc:cc:content-transfer-encoding:date:date :feedback-id:feedback-id:from:from:in-reply-to:in-reply-to :message-id:mime-version:references:reply-to:sender:subject :subject:to:to:x-me-proxy:x-me-proxy:x-me-sender:x-me-sender :x-sasl-enc; s=fm3; t=1666734297; x=1666820697; bh=IVVtQhy2Cq8xx oRMsKtVjmdHVW//XVe0x0ktVGvwQ1s=; b=JJv3W9vzwgbWulxVzTLtD/pKCrxxQ sWadCkhrpH6rkA79iJEw6TPIv4/Z8Rk4rA3bG8a/EY8SjAyPvCsE1ZMHM/r/BoDp WsUtmeh1pPIma/wDHxBHqStmI3d7USOUW9BMtFFBVnWmIAdMpnuRwMrab2P5Xq1z pgrCQNGnpynm8ZBm2ZhHDnIIOomi1mTa5ZqCAExplfZStJ8r8ZWpTbhQPWJj/Sg0 8qfiOE90vfb+v0CspUW4jnMczQybuFXyQ3C7r53MWpliF+6NKqF5GOL8SnNKBmRm n/NRrRsNmdPal90/lTeJVxBB8vRRUt/sAypbkuZzPTlzuRbLlTf+bJbAA== X-ME-Sender: X-ME-Received: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgedvgedrtddugddtvdcutefuodetggdotefrodftvf curfhrohhfihhlvgemucfhrghsthforghilhdpqfgfvfdpuffrtefokffrpgfnqfghnecu uegrihhlohhuthemuceftddtnecusecvtfgvtghiphhivghnthhsucdlqddutddtmdenuc fjughrpefhvfevufffkffojghfggfgsedtkeertdertddtnecuhfhrohhmpefvhhhomhgr shcuofhonhhjrghlohhnuceothhhohhmrghssehmohhnjhgrlhhonhdrnhgvtheqnecugg ftrfgrthhtvghrnhepvdejhfdugeehvddtieejieegteeuudfgjeeukeeiledthfetveek hefhieelhfdtnecuvehluhhsthgvrhfuihiivgepudenucfrrghrrghmpehmrghilhhfrh homhepthhhohhmrghssehmohhnjhgrlhhonhdrnhgvth X-ME-Proxy: Feedback-ID: i47234305:Fastmail Received: by mail.messagingengine.com (Postfix) with ESMTPA; Tue, 25 Oct 2022 17:44:56 -0400 (EDT) From: Thomas Monjalon To: dev@dpdk.org Cc: ferruh.yigit@amd.com, andrew.rybchenko@oktetlabs.ru, Wisam Jaddo , Ori Kam , Aman Singh , Yuying Zhang , Ajit Khaparde , Somnath Kotur , Hemant Agrawal , Sachin Saxena , Matan Azrad , Viacheslav Ovsiienko Subject: [PATCH 4/8] ethdev: use GRE protocol struct for flow matching Date: Tue, 25 Oct 2022 23:44:06 +0200 Message-Id: <20221025214410.715864-5-thomas@monjalon.net> X-Mailer: git-send-email 2.36.1 In-Reply-To: <20221025214410.715864-1-thomas@monjalon.net> References: <20221025214410.715864-1-thomas@monjalon.net> MIME-Version: 1.0 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org As announced in the deprecation notice, flow item structures should re-use the protocol header definitions from the directory lib/net/. The protocol struct is added in an unnamed union, keeping old field names. The GRE header struct members are used in apps and drivers instead of the redundant fields in the flow items. Signed-off-by: Thomas Monjalon --- app/test-flow-perf/items_gen.c | 4 ++-- app/test-pmd/cmdline_flow.c | 6 +++--- doc/guides/prog_guide/rte_flow.rst | 6 +----- doc/guides/rel_notes/deprecation.rst | 1 - drivers/net/bnxt/tf_ulp/ulp_rte_parser.c | 12 +++-------- drivers/net/dpaa2/dpaa2_flow.c | 12 +++++------ drivers/net/mlx5/mlx5_flow.c | 22 +++++++++----------- drivers/net/mlx5/mlx5_flow_dv.c | 26 +++++++++++++----------- drivers/net/mlx5/mlx5_flow_verbs.c | 8 ++++---- lib/ethdev/rte_flow.h | 24 +++++++++++++++------- 10 files changed, 60 insertions(+), 61 deletions(-) diff --git a/app/test-flow-perf/items_gen.c b/app/test-flow-perf/items_gen.c index a58245239b..0f19e5e536 100644 --- a/app/test-flow-perf/items_gen.c +++ b/app/test-flow-perf/items_gen.c @@ -173,10 +173,10 @@ add_gre(struct rte_flow_item *items, __rte_unused struct additional_para para) { static struct rte_flow_item_gre gre_spec = { - .protocol = RTE_BE16(RTE_ETHER_TYPE_TEB), + .hdr.proto = RTE_BE16(RTE_ETHER_TYPE_TEB), }; static struct rte_flow_item_gre gre_mask = { - .protocol = RTE_BE16(0xffff), + .hdr.proto = RTE_BE16(0xffff), }; items[items_counter].type = RTE_FLOW_ITEM_TYPE_GRE; diff --git a/app/test-pmd/cmdline_flow.c b/app/test-pmd/cmdline_flow.c index fcbd0a2534..3c2d090a08 100644 --- a/app/test-pmd/cmdline_flow.c +++ b/app/test-pmd/cmdline_flow.c @@ -4037,7 +4037,7 @@ static const struct token token_list[] = { .next = NEXT(item_gre, NEXT_ENTRY(COMMON_UNSIGNED), item_param), .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_gre, - protocol)), + hdr.proto)), }, [ITEM_GRE_C_RSVD0_VER] = { .name = "c_rsvd0_ver", @@ -7752,7 +7752,7 @@ parse_vc_action_mplsogre_encap(struct context *ctx, const struct token *token, }, }; struct rte_flow_item_gre gre = { - .protocol = rte_cpu_to_be_16(ETHER_TYPE_MPLS_UNICAST), + .hdr.proto = rte_cpu_to_be_16(ETHER_TYPE_MPLS_UNICAST), }; struct rte_flow_item_mpls mpls = { .ttl = 0, @@ -7850,7 +7850,7 @@ parse_vc_action_mplsogre_decap(struct context *ctx, const struct token *token, }, }; struct rte_flow_item_gre gre = { - .protocol = rte_cpu_to_be_16(ETHER_TYPE_MPLS_UNICAST), + .hdr.proto = rte_cpu_to_be_16(ETHER_TYPE_MPLS_UNICAST), }; struct rte_flow_item_mpls mpls; uint8_t *header; diff --git a/doc/guides/prog_guide/rte_flow.rst b/doc/guides/prog_guide/rte_flow.rst index 92d3168d39..b6ffb03b01 100644 --- a/doc/guides/prog_guide/rte_flow.rst +++ b/doc/guides/prog_guide/rte_flow.rst @@ -980,8 +980,7 @@ Item: ``GRE`` Matches a GRE header. -- ``c_rsvd0_ver``: checksum, reserved 0 and version. -- ``protocol``: protocol type. +- ``hdr``: header definition (``rte_gre.h``). - Default ``mask`` matches protocol only. Item: ``GRE_KEY`` @@ -1000,9 +999,6 @@ Item: ``GRE_OPTION`` Matches a GRE optional fields (checksum/key/sequence). This should be preceded by item ``GRE``. -- ``checksum``: checksum. -- ``key``: key. -- ``sequence``: sequence. - The items in GRE_OPTION do not change bit flags(c_bit/k_bit/s_bit) in GRE item. The bit flags need be set with GRE item by application. When the items present, the corresponding bits in GRE spec and mask should be set "1" by diff --git a/doc/guides/rel_notes/deprecation.rst b/doc/guides/rel_notes/deprecation.rst index 52c43bb652..8e7af28318 100644 --- a/doc/guides/rel_notes/deprecation.rst +++ b/doc/guides/rel_notes/deprecation.rst @@ -70,7 +70,6 @@ Deprecation Notices - ``rte_flow_item_e_tag`` - ``rte_flow_item_geneve`` - ``rte_flow_item_geneve_opt`` - - ``rte_flow_item_gre`` - ``rte_flow_item_gtp`` - ``rte_flow_item_icmp6`` - ``rte_flow_item_icmp6_nd_na`` diff --git a/drivers/net/bnxt/tf_ulp/ulp_rte_parser.c b/drivers/net/bnxt/tf_ulp/ulp_rte_parser.c index 80869b79c3..280ddc0d94 100644 --- a/drivers/net/bnxt/tf_ulp/ulp_rte_parser.c +++ b/drivers/net/bnxt/tf_ulp/ulp_rte_parser.c @@ -1461,16 +1461,10 @@ ulp_rte_gre_hdr_handler(const struct rte_flow_item *item, return BNXT_TF_RC_ERROR; } - size = sizeof(((struct rte_flow_item_gre *)NULL)->c_rsvd0_ver); + size = sizeof(((struct rte_flow_item_gre *)NULL)->hdr.proto); ulp_rte_prsr_fld_mask(params, &idx, size, - ulp_deference_struct(gre_spec, c_rsvd0_ver), - ulp_deference_struct(gre_mask, c_rsvd0_ver), - ULP_PRSR_ACT_DEFAULT); - - size = sizeof(((struct rte_flow_item_gre *)NULL)->protocol); - ulp_rte_prsr_fld_mask(params, &idx, size, - ulp_deference_struct(gre_spec, protocol), - ulp_deference_struct(gre_mask, protocol), + ulp_deference_struct(gre_spec, hdr.proto), + ulp_deference_struct(gre_mask, hdr.proto), ULP_PRSR_ACT_DEFAULT); /* Update the hdr_bitmap with GRE */ diff --git a/drivers/net/dpaa2/dpaa2_flow.c b/drivers/net/dpaa2/dpaa2_flow.c index eec7e60650..8a6d44da48 100644 --- a/drivers/net/dpaa2/dpaa2_flow.c +++ b/drivers/net/dpaa2/dpaa2_flow.c @@ -154,7 +154,7 @@ static const struct rte_flow_item_sctp dpaa2_flow_item_sctp_mask = { }; static const struct rte_flow_item_gre dpaa2_flow_item_gre_mask = { - .protocol = RTE_BE16(0xffff), + .hdr.proto = RTE_BE16(0xffff), }; #endif @@ -2792,7 +2792,7 @@ dpaa2_configure_flow_gre(struct rte_flow *flow, return -1; } - if (!mask->protocol) + if (!mask->hdr.proto) return 0; index = dpaa2_flow_extract_search( @@ -2841,8 +2841,8 @@ dpaa2_configure_flow_gre(struct rte_flow *flow, &flow->qos_rule, NET_PROT_GRE, NH_FLD_GRE_TYPE, - &spec->protocol, - &mask->protocol, + &spec->hdr.proto, + &mask->hdr.proto, sizeof(rte_be16_t)); if (ret) { DPAA2_PMD_ERR( @@ -2855,8 +2855,8 @@ dpaa2_configure_flow_gre(struct rte_flow *flow, &flow->fs_rule, NET_PROT_GRE, NH_FLD_GRE_TYPE, - &spec->protocol, - &mask->protocol, + &spec->hdr.proto, + &mask->hdr.proto, sizeof(rte_be16_t)); if (ret) { DPAA2_PMD_ERR( diff --git a/drivers/net/mlx5/mlx5_flow.c b/drivers/net/mlx5/mlx5_flow.c index 10f6abeb07..b4a560c18a 100644 --- a/drivers/net/mlx5/mlx5_flow.c +++ b/drivers/net/mlx5/mlx5_flow.c @@ -304,7 +304,7 @@ mlx5_flow_expand_rss_item_complete(const struct rte_flow_item *item) ret = mlx5_ethertype_to_item_type(spec, mask, true); break; case RTE_FLOW_ITEM_TYPE_GRE: - MLX5_XSET_ITEM_MASK_SPEC(gre, protocol); + MLX5_XSET_ITEM_MASK_SPEC(gre, hdr.proto); ret = mlx5_ethertype_to_item_type(spec, mask, true); break; case RTE_FLOW_ITEM_TYPE_VXLAN_GPE: @@ -2987,8 +2987,7 @@ mlx5_flow_validate_item_gre_key(const struct rte_flow_item *item, if (!gre_mask) gre_mask = &rte_flow_item_gre_mask; gre_spec = gre_item->spec; - if (gre_spec && (gre_mask->c_rsvd0_ver & RTE_BE16(0x2000)) && - !(gre_spec->c_rsvd0_ver & RTE_BE16(0x2000))) + if (gre_spec && (gre_mask->hdr.k) && !(gre_spec->hdr.k)) return rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, "Key bit must be on"); @@ -3063,21 +3062,18 @@ mlx5_flow_validate_item_gre_option(struct rte_eth_dev *dev, if (!gre_mask) gre_mask = &rte_flow_item_gre_mask; if (mask->checksum_rsvd.checksum) - if (gre_spec && (gre_mask->c_rsvd0_ver & RTE_BE16(0x8000)) && - !(gre_spec->c_rsvd0_ver & RTE_BE16(0x8000))) + if (gre_spec && (gre_mask->hdr.c) && !(gre_spec->hdr.c)) return rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, "Checksum bit must be on"); if (mask->key.key) - if (gre_spec && (gre_mask->c_rsvd0_ver & RTE_BE16(0x2000)) && - !(gre_spec->c_rsvd0_ver & RTE_BE16(0x2000))) + if (gre_spec && (gre_mask->hdr.k) && !(gre_spec->hdr.k)) return rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, "Key bit must be on"); if (mask->sequence.sequence) - if (gre_spec && (gre_mask->c_rsvd0_ver & RTE_BE16(0x1000)) && - !(gre_spec->c_rsvd0_ver & RTE_BE16(0x1000))) + if (gre_spec && (gre_mask->hdr.s) && !(gre_spec->hdr.s)) return rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, @@ -3128,8 +3124,10 @@ mlx5_flow_validate_item_gre(const struct rte_flow_item *item, const struct rte_flow_item_gre *mask = item->mask; int ret; const struct rte_flow_item_gre nic_mask = { - .c_rsvd0_ver = RTE_BE16(0xB000), - .protocol = RTE_BE16(UINT16_MAX), + .hdr.c = 1, + .hdr.k = 1, + .hdr.s = 1, + .hdr.proto = RTE_BE16(UINT16_MAX), }; if (target_protocol != 0xff && target_protocol != IPPROTO_GRE) @@ -3157,7 +3155,7 @@ mlx5_flow_validate_item_gre(const struct rte_flow_item *item, return ret; #ifndef HAVE_MLX5DV_DR #ifndef HAVE_IBV_DEVICE_MPLS_SUPPORT - if (spec && (spec->protocol & mask->protocol)) + if (spec && (spec->hdr.proto & mask->hdr.proto)) return rte_flow_error_set(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_ITEM, item, "without MPLS support the" diff --git a/drivers/net/mlx5/mlx5_flow_dv.c b/drivers/net/mlx5/mlx5_flow_dv.c index a06b6e1860..f70018be50 100644 --- a/drivers/net/mlx5/mlx5_flow_dv.c +++ b/drivers/net/mlx5/mlx5_flow_dv.c @@ -9019,8 +9019,8 @@ flow_dv_translate_item_gre(void *matcher, void *key, if (!gre_m) gre_m = &rte_flow_item_gre_mask; } - gre_crks_rsvd0_ver_m.value = rte_be_to_cpu_16(gre_m->c_rsvd0_ver); - gre_crks_rsvd0_ver_v.value = rte_be_to_cpu_16(gre_v->c_rsvd0_ver); + gre_crks_rsvd0_ver_m.value = rte_be_to_cpu_16(*(const uint16_t*)&gre_m->hdr); + gre_crks_rsvd0_ver_v.value = rte_be_to_cpu_16(*(const uint16_t*)&gre_v->hdr); MLX5_SET(fte_match_set_misc, misc_m, gre_c_present, gre_crks_rsvd0_ver_m.c_present); MLX5_SET(fte_match_set_misc, misc_v, gre_c_present, @@ -9036,8 +9036,8 @@ flow_dv_translate_item_gre(void *matcher, void *key, MLX5_SET(fte_match_set_misc, misc_v, gre_s_present, gre_crks_rsvd0_ver_v.s_present & gre_crks_rsvd0_ver_m.s_present); - protocol_m = rte_be_to_cpu_16(gre_m->protocol); - protocol_v = rte_be_to_cpu_16(gre_v->protocol); + protocol_m = rte_be_to_cpu_16(gre_m->hdr.proto); + protocol_v = rte_be_to_cpu_16(gre_v->hdr.proto); if (!protocol_m) { /* Force next protocol to prevent matchers duplication */ protocol_v = mlx5_translate_tunnel_etypes(pattern_flags); @@ -9101,8 +9101,8 @@ flow_dv_translate_item_gre_option(void *matcher, void *key, if (!gre_m) gre_m = &rte_flow_item_gre_mask; } - protocol_v = gre_v->protocol; - protocol_m = gre_m->protocol; + protocol_v = gre_v->hdr.proto; + protocol_m = gre_m->hdr.proto; if (!protocol_m) { /* Force next protocol to prevent matchers duplication */ uint16_t ether_type = @@ -9112,8 +9112,8 @@ flow_dv_translate_item_gre_option(void *matcher, void *key, protocol_m = UINT16_MAX; } } - c_rsvd0_ver_v = gre_v->c_rsvd0_ver; - c_rsvd0_ver_m = gre_m->c_rsvd0_ver; + c_rsvd0_ver_v = *(const uint16_t*)&gre_v->hdr; + c_rsvd0_ver_m = *(const uint16_t*)&gre_m->hdr; if (option_m->sequence.sequence) { c_rsvd0_ver_v |= RTE_BE16(0x1000); c_rsvd0_ver_m |= RTE_BE16(0x1000); @@ -9183,12 +9183,14 @@ flow_dv_translate_item_nvgre(void *matcher, void *key, /* For NVGRE, GRE header fields must be set with defined values. */ const struct rte_flow_item_gre gre_spec = { - .c_rsvd0_ver = RTE_BE16(0x2000), - .protocol = RTE_BE16(RTE_ETHER_TYPE_TEB) + .hdr.k = 1, + .hdr.proto = RTE_BE16(RTE_ETHER_TYPE_TEB) }; const struct rte_flow_item_gre gre_mask = { - .c_rsvd0_ver = RTE_BE16(0xB000), - .protocol = RTE_BE16(UINT16_MAX), + .hdr.c = 1, + .hdr.k = 1, + .hdr.s = 1, + .hdr.proto = RTE_BE16(UINT16_MAX), }; const struct rte_flow_item gre_item = { .spec = &gre_spec, diff --git a/drivers/net/mlx5/mlx5_flow_verbs.c b/drivers/net/mlx5/mlx5_flow_verbs.c index facab1b313..46f961cbb2 100644 --- a/drivers/net/mlx5/mlx5_flow_verbs.c +++ b/drivers/net/mlx5/mlx5_flow_verbs.c @@ -959,10 +959,10 @@ flow_verbs_translate_item_gre(struct mlx5_flow *dev_flow, if (!mask) mask = &rte_flow_item_gre_mask; } - tunnel.val.c_ks_res0_ver = spec->c_rsvd0_ver; - tunnel.val.protocol = spec->protocol; - tunnel.mask.c_ks_res0_ver = mask->c_rsvd0_ver; - tunnel.mask.protocol = mask->protocol; + tunnel.val.c_ks_res0_ver = *(const uint16_t*)&spec->hdr; + tunnel.val.protocol = spec->hdr.proto; + tunnel.mask.c_ks_res0_ver = *(const uint16_t*)&mask->hdr; + tunnel.mask.protocol = mask->hdr.proto; /* Remove unwanted bits from values. */ tunnel.val.c_ks_res0_ver &= tunnel.mask.c_ks_res0_ver; tunnel.val.key &= tunnel.mask.key; diff --git a/lib/ethdev/rte_flow.h b/lib/ethdev/rte_flow.h index 6045a352ae..fd9be56e31 100644 --- a/lib/ethdev/rte_flow.h +++ b/lib/ethdev/rte_flow.h @@ -1069,19 +1069,29 @@ static const struct rte_flow_item_mpls rte_flow_item_mpls_mask = { * * Matches a GRE header. */ +RTE_STD_C11 struct rte_flow_item_gre { - /** - * Checksum (1b), reserved 0 (12b), version (3b). - * Refer to RFC 2784. - */ - rte_be16_t c_rsvd0_ver; - rte_be16_t protocol; /**< Protocol type. */ + union { + struct { + /* + * These are old fields kept for compatibility. + * Please prefer hdr field below. + */ + /** + * Checksum (1b), reserved 0 (12b), version (3b). + * Refer to RFC 2784. + */ + rte_be16_t c_rsvd0_ver; + rte_be16_t protocol; /**< Protocol type. */ + }; + struct rte_gre_hdr hdr; /**< GRE header definition. */ + }; }; /** Default mask for RTE_FLOW_ITEM_TYPE_GRE. */ #ifndef __cplusplus static const struct rte_flow_item_gre rte_flow_item_gre_mask = { - .protocol = RTE_BE16(0xffff), + .hdr.proto = RTE_BE16(UINT16_MAX), }; #endif From patchwork Tue Oct 25 21:44:07 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Thomas Monjalon X-Patchwork-Id: 119122 X-Patchwork-Delegate: ferruh.yigit@amd.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 7D40AA0544; Tue, 25 Oct 2022 23:45:21 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 1FFA742C6E; Tue, 25 Oct 2022 23:45:04 +0200 (CEST) Received: from out3-smtp.messagingengine.com (out3-smtp.messagingengine.com [66.111.4.27]) by mails.dpdk.org (Postfix) with ESMTP id 362D442C70 for ; Tue, 25 Oct 2022 23:45:02 +0200 (CEST) Received: from compute2.internal (compute2.nyi.internal [10.202.2.46]) by mailout.nyi.internal (Postfix) with ESMTP id E81CE5C00BD; Tue, 25 Oct 2022 17:45:01 -0400 (EDT) Received: from mailfrontend1 ([10.202.2.162]) by compute2.internal (MEProxy); Tue, 25 Oct 2022 17:45:01 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=monjalon.net; h= cc:cc:content-transfer-encoding:date:date:from:from:in-reply-to :in-reply-to:message-id:mime-version:references:reply-to:sender :subject:subject:to:to; s=fm3; t=1666734301; x=1666820701; bh=F3 pIWmOWqbHZsQxVM/VXoeImDkHuuFQxlWwiwvc9BOY=; b=lYeT2JIEJVb/YRL9eY 4DWIVjAV/FAB+lh1xzfq6uYATEzTrAr4u65uccPHMmbOkToz5HeU0NRhv0Yaj5RG cq2m5u0MHa6q5/922ennGojwmRWletFnfNCj2ZkjCO4it2YAx++mqSJ5D9G2G2Cc /NhAe6t3GuGdjPL/aK2XG7qOdVWSit2PBmpDJ97FEvkakeO5IAUaB36itA0Eu4nG 2VfQlIZxsFU7GCGJ9RtQcfXUiSHQ0C82Yewmv4rSADWi3YpUmfdgPE5owqswc+jC T0n1om37RMCLyuZk2eqz7jSk6mzyUyBYCz3UqAaIefwgtEmkhprQWSsmLK0yrUSd wTow== DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=cc:cc:content-transfer-encoding:date:date :feedback-id:feedback-id:from:from:in-reply-to:in-reply-to :message-id:mime-version:references:reply-to:sender:subject :subject:to:to:x-me-proxy:x-me-proxy:x-me-sender:x-me-sender :x-sasl-enc; s=fm3; t=1666734301; x=1666820701; bh=F3pIWmOWqbHZs QxVM/VXoeImDkHuuFQxlWwiwvc9BOY=; b=kC/pGm/XKE2TQQEecNToVscfmywpS XjapwTA4Q2qVaxOHPCW1uRdJIBw/Q5shmrQkKeIKEuuFHqNCo/hDYeaSqaqGJjUa OrUL1CkibSyaZISmz3Ja9WfJACae5uzcXS7a+V31byIs9rQ+dL7d6XEPnUJVPbtE aAoJdX31WFgbVRa4B9ohVw26Jh3na+xxf2ym9KsR1j6322us/fSjq8rXwGs8OMM/ 2SxVkxi8nwrETVNZS6BQ6TE5OBWfTtULA4vmpNZWBEpr64UUtTQENOn3Hr1kwNGt WUOfytfdPqNr7I9HzEr1CooB0HGxF/VgcNK1dNZAMtkJHZkDQ4+49PVuw== X-ME-Sender: X-ME-Received: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgedvgedrtddugddtvdcutefuodetggdotefrodftvf curfhrohhfihhlvgemucfhrghsthforghilhdpqfgfvfdpuffrtefokffrpgfnqfghnecu uegrihhlohhuthemuceftddtnecusecvtfgvtghiphhivghnthhsucdlqddutddtmdenuc fjughrpefhvfevufffkffojghfggfgsedtkeertdertddtnecuhfhrohhmpefvhhhomhgr shcuofhonhhjrghlohhnuceothhhohhmrghssehmohhnjhgrlhhonhdrnhgvtheqnecugg ftrfgrthhtvghrnhepvdejhfdugeehvddtieejieegteeuudfgjeeukeeiledthfetveek hefhieelhfdtnecuvehluhhsthgvrhfuihiivgepvdenucfrrghrrghmpehmrghilhhfrh homhepthhhohhmrghssehmohhnjhgrlhhonhdrnhgvth X-ME-Proxy: Feedback-ID: i47234305:Fastmail Received: by mail.messagingengine.com (Postfix) with ESMTPA; Tue, 25 Oct 2022 17:45:00 -0400 (EDT) From: Thomas Monjalon To: dev@dpdk.org Cc: ferruh.yigit@amd.com, andrew.rybchenko@oktetlabs.ru, Wisam Jaddo , Ori Kam , Aman Singh , Yuying Zhang , Beilei Xing , Jingjing Wu , Qiming Yang , Qi Zhang , Matan Azrad , Viacheslav Ovsiienko Subject: [PATCH 5/8] ethdev: use GTP protocol struct for flow matching Date: Tue, 25 Oct 2022 23:44:07 +0200 Message-Id: <20221025214410.715864-6-thomas@monjalon.net> X-Mailer: git-send-email 2.36.1 In-Reply-To: <20221025214410.715864-1-thomas@monjalon.net> References: <20221025214410.715864-1-thomas@monjalon.net> MIME-Version: 1.0 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org As announced in the deprecation notice, flow item structures should re-use the protocol header definitions from the directory lib/net/. The protocol struct is added in an unnamed union, keeping old field names. The GTP header struct members are used in apps and drivers instead of the redundant fields in the flow items. Signed-off-by: Thomas Monjalon --- app/test-flow-perf/items_gen.c | 4 ++-- app/test-pmd/cmdline_flow.c | 8 +++---- doc/guides/prog_guide/rte_flow.rst | 10 ++------- doc/guides/rel_notes/deprecation.rst | 1 - drivers/net/i40e/i40e_fdir.c | 14 ++++++------ drivers/net/i40e/i40e_flow.c | 20 ++++++++--------- drivers/net/iavf/iavf_fdir.c | 8 +++---- drivers/net/ice/ice_fdir_filter.c | 10 ++++----- drivers/net/ice/ice_switch_filter.c | 12 +++++------ drivers/net/mlx5/mlx5_flow_dv.c | 24 ++++++++++----------- lib/ethdev/rte_flow.h | 32 ++++++++++++++++++---------- 11 files changed, 73 insertions(+), 70 deletions(-) diff --git a/app/test-flow-perf/items_gen.c b/app/test-flow-perf/items_gen.c index 0f19e5e536..55eb6f5cf0 100644 --- a/app/test-flow-perf/items_gen.c +++ b/app/test-flow-perf/items_gen.c @@ -213,10 +213,10 @@ add_gtp(struct rte_flow_item *items, __rte_unused struct additional_para para) { static struct rte_flow_item_gtp gtp_spec = { - .teid = RTE_BE32(TEID_VALUE), + .hdr.teid = RTE_BE32(TEID_VALUE), }; static struct rte_flow_item_gtp gtp_mask = { - .teid = RTE_BE32(0xffffffff), + .hdr.teid = RTE_BE32(0xffffffff), }; items[items_counter].type = RTE_FLOW_ITEM_TYPE_GTP; diff --git a/app/test-pmd/cmdline_flow.c b/app/test-pmd/cmdline_flow.c index 3c2d090a08..90da247eaf 100644 --- a/app/test-pmd/cmdline_flow.c +++ b/app/test-pmd/cmdline_flow.c @@ -4103,19 +4103,19 @@ static const struct token token_list[] = { .help = "GTP flags", .next = NEXT(item_gtp, NEXT_ENTRY(COMMON_UNSIGNED), item_param), .args = ARGS(ARGS_ENTRY(struct rte_flow_item_gtp, - v_pt_rsv_flags)), + hdr.gtp_hdr_info)), }, [ITEM_GTP_MSG_TYPE] = { .name = "msg_type", .help = "GTP message type", .next = NEXT(item_gtp, NEXT_ENTRY(COMMON_UNSIGNED), item_param), - .args = ARGS(ARGS_ENTRY(struct rte_flow_item_gtp, msg_type)), + .args = ARGS(ARGS_ENTRY(struct rte_flow_item_gtp, hdr.msg_type)), }, [ITEM_GTP_TEID] = { .name = "teid", .help = "tunnel endpoint identifier", .next = NEXT(item_gtp, NEXT_ENTRY(COMMON_UNSIGNED), item_param), - .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_gtp, teid)), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_gtp, hdr.teid)), }, [ITEM_GTPC] = { .name = "gtpc", @@ -11135,7 +11135,7 @@ cmd_set_raw_parsed(const struct buffer *in) goto error; } gtp = item->spec; - if ((gtp->v_pt_rsv_flags & 0x07) != 0x04) { + if (gtp->hdr.s == 1 || gtp->hdr.pn == 1) { /* Only E flag should be set. */ fprintf(stderr, "Error - GTP unsupported flags\n"); diff --git a/doc/guides/prog_guide/rte_flow.rst b/doc/guides/prog_guide/rte_flow.rst index b6ffb03b01..e8512e0a03 100644 --- a/doc/guides/prog_guide/rte_flow.rst +++ b/doc/guides/prog_guide/rte_flow.rst @@ -1064,12 +1064,7 @@ Note: GTP, GTPC and GTPU use the same structure. GTPC and GTPU item are defined for a user-friendly API when creating GTP-C and GTP-U flow rules. -- ``v_pt_rsv_flags``: version (3b), protocol type (1b), reserved (1b), - extension header flag (1b), sequence number flag (1b), N-PDU number - flag (1b). -- ``msg_type``: message type. -- ``msg_len``: message length. -- ``teid``: tunnel endpoint identifier. +- ``hdr``: header definition (``rte_gtp.h``). - Default ``mask`` matches teid only. Item: ``ESP`` @@ -1235,8 +1230,7 @@ Item: ``GTP_PSC`` Matches a GTP PDU extension header with type 0x85. -- ``pdu_type``: PDU type. -- ``qfi``: QoS flow identifier. +- ``hdr``: header definition (``rte_gtp.h``). - Default ``mask`` matches QFI only. Item: ``PPPOES``, ``PPPOED`` diff --git a/doc/guides/rel_notes/deprecation.rst b/doc/guides/rel_notes/deprecation.rst index 8e7af28318..b4b97d3165 100644 --- a/doc/guides/rel_notes/deprecation.rst +++ b/doc/guides/rel_notes/deprecation.rst @@ -70,7 +70,6 @@ Deprecation Notices - ``rte_flow_item_e_tag`` - ``rte_flow_item_geneve`` - ``rte_flow_item_geneve_opt`` - - ``rte_flow_item_gtp`` - ``rte_flow_item_icmp6`` - ``rte_flow_item_icmp6_nd_na`` - ``rte_flow_item_icmp6_nd_ns`` diff --git a/drivers/net/i40e/i40e_fdir.c b/drivers/net/i40e/i40e_fdir.c index afcaa593eb..47f79ecf11 100644 --- a/drivers/net/i40e/i40e_fdir.c +++ b/drivers/net/i40e/i40e_fdir.c @@ -761,26 +761,26 @@ i40e_flow_fdir_construct_pkt(struct i40e_pf *pf, gtp = (struct rte_flow_item_gtp *) ((unsigned char *)udp + sizeof(struct rte_udp_hdr)); - gtp->msg_len = + gtp->hdr.plen = rte_cpu_to_be_16(I40E_FDIR_GTP_DEFAULT_LEN); - gtp->teid = fdir_input->flow.gtp_flow.teid; - gtp->msg_type = I40E_FDIR_GTP_MSG_TYPE_0X01; + gtp->hdr.teid = fdir_input->flow.gtp_flow.teid; + gtp->hdr.msg_type = I40E_FDIR_GTP_MSG_TYPE_0X01; /* GTP-C message type is not supported. */ if (cus_pctype->index == I40E_CUSTOMIZED_GTPC) { udp->dst_port = rte_cpu_to_be_16(I40E_FDIR_GTPC_DST_PORT); - gtp->v_pt_rsv_flags = + gtp->hdr.gtp_hdr_info = I40E_FDIR_GTP_VER_FLAG_0X32; } else { udp->dst_port = rte_cpu_to_be_16(I40E_FDIR_GTPU_DST_PORT); - gtp->v_pt_rsv_flags = + gtp->hdr.gtp_hdr_info = I40E_FDIR_GTP_VER_FLAG_0X30; } if (cus_pctype->index == I40E_CUSTOMIZED_GTPU_IPV4) { - gtp->msg_type = I40E_FDIR_GTP_MSG_TYPE_0XFF; + gtp->hdr.msg_type = I40E_FDIR_GTP_MSG_TYPE_0XFF; gtp_ipv4 = (struct rte_ipv4_hdr *) ((unsigned char *)gtp + sizeof(struct rte_flow_item_gtp)); @@ -794,7 +794,7 @@ i40e_flow_fdir_construct_pkt(struct i40e_pf *pf, sizeof(struct rte_ipv4_hdr); } else if (cus_pctype->index == I40E_CUSTOMIZED_GTPU_IPV6) { - gtp->msg_type = I40E_FDIR_GTP_MSG_TYPE_0XFF; + gtp->hdr.msg_type = I40E_FDIR_GTP_MSG_TYPE_0XFF; gtp_ipv6 = (struct rte_ipv6_hdr *) ((unsigned char *)gtp + sizeof(struct rte_flow_item_gtp)); diff --git a/drivers/net/i40e/i40e_flow.c b/drivers/net/i40e/i40e_flow.c index 2855b14fe6..3c550733f2 100644 --- a/drivers/net/i40e/i40e_flow.c +++ b/drivers/net/i40e/i40e_flow.c @@ -2135,10 +2135,10 @@ i40e_flow_parse_fdir_pattern(struct rte_eth_dev *dev, gtp_mask = item->mask; if (gtp_spec && gtp_mask) { - if (gtp_mask->v_pt_rsv_flags || - gtp_mask->msg_type || - gtp_mask->msg_len || - gtp_mask->teid != UINT32_MAX) { + if (gtp_mask->hdr.gtp_hdr_info || + gtp_mask->hdr.msg_type || + gtp_mask->hdr.plen || + gtp_mask->hdr.teid != UINT32_MAX) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, @@ -2147,7 +2147,7 @@ i40e_flow_parse_fdir_pattern(struct rte_eth_dev *dev, } filter->input.flow.gtp_flow.teid = - gtp_spec->teid; + gtp_spec->hdr.teid; filter->input.flow_ext.customized_pctype = true; cus_proto = item_type; } @@ -3570,10 +3570,10 @@ i40e_flow_parse_gtp_pattern(struct rte_eth_dev *dev, return -rte_errno; } - if (gtp_mask->v_pt_rsv_flags || - gtp_mask->msg_type || - gtp_mask->msg_len || - gtp_mask->teid != UINT32_MAX) { + if (gtp_mask->hdr.gtp_hdr_info || + gtp_mask->hdr.msg_type || + gtp_mask->hdr.plen || + gtp_mask->hdr.teid != UINT32_MAX) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, @@ -3586,7 +3586,7 @@ i40e_flow_parse_gtp_pattern(struct rte_eth_dev *dev, else if (item_type == RTE_FLOW_ITEM_TYPE_GTPU) filter->tunnel_type = I40E_TUNNEL_TYPE_GTPU; - filter->tenant_id = rte_be_to_cpu_32(gtp_spec->teid); + filter->tenant_id = rte_be_to_cpu_32(gtp_spec->hdr.teid); break; default: diff --git a/drivers/net/iavf/iavf_fdir.c b/drivers/net/iavf/iavf_fdir.c index a6c88cb55b..811a10287b 100644 --- a/drivers/net/iavf/iavf_fdir.c +++ b/drivers/net/iavf/iavf_fdir.c @@ -1277,16 +1277,16 @@ iavf_fdir_parse_pattern(__rte_unused struct iavf_adapter *ad, VIRTCHNL_SET_PROTO_HDR_TYPE(hdr, GTPU_IP); if (gtp_spec && gtp_mask) { - if (gtp_mask->v_pt_rsv_flags || - gtp_mask->msg_type || - gtp_mask->msg_len) { + if (gtp_mask->hdr.gtp_hdr_info || + gtp_mask->hdr.msg_type || + gtp_mask->hdr.plen) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, "Invalid GTP mask"); return -rte_errno; } - if (gtp_mask->teid == UINT32_MAX) { + if (gtp_mask->hdr.teid == UINT32_MAX) { input_set |= IAVF_INSET_GTPU_TEID; VIRTCHNL_ADD_PROTO_HDR_FIELD_BIT(hdr, GTPU_IP, TEID); } diff --git a/drivers/net/ice/ice_fdir_filter.c b/drivers/net/ice/ice_fdir_filter.c index 5d297afc29..480b369af8 100644 --- a/drivers/net/ice/ice_fdir_filter.c +++ b/drivers/net/ice/ice_fdir_filter.c @@ -2341,9 +2341,9 @@ ice_fdir_parse_pattern(__rte_unused struct ice_adapter *ad, if (!(gtp_spec && gtp_mask)) break; - if (gtp_mask->v_pt_rsv_flags || - gtp_mask->msg_type || - gtp_mask->msg_len) { + if (gtp_mask->hdr.gtp_hdr_info || + gtp_mask->hdr.msg_type || + gtp_mask->hdr.plen) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, @@ -2351,10 +2351,10 @@ ice_fdir_parse_pattern(__rte_unused struct ice_adapter *ad, return -rte_errno; } - if (gtp_mask->teid == UINT32_MAX) + if (gtp_mask->hdr.teid == UINT32_MAX) input_set_o |= ICE_INSET_GTPU_TEID; - filter->input.gtpu_data.teid = gtp_spec->teid; + filter->input.gtpu_data.teid = gtp_spec->hdr.teid; break; case RTE_FLOW_ITEM_TYPE_GTP_PSC: tunnel_type = ICE_FDIR_TUNNEL_TYPE_GTPU_EH; diff --git a/drivers/net/ice/ice_switch_filter.c b/drivers/net/ice/ice_switch_filter.c index 7cb20fa0b4..110d8895fe 100644 --- a/drivers/net/ice/ice_switch_filter.c +++ b/drivers/net/ice/ice_switch_filter.c @@ -1405,9 +1405,9 @@ ice_switch_parse_pattern(const struct rte_flow_item pattern[], return false; } if (gtp_spec && gtp_mask) { - if (gtp_mask->v_pt_rsv_flags || - gtp_mask->msg_type || - gtp_mask->msg_len) { + if (gtp_mask->hdr.gtp_hdr_info || + gtp_mask->hdr.msg_type || + gtp_mask->hdr.plen) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, @@ -1415,13 +1415,13 @@ ice_switch_parse_pattern(const struct rte_flow_item pattern[], return false; } input = &outer_input_set; - if (gtp_mask->teid) + if (gtp_mask->hdr.teid) *input |= ICE_INSET_GTPU_TEID; list[t].type = ICE_GTP; list[t].h_u.gtp_hdr.teid = - gtp_spec->teid; + gtp_spec->hdr.teid; list[t].m_u.gtp_hdr.teid = - gtp_mask->teid; + gtp_mask->hdr.teid; input_set_byte += 4; t++; } diff --git a/drivers/net/mlx5/mlx5_flow_dv.c b/drivers/net/mlx5/mlx5_flow_dv.c index f70018be50..5d1ca7d658 100644 --- a/drivers/net/mlx5/mlx5_flow_dv.c +++ b/drivers/net/mlx5/mlx5_flow_dv.c @@ -2391,9 +2391,9 @@ flow_dv_validate_item_gtp(struct rte_eth_dev *dev, const struct rte_flow_item_gtp *spec = item->spec; const struct rte_flow_item_gtp *mask = item->mask; const struct rte_flow_item_gtp nic_mask = { - .v_pt_rsv_flags = MLX5_GTP_FLAGS_MASK, - .msg_type = 0xff, - .teid = RTE_BE32(0xffffffff), + .hdr.gtp_hdr_info = MLX5_GTP_FLAGS_MASK, + .hdr.msg_type = 0xff, + .hdr.teid = RTE_BE32(0xffffffff), }; if (!priv->sh->cdev->config.hca_attr.tunnel_stateless_gtp) @@ -2411,7 +2411,7 @@ flow_dv_validate_item_gtp(struct rte_eth_dev *dev, "no outer UDP layer found"); if (!mask) mask = &rte_flow_item_gtp_mask; - if (spec && spec->v_pt_rsv_flags & ~MLX5_GTP_FLAGS_MASK) + if (spec && spec->hdr.gtp_hdr_info & ~MLX5_GTP_FLAGS_MASK) return rte_flow_error_set(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_ITEM, item, "Match is supported for GTP" @@ -2462,8 +2462,8 @@ flow_dv_validate_item_gtp_psc(const struct rte_flow_item *item, gtp_mask = gtp_item->mask ? gtp_item->mask : &rte_flow_item_gtp_mask; /* GTP spec and E flag is requested to match zero. */ if (gtp_spec && - (gtp_mask->v_pt_rsv_flags & - ~gtp_spec->v_pt_rsv_flags & MLX5_GTP_EXT_HEADER_FLAG)) + (gtp_mask->hdr.gtp_hdr_info & + ~gtp_spec->hdr.gtp_hdr_info & MLX5_GTP_EXT_HEADER_FLAG)) return rte_flow_error_set (error, ENOTSUP, RTE_FLOW_ERROR_TYPE_ITEM, item, "GTP E flag must be 1 to match GTP PSC"); @@ -10298,16 +10298,16 @@ flow_dv_translate_item_gtp(void *matcher, void *key, if (!gtp_m) gtp_m = &rte_flow_item_gtp_mask; MLX5_SET(fte_match_set_misc3, misc3_m, gtpu_msg_flags, - gtp_m->v_pt_rsv_flags); + gtp_m->hdr.gtp_hdr_info); MLX5_SET(fte_match_set_misc3, misc3_v, gtpu_msg_flags, - gtp_v->v_pt_rsv_flags & gtp_m->v_pt_rsv_flags); - MLX5_SET(fte_match_set_misc3, misc3_m, gtpu_msg_type, gtp_m->msg_type); + gtp_v->hdr.gtp_hdr_info & gtp_m->hdr.gtp_hdr_info); + MLX5_SET(fte_match_set_misc3, misc3_m, gtpu_msg_type, gtp_m->hdr.msg_type); MLX5_SET(fte_match_set_misc3, misc3_v, gtpu_msg_type, - gtp_v->msg_type & gtp_m->msg_type); + gtp_v->hdr.msg_type & gtp_m->hdr.msg_type); MLX5_SET(fte_match_set_misc3, misc3_m, gtpu_teid, - rte_be_to_cpu_32(gtp_m->teid)); + rte_be_to_cpu_32(gtp_m->hdr.teid)); MLX5_SET(fte_match_set_misc3, misc3_v, gtpu_teid, - rte_be_to_cpu_32(gtp_v->teid & gtp_m->teid)); + rte_be_to_cpu_32(gtp_v->hdr.teid & gtp_m->hdr.teid)); } /** diff --git a/lib/ethdev/rte_flow.h b/lib/ethdev/rte_flow.h index fd9be56e31..02c6cc9981 100644 --- a/lib/ethdev/rte_flow.h +++ b/lib/ethdev/rte_flow.h @@ -1148,23 +1148,33 @@ static const struct rte_flow_item_fuzzy rte_flow_item_fuzzy_mask = { * * Matches a GTPv1 header. */ +RTE_STD_C11 struct rte_flow_item_gtp { - /** - * Version (3b), protocol type (1b), reserved (1b), - * Extension header flag (1b), - * Sequence number flag (1b), - * N-PDU number flag (1b). - */ - uint8_t v_pt_rsv_flags; - uint8_t msg_type; /**< Message type. */ - rte_be16_t msg_len; /**< Message length. */ - rte_be32_t teid; /**< Tunnel endpoint identifier. */ + union { + struct { + /* + * These are old fields kept for compatibility. + * Please prefer hdr field below. + */ + /** + * Version (3b), protocol type (1b), reserved (1b), + * Extension header flag (1b), + * Sequence number flag (1b), + * N-PDU number flag (1b). + */ + uint8_t v_pt_rsv_flags; + uint8_t msg_type; /**< Message type. */ + rte_be16_t msg_len; /**< Message length. */ + rte_be32_t teid; /**< Tunnel endpoint identifier. */ + }; + struct rte_gtp_hdr hdr; /**< GTP header definition. */ + }; }; /** Default mask for RTE_FLOW_ITEM_TYPE_GTP. */ #ifndef __cplusplus static const struct rte_flow_item_gtp rte_flow_item_gtp_mask = { - .teid = RTE_BE32(0xffffffff), + .hdr.teid = RTE_BE32(UINT32_MAX), }; #endif From patchwork Tue Oct 25 21:44:08 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Thomas Monjalon X-Patchwork-Id: 119123 X-Patchwork-Delegate: ferruh.yigit@amd.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 71D0EA0544; Tue, 25 Oct 2022 23:45:30 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 81BE042C59; Tue, 25 Oct 2022 23:45:07 +0200 (CEST) Received: from out3-smtp.messagingengine.com (out3-smtp.messagingengine.com [66.111.4.27]) by mails.dpdk.org (Postfix) with ESMTP id C81E4410D2 for ; Tue, 25 Oct 2022 23:45:06 +0200 (CEST) Received: from compute2.internal (compute2.nyi.internal [10.202.2.46]) by mailout.nyi.internal (Postfix) with ESMTP id 870805C01AC; Tue, 25 Oct 2022 17:45:06 -0400 (EDT) Received: from mailfrontend1 ([10.202.2.162]) by compute2.internal (MEProxy); Tue, 25 Oct 2022 17:45:06 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=monjalon.net; h= cc:cc:content-transfer-encoding:date:date:from:from:in-reply-to :in-reply-to:message-id:mime-version:references:reply-to:sender :subject:subject:to:to; s=fm3; t=1666734306; x=1666820706; bh=YC Rfc0bL2y7vwVY00aP0rRE5yM+6qksSA7GtoGPvEDo=; b=hNEhONfCHZX5dxFv48 MHiGk+xuTgUaFBhY0InOjE2xvxu5OJU1awBX1k0jRutpq+jaHfgxgZdG2qEnpKco qItwIPnJf2yUHMMREe7A+lWOaYLPXB+JpkCWTDyWE5kiRiwhqzeGnunADnt+j4HB XPw+I7etXv5VbIj4YIUHmvbs9Wxp64XipZEM8rySNxCbSb0hHQCRj8phhCoj/6rF ukriKOWxUh0oLR5F2HPnl4LCs0xjau8AR9qqH7UoUTzQzH9c2gzIJ27Xi75fZFZC l3kH4Y+jG0mWe2EvX2f7S9LjXHwmbysqvmLdqM1P+/57/ZS/vNHsS54p+fjXtEJB TD2g== DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=cc:cc:content-transfer-encoding:date:date :feedback-id:feedback-id:from:from:in-reply-to:in-reply-to :message-id:mime-version:references:reply-to:sender:subject :subject:to:to:x-me-proxy:x-me-proxy:x-me-sender:x-me-sender :x-sasl-enc; s=fm3; t=1666734306; x=1666820706; bh=YCRfc0bL2y7vw VY00aP0rRE5yM+6qksSA7GtoGPvEDo=; b=hn9JB7lfuh749BISj39GDo8ugq2xP oRTcRxiLAo50TOkyZ+nPZt3iOUvHlJ5Lkhaezok5nq5uuoaq+/w1fWa3PsnwL0mB tgfc1Oiqvvvaj0Rp9OKnkh0oe4uzYordz/XwDE558fsheTriDWriqWDk8Iibwl45 PfJil20s+zxG0R5q85sPvO9HsYc9iu1EY2H7rIXBG4Swh8wqokcb97EEOWYUB+Uv HjnEOMlbQMlpcCysPvAEMR3DR30dlHZftcr5l8nC1npJsNPCv+vkKuq5xUdjE5DF 4P9ryqEOzy0U3eP/8Q485n7MdiNo2SEL4mGswMD3Oa6jcCC+bkeA37CGw== X-ME-Sender: X-ME-Received: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgedvgedrtddugddtvdcutefuodetggdotefrodftvf curfhrohhfihhlvgemucfhrghsthforghilhdpqfgfvfdpuffrtefokffrpgfnqfghnecu uegrihhlohhuthemuceftddtnecusecvtfgvtghiphhivghnthhsucdlqddutddtmdenuc fjughrpefhvfevufffkffojghfggfgsedtkeertdertddtnecuhfhrohhmpefvhhhomhgr shcuofhonhhjrghlohhnuceothhhohhmrghssehmohhnjhgrlhhonhdrnhgvtheqnecugg ftrfgrthhtvghrnhepvdejhfdugeehvddtieejieegteeuudfgjeeukeeiledthfetveek hefhieelhfdtnecuvehluhhsthgvrhfuihiivgepfeenucfrrghrrghmpehmrghilhhfrh homhepthhhohhmrghssehmohhnjhgrlhhonhdrnhgvth X-ME-Proxy: Feedback-ID: i47234305:Fastmail Received: by mail.messagingengine.com (Postfix) with ESMTPA; Tue, 25 Oct 2022 17:45:05 -0400 (EDT) From: Thomas Monjalon To: dev@dpdk.org Cc: ferruh.yigit@amd.com, andrew.rybchenko@oktetlabs.ru, Ori Kam , Aman Singh , Yuying Zhang Subject: [PATCH 6/8] ethdev: use ARP protocol struct for flow matching Date: Tue, 25 Oct 2022 23:44:08 +0200 Message-Id: <20221025214410.715864-7-thomas@monjalon.net> X-Mailer: git-send-email 2.36.1 In-Reply-To: <20221025214410.715864-1-thomas@monjalon.net> References: <20221025214410.715864-1-thomas@monjalon.net> MIME-Version: 1.0 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org As announced in the deprecation notice, flow item structures should re-use the protocol header definitions from the directory lib/net/. The protocol struct is added in an unnamed union, keeping old field names. The ARP header struct members are used in testpmd instead of the redundant fields in the flow items. Signed-off-by: Thomas Monjalon --- app/test-pmd/cmdline_flow.c | 8 +++--- doc/guides/prog_guide/rte_flow.rst | 10 +------- doc/guides/rel_notes/deprecation.rst | 1 - lib/ethdev/rte_flow.h | 37 ++++++++++++++++++---------- 4 files changed, 29 insertions(+), 27 deletions(-) diff --git a/app/test-pmd/cmdline_flow.c b/app/test-pmd/cmdline_flow.c index 90da247eaf..84e1ed039f 100644 --- a/app/test-pmd/cmdline_flow.c +++ b/app/test-pmd/cmdline_flow.c @@ -4192,7 +4192,7 @@ static const struct token token_list[] = { .next = NEXT(item_arp_eth_ipv4, NEXT_ENTRY(COMMON_MAC_ADDR), item_param), .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_arp_eth_ipv4, - sha)), + hdr.arp_data.arp_sha)), }, [ITEM_ARP_ETH_IPV4_SPA] = { .name = "spa", @@ -4200,7 +4200,7 @@ static const struct token token_list[] = { .next = NEXT(item_arp_eth_ipv4, NEXT_ENTRY(COMMON_IPV4_ADDR), item_param), .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_arp_eth_ipv4, - spa)), + hdr.arp_data.arp_sip)), }, [ITEM_ARP_ETH_IPV4_THA] = { .name = "tha", @@ -4208,7 +4208,7 @@ static const struct token token_list[] = { .next = NEXT(item_arp_eth_ipv4, NEXT_ENTRY(COMMON_MAC_ADDR), item_param), .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_arp_eth_ipv4, - tha)), + hdr.arp_data.arp_tha)), }, [ITEM_ARP_ETH_IPV4_TPA] = { .name = "tpa", @@ -4216,7 +4216,7 @@ static const struct token token_list[] = { .next = NEXT(item_arp_eth_ipv4, NEXT_ENTRY(COMMON_IPV4_ADDR), item_param), .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_arp_eth_ipv4, - tpa)), + hdr.arp_data.arp_tip)), }, [ITEM_IPV6_EXT] = { .name = "ipv6_ext", diff --git a/doc/guides/prog_guide/rte_flow.rst b/doc/guides/prog_guide/rte_flow.rst index e8512e0a03..421c6407a9 100644 --- a/doc/guides/prog_guide/rte_flow.rst +++ b/doc/guides/prog_guide/rte_flow.rst @@ -1100,15 +1100,7 @@ Item: ``ARP_ETH_IPV4`` Matches an ARP header for Ethernet/IPv4. -- ``hdr``: hardware type, normally 1. -- ``pro``: protocol type, normally 0x0800. -- ``hln``: hardware address length, normally 6. -- ``pln``: protocol address length, normally 4. -- ``op``: opcode (1 for request, 2 for reply). -- ``sha``: sender hardware address. -- ``spa``: sender IPv4 address. -- ``tha``: target hardware address. -- ``tpa``: target IPv4 address. +- ``hdr``: header definition (``rte_arp.h``). - Default ``mask`` matches SHA, SPA, THA and TPA. Item: ``IPV6_EXT`` diff --git a/doc/guides/rel_notes/deprecation.rst b/doc/guides/rel_notes/deprecation.rst index b4b97d3165..af266cf9f4 100644 --- a/doc/guides/rel_notes/deprecation.rst +++ b/doc/guides/rel_notes/deprecation.rst @@ -66,7 +66,6 @@ Deprecation Notices These items are not compliant (not including struct from lib/net/): - ``rte_flow_item_ah`` - - ``rte_flow_item_arp_eth_ipv4`` - ``rte_flow_item_e_tag`` - ``rte_flow_item_geneve`` - ``rte_flow_item_geneve_opt`` diff --git a/lib/ethdev/rte_flow.h b/lib/ethdev/rte_flow.h index 02c6cc9981..d890c253b4 100644 --- a/lib/ethdev/rte_flow.h +++ b/lib/ethdev/rte_flow.h @@ -19,6 +19,7 @@ #include #include +#include #include #include #include @@ -1254,26 +1255,36 @@ static const struct rte_flow_item_vxlan_gpe rte_flow_item_vxlan_gpe_mask = { * * Matches an ARP header for Ethernet/IPv4. */ +RTE_STD_C11 struct rte_flow_item_arp_eth_ipv4 { - rte_be16_t hrd; /**< Hardware type, normally 1. */ - rte_be16_t pro; /**< Protocol type, normally 0x0800. */ - uint8_t hln; /**< Hardware address length, normally 6. */ - uint8_t pln; /**< Protocol address length, normally 4. */ - rte_be16_t op; /**< Opcode (1 for request, 2 for reply). */ - struct rte_ether_addr sha; /**< Sender hardware address. */ - rte_be32_t spa; /**< Sender IPv4 address. */ - struct rte_ether_addr tha; /**< Target hardware address. */ - rte_be32_t tpa; /**< Target IPv4 address. */ + union { + struct { + /* + * These are old fields kept for compatibility. + * Please prefer hdr field below. + */ + rte_be16_t hrd; /**< Hardware type, normally 1. */ + rte_be16_t pro; /**< Protocol type, normally 0x0800. */ + uint8_t hln; /**< Hardware address length, normally 6. */ + uint8_t pln; /**< Protocol address length, normally 4. */ + rte_be16_t op; /**< Opcode (1 for request, 2 for reply). */ + struct rte_ether_addr sha; /**< Sender hardware address. */ + rte_be32_t spa; /**< Sender IPv4 address. */ + struct rte_ether_addr tha; /**< Target hardware address. */ + rte_be32_t tpa; /**< Target IPv4 address. */ + }; + struct rte_arp_hdr hdr; /**< ARP header definition. */ + }; }; /** Default mask for RTE_FLOW_ITEM_TYPE_ARP_ETH_IPV4. */ #ifndef __cplusplus static const struct rte_flow_item_arp_eth_ipv4 rte_flow_item_arp_eth_ipv4_mask = { - .sha.addr_bytes = "\xff\xff\xff\xff\xff\xff", - .spa = RTE_BE32(0xffffffff), - .tha.addr_bytes = "\xff\xff\xff\xff\xff\xff", - .tpa = RTE_BE32(0xffffffff), + .hdr.arp_data.arp_sha.addr_bytes = "\xff\xff\xff\xff\xff\xff", + .hdr.arp_data.arp_sip = RTE_BE32(UINT32_MAX), + .hdr.arp_data.arp_tha.addr_bytes = "\xff\xff\xff\xff\xff\xff", + .hdr.arp_data.arp_tip = RTE_BE32(UINT32_MAX), }; #endif From patchwork Tue Oct 25 21:44:09 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Thomas Monjalon X-Patchwork-Id: 119124 X-Patchwork-Delegate: ferruh.yigit@amd.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 6745DA0544; Tue, 25 Oct 2022 23:45:35 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 6889042C7E; Tue, 25 Oct 2022 23:45:10 +0200 (CEST) Received: from out3-smtp.messagingengine.com (out3-smtp.messagingengine.com [66.111.4.27]) by mails.dpdk.org (Postfix) with ESMTP id 05D8742C79 for ; Tue, 25 Oct 2022 23:45:09 +0200 (CEST) Received: from compute5.internal (compute5.nyi.internal [10.202.2.45]) by mailout.nyi.internal (Postfix) with ESMTP id B8C185C010E; Tue, 25 Oct 2022 17:45:08 -0400 (EDT) Received: from mailfrontend1 ([10.202.2.162]) by compute5.internal (MEProxy); Tue, 25 Oct 2022 17:45:08 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=monjalon.net; h= cc:cc:content-transfer-encoding:date:date:from:from:in-reply-to :in-reply-to:message-id:mime-version:references:reply-to:sender :subject:subject:to:to; s=fm3; t=1666734308; x=1666820708; bh=JP OeBk+/Nsai8/ky5IyUO6paWAb1u65Zh5+2Yg5Byic=; b=iBpqeJ6kGd6a4q4J37 KhuoEYhFQ4Xz5rO4XLxC73KieuupzMkEeon8BBzRBdZ5rs/YPOU8J3Q4BU5MdAFL 1/lcVf5tzzUIhUr8G8/pkTO/w/UeF/gn69ZLATCuiF1KWDhFFcaxyNcNXSSkVq3W w+7bgGquJZNosjUufMUHUQHTWSNc06YnPVkp0VyiBsToaZi15xoQAzL/IBoWR+5J kCj4ueEjp11ZzS+48pK3alz4Y27p2n3bC7hRf9HAqshgld4LSHEIqrIz7JaQUDGW IshXjZuOZxjoLtYERysgsEt3KDH3td2RikxLjDySHD/rTmkiLv69m/Gu1AmOgErD s4Dg== DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=cc:cc:content-transfer-encoding:date:date :feedback-id:feedback-id:from:from:in-reply-to:in-reply-to :message-id:mime-version:references:reply-to:sender:subject :subject:to:to:x-me-proxy:x-me-proxy:x-me-sender:x-me-sender :x-sasl-enc; s=fm3; t=1666734308; x=1666820708; bh=JPOeBk+/Nsai8 /ky5IyUO6paWAb1u65Zh5+2Yg5Byic=; b=es/VTK/hzj0GDi4tM2DG80G6rH2k5 MwQQpXrzmBNdmnPwdeqUdIVUDGTLPFSHXBLS3zHxItkDa9zTvCLT250UIg3Q26ox BJm2bpaUGL5ppE7Pq17mKI/dLpgD//f6SZlAeeS9uLo2jK5I/946QoxULi4XSoon RDRGalgbiNKGfNh9xTiLv9dWPWU4+WBox8iePSoe9277oyqXX7N4crOwGwhn3GPz 4mIBIoA7QTgs+WSBnAjWurtn77ZoRLgmlGgxxBPs4hw2BzLGPPpzrNeWscp9fzjR b/07WIF7i89k8a5BWIgKbHNGkaEkTk3d4kvQ8YQIhhf3DRA1H/6UEe3HA== X-ME-Sender: X-ME-Received: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgedvgedrtddugddtudcutefuodetggdotefrodftvf curfhrohhfihhlvgemucfhrghsthforghilhdpqfgfvfdpuffrtefokffrpgfnqfghnecu uegrihhlohhuthemuceftddtnecusecvtfgvtghiphhivghnthhsucdlqddutddtmdenuc fjughrpefhvfevufffkffojghfggfgsedtkeertdertddtnecuhfhrohhmpefvhhhomhgr shcuofhonhhjrghlohhnuceothhhohhmrghssehmohhnjhgrlhhonhdrnhgvtheqnecugg ftrfgrthhtvghrnhepvdejhfdugeehvddtieejieegteeuudfgjeeukeeiledthfetveek hefhieelhfdtnecuvehluhhsthgvrhfuihiivgepudenucfrrghrrghmpehmrghilhhfrh homhepthhhohhmrghssehmohhnjhgrlhhonhdrnhgvth X-ME-Proxy: Feedback-ID: i47234305:Fastmail Received: by mail.messagingengine.com (Postfix) with ESMTPA; Tue, 25 Oct 2022 17:45:07 -0400 (EDT) From: Thomas Monjalon To: dev@dpdk.org Cc: ferruh.yigit@amd.com, andrew.rybchenko@oktetlabs.ru, Ori Kam Subject: [PATCH 7/8] doc: fix description of L2TPV2 flow item Date: Tue, 25 Oct 2022 23:44:09 +0200 Message-Id: <20221025214410.715864-8-thomas@monjalon.net> X-Mailer: git-send-email 2.36.1 In-Reply-To: <20221025214410.715864-1-thomas@monjalon.net> References: <20221025214410.715864-1-thomas@monjalon.net> MIME-Version: 1.0 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org The flow item structure includes the protocol definition from the directory lib/net/, so it is reflected in the guide. Section title underlining is also fixed around. Signed-off-by: Thomas Monjalon --- doc/guides/prog_guide/rte_flow.rst | 13 +++---------- 1 file changed, 3 insertions(+), 10 deletions(-) diff --git a/doc/guides/prog_guide/rte_flow.rst b/doc/guides/prog_guide/rte_flow.rst index 421c6407a9..007051f070 100644 --- a/doc/guides/prog_guide/rte_flow.rst +++ b/doc/guides/prog_guide/rte_flow.rst @@ -1485,22 +1485,15 @@ rte_flow_flex_item_create() routine. value and mask. Item: ``L2TPV2`` -^^^^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^ Matches a L2TPv2 header. -- ``flags_version``: flags(12b), version(4b). -- ``length``: total length of the message. -- ``tunnel_id``: identifier for the control connection. -- ``session_id``: identifier for a session within a tunnel. -- ``ns``: sequence number for this date or control message. -- ``nr``: sequence number expected in the next control message to be received. -- ``offset_size``: offset of payload data. -- ``offset_padding``: offset padding, variable length. +- ``hdr``: header definition (``rte_l2tpv2.h``). - Default ``mask`` matches flags_version only. Item: ``PPP`` -^^^^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^ Matches a PPP header. From patchwork Tue Oct 25 21:44:10 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Thomas Monjalon X-Patchwork-Id: 119125 X-Patchwork-Delegate: ferruh.yigit@amd.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 5E61CA0544; Tue, 25 Oct 2022 23:45:40 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 7D88B42C86; Tue, 25 Oct 2022 23:45:16 +0200 (CEST) Received: from out3-smtp.messagingengine.com (out3-smtp.messagingengine.com [66.111.4.27]) by mails.dpdk.org (Postfix) with ESMTP id 9DAD441133 for ; Tue, 25 Oct 2022 23:45:14 +0200 (CEST) Received: from compute3.internal (compute3.nyi.internal [10.202.2.43]) by mailout.nyi.internal (Postfix) with ESMTP id 56AB45C0166; Tue, 25 Oct 2022 17:45:14 -0400 (EDT) Received: from mailfrontend1 ([10.202.2.162]) by compute3.internal (MEProxy); Tue, 25 Oct 2022 17:45:14 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=monjalon.net; h= cc:cc:content-transfer-encoding:date:date:from:from:in-reply-to :in-reply-to:message-id:mime-version:references:reply-to:sender :subject:subject:to:to; s=fm3; t=1666734314; x=1666820714; bh=cr 3j07ys3O+NSgovRFCLDFubZV1S/NJJ2ZHUgnXC9MU=; b=mqUVmL/RaY3Jfmd2tZ 49KIBURQC/KpbGEaNO9k43SwF0ZO8W6s7+u1lRu9UkBjv/EmXIzuDvLlgjkdS1ph 9gOsbWKlN3DfC66T21kkee9ttHgCuxLcWjO/W4eI8Oll8LjA5LUlbUIsee8E6IKd Fd850G/noLy3nl/YnrHqibs08kjOk89+1cFl/9pJyOgCkIbD8MuM4IMSQK3nyJQF XaywrRjIrHTggRjUGvVmDWl/EzirbJW2sQzpug1kanSd3b77mzSuUOftp9SY33Ud 5Czkn9NpvfZKju20yJkuW/d2vfIX9WnKIExQeB783tooiG4IupBSpEMGz9xsLt2q oSww== DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=cc:cc:content-transfer-encoding:date:date :feedback-id:feedback-id:from:from:in-reply-to:in-reply-to :message-id:mime-version:references:reply-to:sender:subject :subject:to:to:x-me-proxy:x-me-proxy:x-me-sender:x-me-sender :x-sasl-enc; s=fm3; t=1666734314; x=1666820714; bh=cr3j07ys3O+NS govRFCLDFubZV1S/NJJ2ZHUgnXC9MU=; b=iXGsNc0c5WUr9VKLi1Mld6M6yE3cM ydzgPV/mo/+LCkO8ycxY2BWkYhmUge7Lft0XPliwL+M8Ki7wxk9qQAFi6iWYg27F 0jcbRVnB+/S4wbjHGAFbPQgjR1ieUlh2cXw0xvD5k1ZjdVnTx8YQxTlcrNho3NPl juScGOYi5KXmbYsLCV96XyfNZ2bHjWP793P651XJ8anT8esmc2D2uXNJEhebwK8q R7VYDx+hnN3bxZRXLxUnSOZIKiqgcZ3lwPyxi5H5ArAn4Gb57qM7xL9AhgygiCZ5 Kt19EMmW2DljcgbkCJdrt+BdzR+zyItMD/KxqOwrD/4ewNo/B/DR/3NIg== X-ME-Sender: X-ME-Received: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgedvgedrtddugddtvdcutefuodetggdotefrodftvf curfhrohhfihhlvgemucfhrghsthforghilhdpqfgfvfdpuffrtefokffrpgfnqfghnecu uegrihhlohhuthemuceftddtnecusecvtfgvtghiphhivghnthhsucdlqddutddtmdenuc fjughrpefhvfevufffkffojghfggfgsedtkeertdertddtnecuhfhrohhmpefvhhhomhgr shcuofhonhhjrghlohhnuceothhhohhmrghssehmohhnjhgrlhhonhdrnhgvtheqnecugg ftrfgrthhtvghrnhepvdejhfdugeehvddtieejieegteeuudfgjeeukeeiledthfetveek hefhieelhfdtnecuvehluhhsthgvrhfuihiivgeptdenucfrrghrrghmpehmrghilhhfrh homhepthhhohhmrghssehmohhnjhgrlhhonhdrnhgvth X-ME-Proxy: Feedback-ID: i47234305:Fastmail Received: by mail.messagingengine.com (Postfix) with ESMTPA; Tue, 25 Oct 2022 17:45:13 -0400 (EDT) From: Thomas Monjalon To: dev@dpdk.org Cc: ferruh.yigit@amd.com, andrew.rybchenko@oktetlabs.ru, Olivier Matz Subject: [PATCH 8/8] net: mark all big endian types Date: Tue, 25 Oct 2022 23:44:10 +0200 Message-Id: <20221025214410.715864-9-thomas@monjalon.net> X-Mailer: git-send-email 2.36.1 In-Reply-To: <20221025214410.715864-1-thomas@monjalon.net> References: <20221025214410.715864-1-thomas@monjalon.net> MIME-Version: 1.0 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Some protocols (ARP, MPLS and HIGIG2) were using uint16_t and uint32_t types for their 16 and 32-bit fields. It was correct but not conveying the big endian nature of these fields. As for other protocols defined in this directory, all types are explicitly marked as big endian fields. Signed-off-by: Thomas Monjalon --- lib/net/rte_arp.h | 28 ++++++++++++++-------------- lib/net/rte_higig.h | 6 +++--- lib/net/rte_mpls.h | 2 +- 3 files changed, 18 insertions(+), 18 deletions(-) diff --git a/lib/net/rte_arp.h b/lib/net/rte_arp.h index 076c8ab314..151e6c641f 100644 --- a/lib/net/rte_arp.h +++ b/lib/net/rte_arp.h @@ -23,28 +23,28 @@ extern "C" { */ struct rte_arp_ipv4 { struct rte_ether_addr arp_sha; /**< sender hardware address */ - uint32_t arp_sip; /**< sender IP address */ + rte_be32_t arp_sip; /**< sender IP address */ struct rte_ether_addr arp_tha; /**< target hardware address */ - uint32_t arp_tip; /**< target IP address */ + rte_be32_t arp_tip; /**< target IP address */ } __rte_packed __rte_aligned(2); /** * ARP header. */ struct rte_arp_hdr { - uint16_t arp_hardware; /* format of hardware address */ -#define RTE_ARP_HRD_ETHER 1 /* ARP Ethernet address format */ + rte_be16_t arp_hardware; /** format of hardware address */ +#define RTE_ARP_HRD_ETHER 1 /** ARP Ethernet address format */ - uint16_t arp_protocol; /* format of protocol address */ - uint8_t arp_hlen; /* length of hardware address */ - uint8_t arp_plen; /* length of protocol address */ - uint16_t arp_opcode; /* ARP opcode (command) */ -#define RTE_ARP_OP_REQUEST 1 /* request to resolve address */ -#define RTE_ARP_OP_REPLY 2 /* response to previous request */ -#define RTE_ARP_OP_REVREQUEST 3 /* request proto addr given hardware */ -#define RTE_ARP_OP_REVREPLY 4 /* response giving protocol address */ -#define RTE_ARP_OP_INVREQUEST 8 /* request to identify peer */ -#define RTE_ARP_OP_INVREPLY 9 /* response identifying peer */ + rte_be16_t arp_protocol; /** format of protocol address */ + uint8_t arp_hlen; /** length of hardware address */ + uint8_t arp_plen; /** length of protocol address */ + rte_be16_t arp_opcode; /** ARP opcode (command) */ +#define RTE_ARP_OP_REQUEST 1 /** request to resolve address */ +#define RTE_ARP_OP_REPLY 2 /** response to previous request */ +#define RTE_ARP_OP_REVREQUEST 3 /** request proto addr given hardware */ +#define RTE_ARP_OP_REVREPLY 4 /** response giving protocol address */ +#define RTE_ARP_OP_INVREQUEST 8 /** request to identify peer */ +#define RTE_ARP_OP_INVREPLY 9 /** response identifying peer */ struct rte_arp_ipv4 arp_data; } __rte_packed __rte_aligned(2); diff --git a/lib/net/rte_higig.h b/lib/net/rte_higig.h index b55fb1a7db..bba3898a88 100644 --- a/lib/net/rte_higig.h +++ b/lib/net/rte_higig.h @@ -112,9 +112,9 @@ struct rte_higig2_ppt_type0 { */ __extension__ struct rte_higig2_ppt_type1 { - uint16_t classification; - uint16_t resv; - uint16_t vid; + rte_be16_t classification; + rte_be16_t resv; + rte_be16_t vid; #if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN uint16_t opcode:3; uint16_t resv1:2; diff --git a/lib/net/rte_mpls.h b/lib/net/rte_mpls.h index 3e8cb90ec3..51523e7a11 100644 --- a/lib/net/rte_mpls.h +++ b/lib/net/rte_mpls.h @@ -23,7 +23,7 @@ extern "C" { */ __extension__ struct rte_mpls_hdr { - uint16_t tag_msb; /**< Label(msb). */ + rte_be16_t tag_msb; /**< Label(msb). */ #if RTE_BYTE_ORDER == RTE_BIG_ENDIAN uint8_t tag_lsb:4; /**< Label(lsb). */ uint8_t tc:3; /**< Traffic class. */