From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id D499941BAE; Thu, 2 Feb 2023 13:45:43 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 0146242FA6; Thu, 2 Feb 2023 13:45:36 +0100 (CET) Received: from NAM12-BN8-obe.outbound.protection.outlook.com (mail-bn8nam12on2062.outbound.protection.outlook.com [40.107.237.62]) by mails.dpdk.org (Postfix) with ESMTP id 4E65E42DB5 for ; Thu, 2 Feb 2023 13:45:33 +0100 (CET) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=JKTw6gtbJx8fyD/ueATIAP3gYrvaDsAIKAjO1uUFOqV5O1T+xUqejRFdYZ8TsocKpogGYY9cpDuCaUo78ga+y/OF+YLAbzUURspbLOFtKVz6bB+ALLkmF6o94Xi94bpBltIB5jTNHXH6UxHdkQPnh/ez+zIrgg488pirLRzbqnGPlY0X0Cwigd5G1UofCbfSDvwXbiccA8S91emzNCGUuHuvDaQiriX7REZGpAndg+oxpLUdfRvmk5sbht2v6+/lfYN+gXPLt2xEyZmohzB2y4Jzyc5ttIIJl/3kFj+01YOpk79ZNMe2RJYzETHZRO5JO3gYJNsJOA5dII1h/buYHA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=aFdCK3pLKgtlG1PHdNtof2Odl19QzUySmAHw+ma9sJc=; b=aC/YidhFH/2MgJHpKPx0o/BEdAGztQ1yD+Ba/Hdm0cGzZs/dAJV50nH4Jc+HonN3Xyj7ihxcl2yAomOiy6JOmWY7o+UiSs2IhV1QH869jngVDCpse4fCPlpSBrozv/oslYNPW9tq7kKROsfe5saychanQOGmgZYGtylSiYZwTt8IcVQxyb1+HiYaqltzaJBdAy2UDXd3dWi44v5culhKnpd1NOraxIQAMKM712N4gt/MnOVgnohaGNfVeUuqrdde+PNsk0JjWXyEAl2lIyLk5g2wvpaM0OuilgnagVbGsNqMhtHTVz/HAQL4+pMr8WL7G3UHBOThRoSZRWzzyfzIBA== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass (sender ip is 165.204.84.17) smtp.rcpttodomain=monjalon.net smtp.mailfrom=amd.com; dmarc=pass (p=quarantine sp=quarantine pct=100) action=none header.from=amd.com; dkim=none (message not signed); arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=amd.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=aFdCK3pLKgtlG1PHdNtof2Odl19QzUySmAHw+ma9sJc=; b=YQzeIu4lfu8w5DmOwXzHFjJkgK3Mf8FYkP+CV/B/G/PE1jtQ7MbzIutA5lIyTn4LGWqF7IYFoytBtuu/+zMpHMdWrUpNnEhf9xcgGIkVOis1Cja+NIO5UadoP09Tf5GoMyoufYzI3XIef1EqebTafJuuR3c3yWUq/HA8Oj9I0v4= Received: from MW4PR03CA0227.namprd03.prod.outlook.com (2603:10b6:303:b9::22) by DM6PR12MB4386.namprd12.prod.outlook.com (2603:10b6:5:28f::21) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.6064.24; Thu, 2 Feb 2023 12:45:24 +0000 Received: from CO1NAM11FT046.eop-nam11.prod.protection.outlook.com (2603:10b6:303:b9:cafe::fe) by MW4PR03CA0227.outlook.office365.com (2603:10b6:303:b9::22) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.6064.27 via Frontend Transport; Thu, 2 Feb 2023 12:45:24 +0000 X-MS-Exchange-Authentication-Results: spf=pass (sender IP is 165.204.84.17) smtp.mailfrom=amd.com; dkim=none (message not signed) header.d=none;dmarc=pass action=none header.from=amd.com; Received-SPF: Pass (protection.outlook.com: domain of amd.com designates 165.204.84.17 as permitted sender) receiver=protection.outlook.com; client-ip=165.204.84.17; helo=SATLEXMB04.amd.com; pr=C Received: from SATLEXMB04.amd.com (165.204.84.17) by CO1NAM11FT046.mail.protection.outlook.com (10.13.174.203) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.20.6064.25 via Frontend Transport; Thu, 2 Feb 2023 12:45:24 +0000 Received: from telcodpdk.amd.com (10.180.168.240) by SATLEXMB04.amd.com (10.181.40.145) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2375.34; Thu, 2 Feb 2023 06:45:18 -0600 From: Ferruh Yigit To: Thomas Monjalon , 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 , Chaoyong He , =?UTF-8?q?Niklas=20S=C3=B6derlund?= , Andrew Rybchenko , Jiawen Wu , Jian Wang CC: David Marchand , Subject: [PATCH v6 1/8] ethdev: use Ethernet protocol struct for flow matching Date: Thu, 2 Feb 2023 12:44:53 +0000 Message-ID: <20230202124500.2578857-2-ferruh.yigit@amd.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20230202124500.2578857-1-ferruh.yigit@amd.com> References: <20221025214410.715864-1-thomas@monjalon.net> <20230202124500.2578857-1-ferruh.yigit@amd.com> MIME-Version: 1.0 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: 8bit X-Originating-IP: [10.180.168.240] X-ClientProxiedBy: SATLEXMB04.amd.com (10.181.40.145) To SATLEXMB04.amd.com (10.181.40.145) X-EOPAttributedMessage: 0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: CO1NAM11FT046:EE_|DM6PR12MB4386:EE_ X-MS-Office365-Filtering-Correlation-Id: 6a5e7e0d-d651-4ee9-c141-08db051b5aaa X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: c4H0is2vcQmYyrR3Dbz2vnIKfK0V0s9Gc5B9ubUjBabNU8ATyFgMw2Pzekw4+eSfwVqqn5H081QTu323AAb9mqA1UHsnYser1YgBHucP0wx2I9fNntGKhxwKO5Apu7V1IExgONYRdktJTEEzCejyL0lTB3xcimv4EXpPLJdihzNG/s6AWA4yJ8J10LAcGIGacKKb/ZX0uWA/QOnHi4layE6w2l/JAUgkgt8KDvsnRcWy89xvrKySTiIHb7Kti97M5kyqipLj4su6054tDNI9GR45vbcRb7amRizJjRaDpIta2Ek8Hn8m3CskohZkUJVSj7aOXbcTkUxeUOCcwglSJFXf+/lG3hvME8uVafSsK6DypcWNyR1pK6fF4YsKXmpaf6AhVhb2FIfRMcXFS+363NHPX5E+3ZEJL4PCGi06Kk5uZDSLxs+mCc1u4ZkyQ0sn4mzGgBDSOMHsvWRHfnS7ZcYZHXFnO57F0uiicVipZiCOesiwLeA858lvfZuT9EM9TVNvK/zx5whPvKeA6U8SwL0Dl28VKMrP1bK6GMJL+auZ5hN3BxU8jWebHrhbAlP3nxY6RJh7rTCLz2tr+K/WWwg0IU3cCV6jbhkCtZml/mnKqpzixn0h+pBh7+bhxVtx6gzmrbSYfNEeJOBNfQEh3UDDPyPYpJlkX/hNlhRJyR2dyKEARAQih2MuXAUtxV2vh7lavYISM/5OTuPWFffWUQ3OgiQYZcIIDJ1gmgENZEP2QaJlqC/6aEtDv05Dr7/9 X-Forefront-Antispam-Report: CIP:165.204.84.17; CTRY:US; LANG:en; SCL:1; SRV:; IPV:CAL; SFV:NSPM; H:SATLEXMB04.amd.com; PTR:InfoDomainNonexistent; CAT:NONE; SFS:(13230025)(4636009)(376002)(39860400002)(136003)(396003)(346002)(451199018)(40470700004)(46966006)(36840700001)(7416002)(316002)(47076005)(86362001)(478600001)(2616005)(921005)(7696005)(82740400003)(26005)(6666004)(356005)(1076003)(81166007)(82310400005)(16526019)(186003)(5660300002)(54906003)(110136005)(7406005)(83380400001)(336012)(36756003)(426003)(2906002)(30864003)(40480700001)(66574015)(40460700003)(36860700001)(8936002)(70206006)(8676002)(44832011)(41300700001)(70586007)(4326008)(36900700001)(579004)(559001); DIR:OUT; SFP:1101; X-OriginatorOrg: amd.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 02 Feb 2023 12:45:24.4734 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 6a5e7e0d-d651-4ee9-c141-08db051b5aaa X-MS-Exchange-CrossTenant-Id: 3dd8961f-e488-4e60-8e11-a82d994e183d X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=3dd8961f-e488-4e60-8e11-a82d994e183d; Ip=[165.204.84.17]; Helo=[SATLEXMB04.amd.com] X-MS-Exchange-CrossTenant-AuthSource: CO1NAM11FT046.eop-nam11.prod.protection.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Anonymous X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: DM6PR12MB4386 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 From: Thomas Monjalon 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 Acked-by: Ferruh Yigit Reviewed-by: Niklas Söderlund Acked-by: Ori Kam Acked-by: Andrew Rybchenko --- 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 | 2 + 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/hws/mlx5dr_definer.c | 26 ++--- drivers/net/mlx5/mlx5_flow.c | 24 ++-- drivers/net/mlx5/mlx5_flow_dv.c | 94 +++++++-------- drivers/net/mlx5/mlx5_flow_hw.c | 80 ++++++------- drivers/net/mlx5/mlx5_flow_verbs.c | 30 ++--- drivers/net/mlx5/mlx5_trigger.c | 28 ++--- drivers/net/mvpp2/mrvl_flow.c | 28 ++--- drivers/net/nfp/nfp_flow.c | 12 +- 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 ++--- 39 files changed, 618 insertions(+), 619 deletions(-) diff --git a/app/test-flow-perf/items_gen.c b/app/test-flow-perf/items_gen.c index a73de9031f54..b7f51030a119 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 88108498e0c3..694a7eb647c5 100644 --- a/app/test-pmd/cmdline_flow.c +++ b/app/test-pmd/cmdline_flow.c @@ -3633,19 +3633,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", @@ -3666,7 +3666,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", @@ -3674,7 +3674,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", @@ -3682,7 +3682,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", @@ -3690,7 +3690,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", @@ -3698,7 +3698,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", @@ -7487,10 +7487,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, @@ -7502,9 +7502,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, @@ -7622,10 +7622,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, @@ -7635,9 +7635,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, @@ -7698,10 +7698,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; @@ -7728,22 +7728,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); } @@ -7762,10 +7762,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; @@ -7792,7 +7792,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) { @@ -7816,10 +7816,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 = { @@ -7868,22 +7868,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); } @@ -7922,8 +7922,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, @@ -7963,22 +7963,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); } @@ -8009,10 +8009,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 = { @@ -8062,22 +8062,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); } @@ -8116,8 +8116,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, @@ -8159,22 +8159,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 3e6242803dc0..27c3780c4f17 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 eea99b454005..4782d2e680d3 100644 --- a/doc/guides/rel_notes/deprecation.rst +++ b/doc/guides/rel_notes/deprecation.rst @@ -63,6 +63,8 @@ Deprecation Notices 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 a 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/): diff --git a/drivers/net/bnxt/bnxt_flow.c b/drivers/net/bnxt/bnxt_flow.c index 96ef00460cf5..8f660493402c 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 1be649a16c49..2928598ced55 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 f70c2c290577..f0c4f7d26b86 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 d66672a9e6b8..f5787c247f1f 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 df06c3862e7c..eec7e6065097 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 7456f43f425c..2ff1a98fda7c 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 b77531065196..ea9b290e1cb5 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 cf51793cfef0..e6c9ad442ac0 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 c87d3af8476c..90027dc67695 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 358b372e07e8..d1a564a16303 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 a2c1589c3980..ef1832982dee 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 65a826d51c17..0acbd5a061e0 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 0c848189776d..02e1457d8017 100644 --- a/drivers/net/i40e/i40e_hash.c +++ b/drivers/net/i40e/i40e_hash.c @@ -986,7 +986,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."); @@ -1033,7 +1033,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 8f8087392538..a6c88cb55b88 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 4082c0069f31..74e1e7099b8c 100644 --- a/drivers/net/iavf/iavf_fsub.c +++ b/drivers/net/iavf/iavf_fsub.c @@ -254,7 +254,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 { @@ -262,12 +262,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; } @@ -487,10 +487,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 868921cac595..08a80137e5b9 100644 --- a/drivers/net/iavf/iavf_ipsec_crypto.c +++ b/drivers/net/iavf/iavf_ipsec_crypto.c @@ -1682,9 +1682,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 8fe6f5aeb0cd..f2ddbd7b9b2e 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 7914ba940731..5d297afc290e 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 60f7934a1697..d84061340e6c 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 58a6a8a539c6..b677a0d61340 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 5b57ee9341d3..ee56d0f43d93 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 110ff34fcceb..a11da3dc8beb 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 9d7247cf81d0..8ef9fd2db44e 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/hws/mlx5dr_definer.c b/drivers/net/mlx5/hws/mlx5dr_definer.c index 6b98eb8c9666..604384a24253 100644 --- a/drivers/net/mlx5/hws/mlx5dr_definer.c +++ b/drivers/net/mlx5/hws/mlx5dr_definer.c @@ -109,12 +109,12 @@ struct mlx5dr_definer_conv_data { /* Xmacro used to create generic item setter from items */ #define LIST_OF_FIELDS_INFO \ - X(SET_BE16, eth_type, v->type, rte_flow_item_eth) \ - X(SET_BE32P, eth_smac_47_16, &v->src.addr_bytes[0], rte_flow_item_eth) \ - X(SET_BE16P, eth_smac_15_0, &v->src.addr_bytes[4], rte_flow_item_eth) \ - X(SET_BE32P, eth_dmac_47_16, &v->dst.addr_bytes[0], rte_flow_item_eth) \ - X(SET_BE16P, eth_dmac_15_0, &v->dst.addr_bytes[4], rte_flow_item_eth) \ - X(SET_BE16, tci, v->tci, rte_flow_item_vlan) \ + X(SET_BE16, eth_type, v->hdr.ether_type, rte_flow_item_eth) \ + X(SET_BE32P, eth_smac_47_16, &v->hdr.src_addr.addr_bytes[0], rte_flow_item_eth) \ + X(SET_BE16P, eth_smac_15_0, &v->hdr.src_addr.addr_bytes[4], rte_flow_item_eth) \ + X(SET_BE32P, eth_dmac_47_16, &v->hdr.dst_addr.addr_bytes[0], rte_flow_item_eth) \ + X(SET_BE16P, eth_dmac_15_0, &v->hdr.dst_addr.addr_bytes[4], rte_flow_item_eth) \ + X(SET_BE16, tci, v->hdr.vlan_tci, rte_flow_item_vlan) \ X(SET, ipv4_ihl, v->ihl, rte_ipv4_hdr) \ X(SET, ipv4_tos, v->type_of_service, rte_ipv4_hdr) \ X(SET, ipv4_time_to_live, v->time_to_live, rte_ipv4_hdr) \ @@ -416,7 +416,7 @@ mlx5dr_definer_conv_item_eth(struct mlx5dr_definer_conv_data *cd, return rte_errno; } - if (m->type) { + if (m->hdr.ether_type) { fc = &cd->fc[DR_CALC_FNAME(ETH_TYPE, inner)]; fc->item_idx = item_idx; fc->tag_set = &mlx5dr_definer_eth_type_set; @@ -424,7 +424,7 @@ mlx5dr_definer_conv_item_eth(struct mlx5dr_definer_conv_data *cd, } /* Check SMAC 47_16 */ - if (memcmp(m->src.addr_bytes, empty_mac, 4)) { + if (memcmp(m->hdr.src_addr.addr_bytes, empty_mac, 4)) { fc = &cd->fc[DR_CALC_FNAME(ETH_SMAC_48_16, inner)]; fc->item_idx = item_idx; fc->tag_set = &mlx5dr_definer_eth_smac_47_16_set; @@ -432,7 +432,7 @@ mlx5dr_definer_conv_item_eth(struct mlx5dr_definer_conv_data *cd, } /* Check SMAC 15_0 */ - if (memcmp(m->src.addr_bytes + 4, empty_mac + 4, 2)) { + if (memcmp(m->hdr.src_addr.addr_bytes + 4, empty_mac + 4, 2)) { fc = &cd->fc[DR_CALC_FNAME(ETH_SMAC_15_0, inner)]; fc->item_idx = item_idx; fc->tag_set = &mlx5dr_definer_eth_smac_15_0_set; @@ -440,7 +440,7 @@ mlx5dr_definer_conv_item_eth(struct mlx5dr_definer_conv_data *cd, } /* Check DMAC 47_16 */ - if (memcmp(m->dst.addr_bytes, empty_mac, 4)) { + if (memcmp(m->hdr.dst_addr.addr_bytes, empty_mac, 4)) { fc = &cd->fc[DR_CALC_FNAME(ETH_DMAC_48_16, inner)]; fc->item_idx = item_idx; fc->tag_set = &mlx5dr_definer_eth_dmac_47_16_set; @@ -448,7 +448,7 @@ mlx5dr_definer_conv_item_eth(struct mlx5dr_definer_conv_data *cd, } /* Check DMAC 15_0 */ - if (memcmp(m->dst.addr_bytes + 4, empty_mac + 4, 2)) { + if (memcmp(m->hdr.dst_addr.addr_bytes + 4, empty_mac + 4, 2)) { fc = &cd->fc[DR_CALC_FNAME(ETH_DMAC_15_0, inner)]; fc->item_idx = item_idx; fc->tag_set = &mlx5dr_definer_eth_dmac_15_0_set; @@ -493,14 +493,14 @@ mlx5dr_definer_conv_item_vlan(struct mlx5dr_definer_conv_data *cd, DR_CALC_SET(fc, eth_l2, first_vlan_qualifier, inner); } - if (m->tci) { + if (m->hdr.vlan_tci) { fc = &cd->fc[DR_CALC_FNAME(VLAN_TCI, inner)]; fc->item_idx = item_idx; fc->tag_set = &mlx5dr_definer_tci_set; DR_CALC_SET(fc, eth_l2, tci, inner); } - if (m->inner_type) { + if (m->hdr.eth_proto) { fc = &cd->fc[DR_CALC_FNAME(ETH_TYPE, inner)]; fc->item_idx = item_idx; fc->tag_set = &mlx5dr_definer_eth_type_set; diff --git a/drivers/net/mlx5/mlx5_flow.c b/drivers/net/mlx5/mlx5_flow.c index a0cf677fb099..2512d6b52db9 100644 --- a/drivers/net/mlx5/mlx5_flow.c +++ b/drivers/net/mlx5/mlx5_flow.c @@ -301,13 +301,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); @@ -2431,9 +2431,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; @@ -2493,8 +2493,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); @@ -2522,7 +2522,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) { @@ -2542,8 +2542,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 @@ -7877,10 +7877,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 62c38b87a1f0..ff915183b7cc 100644 --- a/drivers/net/mlx5/mlx5_flow_dv.c +++ b/drivers/net/mlx5/mlx5_flow_dv.c @@ -594,17 +594,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; @@ -2370,8 +2370,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); @@ -2399,7 +2399,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) { @@ -2920,9 +2920,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) @@ -2944,23 +2944,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); } } @@ -3010,8 +3010,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 @@ -3023,8 +3023,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 @@ -7130,10 +7130,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; @@ -7149,10 +7149,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; @@ -8460,9 +8460,9 @@ flow_dv_translate_item_eth(void *key, const struct rte_flow_item *item, const struct rte_flow_item_eth *eth_m; const struct rte_flow_item_eth *eth_v; 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_v; @@ -8480,12 +8480,12 @@ flow_dv_translate_item_eth(void *key, const struct rte_flow_item *item, hdrs_v = MLX5_ADDR_OF(fte_match_param, key, outer_headers); /* 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]; 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). @@ -8494,8 +8494,8 @@ flow_dv_translate_item_eth(void *key, const struct rte_flow_item *item, * ethertype, and use ip_version field instead. * eCPRI over Ether layer will use type value 0xAEFE. */ - if (eth_m->type == 0xFFFF) { - rte_be16_t type = eth_v->type; + if (eth_m->hdr.ether_type == 0xFFFF) { + rte_be16_t type = eth_v->hdr.ether_type; /* * When set the matcher mask, refer to the original spec @@ -8503,7 +8503,7 @@ flow_dv_translate_item_eth(void *key, const struct rte_flow_item *item, */ if (key_type == MLX5_SET_MATCHER_SW_M) { MLX5_SET(fte_match_set_lyr_2_4, hdrs_v, cvlan_tag, 1); - type = eth_vv->type; + type = eth_vv->hdr.ether_type; } /* Set cvlan_tag mask for any single\multi\un-tagged case. */ switch (type) { @@ -8539,7 +8539,7 @@ flow_dv_translate_item_eth(void *key, const struct rte_flow_item *item, return; } 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; } /** @@ -8576,7 +8576,7 @@ flow_dv_translate_item_vlan(void *key, const struct rte_flow_item *item, * and pre-validated. */ if (vlan_vv) - wks->vlan_tag = rte_be_to_cpu_16(vlan_vv->tci) & 0x0fff; + wks->vlan_tag = rte_be_to_cpu_16(vlan_vv->hdr.vlan_tci) & 0x0fff; } /* * When VLAN item exists in flow, mark packet as tagged, @@ -8588,7 +8588,7 @@ flow_dv_translate_item_vlan(void *key, const struct rte_flow_item *item, return; MLX5_ITEM_UPDATE(item, key_type, vlan_v, vlan_m, &rte_flow_item_vlan_mask); - tci_v = rte_be_to_cpu_16(vlan_m->tci & vlan_v->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_v, first_vid, tci_v); MLX5_SET(fte_match_set_lyr_2_4, hdrs_v, first_cfi, tci_v >> 12); MLX5_SET(fte_match_set_lyr_2_4, hdrs_v, first_prio, tci_v >> 13); @@ -8596,15 +8596,15 @@ flow_dv_translate_item_vlan(void *key, const struct rte_flow_item *item, * HW is optimized for IPv4/IPv6. In such cases, avoid setting * ethertype, and use ip_version field instead. */ - if (vlan_m->inner_type == 0xFFFF) { - rte_be16_t inner_type = vlan_v->inner_type; + if (vlan_m->hdr.eth_proto == 0xFFFF) { + rte_be16_t inner_type = vlan_v->hdr.eth_proto; /* * When set the matcher mask, refer to the original spec * value. */ if (key_type == MLX5_SET_MATCHER_SW_M) - inner_type = vlan_vv->inner_type; + inner_type = vlan_vv->hdr.eth_proto; switch (inner_type) { case RTE_BE16(RTE_ETHER_TYPE_VLAN): MLX5_SET(fte_match_set_lyr_2_4, hdrs_v, svlan_tag, 1); @@ -8632,7 +8632,7 @@ flow_dv_translate_item_vlan(void *key, const struct rte_flow_item *item, return; } 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_hw.c b/drivers/net/mlx5/mlx5_flow_hw.c index a3c8056515da..b8f96839c8bf 100644 --- a/drivers/net/mlx5/mlx5_flow_hw.c +++ b/drivers/net/mlx5/mlx5_flow_hw.c @@ -91,68 +91,68 @@ static uint32_t mlx5_hw_act_flag[MLX5_HW_ACTION_FLAG_MAX] /* Ethernet item spec for promiscuous mode. */ static const struct rte_flow_item_eth ctrl_rx_eth_promisc_spec = { - .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, }; /* Ethernet item mask for promiscuous mode. */ static const struct rte_flow_item_eth ctrl_rx_eth_promisc_mask = { - .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, }; /* Ethernet item spec for all multicast mode. */ static const struct rte_flow_item_eth ctrl_rx_eth_mcast_spec = { - .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, }; /* Ethernet item mask for all multicast mode. */ static const struct rte_flow_item_eth ctrl_rx_eth_mcast_mask = { - .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, }; /* Ethernet item spec for IPv4 multicast traffic. */ static const struct rte_flow_item_eth ctrl_rx_eth_ipv4_mcast_spec = { - .dst.addr_bytes = "\x01\x00\x5e\x00\x00\x00", - .src.addr_bytes = "\x00\x00\x00\x00\x00\x00", - .type = 0, + .hdr.dst_addr.addr_bytes = "\x01\x00\x5e\x00\x00\x00", + .hdr.src_addr.addr_bytes = "\x00\x00\x00\x00\x00\x00", + .hdr.ether_type = 0, }; /* Ethernet item mask for IPv4 multicast traffic. */ static const struct rte_flow_item_eth ctrl_rx_eth_ipv4_mcast_mask = { - .dst.addr_bytes = "\xff\xff\xff\x00\x00\x00", - .src.addr_bytes = "\x00\x00\x00\x00\x00\x00", - .type = 0, + .hdr.dst_addr.addr_bytes = "\xff\xff\xff\x00\x00\x00", + .hdr.src_addr.addr_bytes = "\x00\x00\x00\x00\x00\x00", + .hdr.ether_type = 0, }; /* Ethernet item spec for IPv6 multicast traffic. */ static const struct rte_flow_item_eth ctrl_rx_eth_ipv6_mcast_spec = { - .dst.addr_bytes = "\x33\x33\x00\x00\x00\x00", - .src.addr_bytes = "\x00\x00\x00\x00\x00\x00", - .type = 0, + .hdr.dst_addr.addr_bytes = "\x33\x33\x00\x00\x00\x00", + .hdr.src_addr.addr_bytes = "\x00\x00\x00\x00\x00\x00", + .hdr.ether_type = 0, }; /* Ethernet item mask for IPv6 multicast traffic. */ static const struct rte_flow_item_eth ctrl_rx_eth_ipv6_mcast_mask = { - .dst.addr_bytes = "\xff\xff\x00\x00\x00\x00", - .src.addr_bytes = "\x00\x00\x00\x00\x00\x00", - .type = 0, + .hdr.dst_addr.addr_bytes = "\xff\xff\x00\x00\x00\x00", + .hdr.src_addr.addr_bytes = "\x00\x00\x00\x00\x00\x00", + .hdr.ether_type = 0, }; /* Ethernet item mask for unicast traffic. */ static const struct rte_flow_item_eth ctrl_rx_eth_dmac_mask = { - .dst.addr_bytes = "\xff\xff\xff\xff\xff\xff", - .src.addr_bytes = "\x00\x00\x00\x00\x00\x00", - .type = 0, + .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 = 0, }; /* Ethernet item spec for broadcast. */ static const struct rte_flow_item_eth ctrl_rx_eth_bcast_spec = { - .dst.addr_bytes = "\xff\xff\xff\xff\xff\xff", - .src.addr_bytes = "\x00\x00\x00\x00\x00\x00", - .type = 0, + .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 = 0, }; /** @@ -5682,9 +5682,9 @@ flow_hw_create_tx_default_mreg_copy_pattern_template(struct rte_eth_dev *dev) .egress = 1, }; 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, }; struct rte_flow_item eth_all[] = { [0] = { @@ -8776,9 +8776,9 @@ mlx5_flow_hw_create_tx_default_mreg_copy_flow(struct rte_eth_dev *dev) { struct mlx5_priv *priv = dev->data->dev_private; 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, }; struct rte_flow_item eth_all[] = { [0] = { @@ -9036,7 +9036,7 @@ __flow_hw_ctrl_flows_single_vlan(struct rte_eth_dev *dev, for (i = 0; i < priv->vlan_filter_n; ++i) { 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), }; items[1].spec = &vlan_spec; @@ -9080,7 +9080,7 @@ __flow_hw_ctrl_flows_unicast(struct rte_eth_dev *dev, if (!memcmp(mac, &cmp, sizeof(*mac))) continue; - memcpy(ð_spec.dst.addr_bytes, mac->addr_bytes, RTE_ETHER_ADDR_LEN); + memcpy(ð_spec.hdr.dst_addr.addr_bytes, mac->addr_bytes, RTE_ETHER_ADDR_LEN); if (flow_hw_create_ctrl_flow(dev, dev, tbl, items, 0, actions, 0)) return -rte_errno; } @@ -9123,11 +9123,11 @@ __flow_hw_ctrl_flows_unicast_vlan(struct rte_eth_dev *dev, if (!memcmp(mac, &cmp, sizeof(*mac))) continue; - memcpy(ð_spec.dst.addr_bytes, mac->addr_bytes, RTE_ETHER_ADDR_LEN); + memcpy(ð_spec.hdr.dst_addr.addr_bytes, mac->addr_bytes, RTE_ETHER_ADDR_LEN); for (j = 0; j < priv->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), }; items[1].spec = &vlan_spec; diff --git a/drivers/net/mlx5/mlx5_flow_verbs.c b/drivers/net/mlx5/mlx5_flow_verbs.c index 28ea28bfbe02..1902b97ec6d4 100644 --- a/drivers/net/mlx5/mlx5_flow_verbs.c +++ b/drivers/net/mlx5/mlx5_flow_verbs.c @@ -417,16 +417,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]; @@ -502,11 +502,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)) @@ -515,7 +515,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; } /** @@ -1305,10 +1305,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); @@ -1328,10 +1328,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 f54443ed1ac4..3457bf65d3e1 100644 --- a/drivers/net/mlx5/mlx5_trigger.c +++ b/drivers/net/mlx5/mlx5_trigger.c @@ -1552,19 +1552,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 = { @@ -1637,9 +1637,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); @@ -1648,9 +1648,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); @@ -1662,7 +1662,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; @@ -1697,14 +1697,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 99695b91c496..e74a5f83f55b 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/nfp/nfp_flow.c b/drivers/net/nfp/nfp_flow.c index ff2e21c817b4..bd3a8d2a3b2f 100644 --- a/drivers/net/nfp/nfp_flow.c +++ b/drivers/net/nfp/nfp_flow.c @@ -1099,11 +1099,11 @@ nfp_flow_merge_eth(__rte_unused struct nfp_app_fw_flower *app_fw_flower, eth = (void *)*mbuf_off; if (is_mask) { - memcpy(eth->mac_src, mask->src.addr_bytes, RTE_ETHER_ADDR_LEN); - memcpy(eth->mac_dst, mask->dst.addr_bytes, RTE_ETHER_ADDR_LEN); + memcpy(eth->mac_src, mask->hdr.src_addr.addr_bytes, RTE_ETHER_ADDR_LEN); + memcpy(eth->mac_dst, mask->hdr.dst_addr.addr_bytes, RTE_ETHER_ADDR_LEN); } else { - memcpy(eth->mac_src, spec->src.addr_bytes, RTE_ETHER_ADDR_LEN); - memcpy(eth->mac_dst, spec->dst.addr_bytes, RTE_ETHER_ADDR_LEN); + memcpy(eth->mac_src, spec->hdr.src_addr.addr_bytes, RTE_ETHER_ADDR_LEN); + memcpy(eth->mac_dst, spec->hdr.dst_addr.addr_bytes, RTE_ETHER_ADDR_LEN); } eth->mpls_lse = 0; @@ -1136,10 +1136,10 @@ nfp_flow_merge_vlan(__rte_unused struct nfp_app_fw_flower *app_fw_flower, mask = item->mask ? item->mask : proc->mask_default; if (is_mask) { meta_tci = (struct nfp_flower_meta_tci *)nfp_flow->payload.mask_data; - meta_tci->tci |= mask->tci; + meta_tci->tci |= mask->hdr.vlan_tci; } else { meta_tci = (struct nfp_flower_meta_tci *)nfp_flow->payload.unmasked_data; - meta_tci->tci |= spec->tci; + meta_tci->tci |= spec->hdr.vlan_tci; } return 0; diff --git a/drivers/net/sfc/sfc_flow.c b/drivers/net/sfc/sfc_flow.c index fb59abd0b563..f098edc6eb33 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 421bb6da9582..710d04be13af 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 efe66fe0593d..ed4d42f92f9f 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 7b18dca7e8d2..7ef52d0b0fcd 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, -- 2.34.1