From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.0 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 53D39C28CC5 for ; Wed, 5 Jun 2019 12:24:22 +0000 (UTC) Received: from dpdk.org (dpdk.org [92.243.14.124]) by mail.kernel.org (Postfix) with ESMTP id C0A77206BA for ; Wed, 5 Jun 2019 12:24:21 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org C0A77206BA Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=redhat.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=dev-bounces@dpdk.org Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id CE0D91B9FC; Wed, 5 Jun 2019 14:24:20 +0200 (CEST) Received: from mx1.redhat.com (mx1.redhat.com [209.132.183.28]) by dpdk.org (Postfix) with ESMTP id 23CD01B9F8 for ; Wed, 5 Jun 2019 14:24:19 +0200 (CEST) Received: from smtp.corp.redhat.com (int-mx08.intmail.prod.int.phx2.redhat.com [10.5.11.23]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 6DE0622387B; Wed, 5 Jun 2019 12:24:08 +0000 (UTC) Received: from [10.36.112.53] (ovpn-112-53.ams2.redhat.com [10.36.112.53]) by smtp.corp.redhat.com (Postfix) with ESMTPS id BA26A19C6A; Wed, 5 Jun 2019 12:24:05 +0000 (UTC) To: Leyi Rong , qi.z.zhang@intel.com Cc: dev@dpdk.org, Dan Nowlin , Paul M Stillwell Jr References: <20190604054248.68510-1-leyi.rong@intel.com> <20190604054248.68510-48-leyi.rong@intel.com> From: Maxime Coquelin Message-ID: <020fd028-65d5-7a8e-0591-b4c1c10a427b@redhat.com> Date: Wed, 5 Jun 2019 14:24:03 +0200 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.6.1 MIME-Version: 1.0 In-Reply-To: <20190604054248.68510-48-leyi.rong@intel.com> Content-Type: text/plain; charset=utf-8; format=flowed Content-Language: en-US Content-Transfer-Encoding: 7bit X-Scanned-By: MIMEDefang 2.84 on 10.5.11.23 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.39]); Wed, 05 Jun 2019 12:24:08 +0000 (UTC) Subject: Re: [dpdk-dev] [PATCH 47/49] net/ice/base: enable additional switch rules X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" On 6/4/19 7:42 AM, Leyi Rong wrote: > Add capability to create inner IP and inner TCP switch recipes and > rules. Change UDP tunnel dummy packet to accommodate the training of > these new rules. > > Signed-off-by: Dan Nowlin > Signed-off-by: Paul M Stillwell Jr > Signed-off-by: Leyi Rong > --- > drivers/net/ice/base/ice_protocol_type.h | 8 +- > drivers/net/ice/base/ice_switch.c | 361 ++++++++++++----------- > drivers/net/ice/base/ice_switch.h | 1 + > 3 files changed, 203 insertions(+), 167 deletions(-) > > diff --git a/drivers/net/ice/base/ice_protocol_type.h b/drivers/net/ice/base/ice_protocol_type.h > index 82822fb74..38bed7a79 100644 > --- a/drivers/net/ice/base/ice_protocol_type.h > +++ b/drivers/net/ice/base/ice_protocol_type.h > @@ -35,6 +35,7 @@ enum ice_protocol_type { > ICE_IPV6_IL, > ICE_IPV6_OFOS, > ICE_TCP_IL, > + ICE_UDP_OF, > ICE_UDP_ILOS, > ICE_SCTP_IL, > ICE_VXLAN, > @@ -112,6 +113,7 @@ enum ice_prot_id { > #define ICE_IPV6_OFOS_HW 40 > #define ICE_IPV6_IL_HW 41 > #define ICE_TCP_IL_HW 49 > +#define ICE_UDP_OF_HW 52 > #define ICE_UDP_ILOS_HW 53 > #define ICE_SCTP_IL_HW 96 > > @@ -188,8 +190,7 @@ struct ice_l4_hdr { > struct ice_udp_tnl_hdr { > u16 field; > u16 proto_type; > - u16 vni; > - u16 reserved; > + u32 vni; /* only use lower 24-bits */ > }; > > struct ice_nvgre { > @@ -225,6 +226,7 @@ struct ice_prot_lkup_ext { > u8 n_val_words; > /* create a buffer to hold max words per recipe */ > u16 field_off[ICE_MAX_CHAIN_WORDS]; > + u16 field_mask[ICE_MAX_CHAIN_WORDS]; > > struct ice_fv_word fv_words[ICE_MAX_CHAIN_WORDS]; > > @@ -235,6 +237,7 @@ struct ice_prot_lkup_ext { > struct ice_pref_recipe_group { > u8 n_val_pairs; /* Number of valid pairs */ > struct ice_fv_word pairs[ICE_NUM_WORDS_RECIPE]; > + u16 mask[ICE_NUM_WORDS_RECIPE]; > }; > > struct ice_recp_grp_entry { > @@ -244,6 +247,7 @@ struct ice_recp_grp_entry { > u16 rid; > u8 chain_idx; > u16 fv_idx[ICE_NUM_WORDS_RECIPE]; > + u16 fv_mask[ICE_NUM_WORDS_RECIPE]; > struct ice_pref_recipe_group r_group; > }; > #endif /* _ICE_PROTOCOL_TYPE_H_ */ > diff --git a/drivers/net/ice/base/ice_switch.c b/drivers/net/ice/base/ice_switch.c > index 373acb7a6..02fb49dba 100644 > --- a/drivers/net/ice/base/ice_switch.c > +++ b/drivers/net/ice/base/ice_switch.c > @@ -53,60 +53,109 @@ static const u8 dummy_eth_header[DUMMY_ETH_HDR_LEN] = { 0x2, 0, 0, 0, 0, 0, > sizeof(((struct ice_sw_rule_vsi_list *)0)->vsi) + \ > ((n) * sizeof(((struct ice_sw_rule_vsi_list *)0)->vsi))) > > +static const struct ice_dummy_pkt_offsets { > + enum ice_protocol_type type; > + u16 offset; /* ICE_PROTOCOL_LAST indicates end of list */ > +} dummy_gre_packet_offsets[] = { > + { ICE_MAC_OFOS, 0 }, > + { ICE_IPV4_OFOS, 14 }, > + { ICE_VXLAN, 34 }, > + { ICE_MAC_IL, 42 }, > + { ICE_IPV4_IL, 54 }, > + { ICE_PROTOCOL_LAST, 0 }, > +}; > + > static const > -u8 dummy_gre_packet[] = { 0, 0, 0, 0, /* Ether starts */ > +u8 dummy_gre_packet[] = { 0, 0, 0, 0, /* ICE_MAC_OFOS 0 */ > 0, 0, 0, 0, > 0, 0, 0, 0, > - 0x08, 0, /* Ether ends */ > - 0x45, 0, 0, 0x3E, /* IP starts */ > + 0x08, 0, > + 0x45, 0, 0, 0x3E, /* ICE_IPV4_OFOS 14 */ > 0, 0, 0, 0, > 0, 0x2F, 0, 0, > 0, 0, 0, 0, > - 0, 0, 0, 0, /* IP ends */ > - 0x80, 0, 0x65, 0x58, /* GRE starts */ > - 0, 0, 0, 0, /* GRE ends */ > - 0, 0, 0, 0, /* Ether starts */ > - 0, 0, 0, 0, > - 0, 0, 0, 0, > - 0x08, 0, /* Ether ends */ > - 0x45, 0, 0, 0x14, /* IP starts */ > 0, 0, 0, 0, > + 0x80, 0, 0x65, 0x58, /* ICE_VXLAN_GRE 34 */ > 0, 0, 0, 0, > + 0, 0, 0, 0, /* ICE_MAC_IL 42 */ > 0, 0, 0, 0, > - 0, 0, 0, 0 /* IP ends */ > - }; > - > -static const u8 > -dummy_udp_tun_packet[] = {0, 0, 0, 0, /* Ether starts */ > - 0, 0, 0, 0, > - 0, 0, 0, 0, > - 0x08, 0, /* Ether ends */ > - 0x45, 0, 0, 0x32, /* IP starts */ > 0, 0, 0, 0, > - 0, 0x11, 0, 0, > + 0x08, 0, > + 0x45, 0, 0, 0x14, /* ICE_IPV4_IL 54 */ > 0, 0, 0, 0, > - 0, 0, 0, 0, /* IP ends */ > - 0, 0, 0x12, 0xB5, /* UDP start*/ > - 0, 0x1E, 0, 0, /* UDP end*/ > - 0, 0, 0, 0, /* VXLAN start */ > - 0, 0, 0, 0, /* VXLAN end*/ > - 0, 0, 0, 0, /* Ether starts */ > 0, 0, 0, 0, > 0, 0, 0, 0, > - 0, 0 /* Ether ends */ > + 0, 0, 0, 0 > }; > > +static const > +struct ice_dummy_pkt_offsets dummy_udp_tun_packet_offsets[] = { > + { ICE_MAC_OFOS, 0 }, > + { ICE_IPV4_OFOS, 14 }, > + { ICE_UDP_OF, 34 }, > + { ICE_VXLAN, 42 }, > + { ICE_MAC_IL, 50 }, > + { ICE_IPV4_IL, 64 }, > + { ICE_TCP_IL, 84 }, > + { ICE_PROTOCOL_LAST, 0 }, > +}; > + > +static const > +u8 dummy_udp_tun_packet[] = { > + 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ > + 0x00, 0x00, 0x00, 0x00, > + 0x00, 0x00, 0x00, 0x00, > + 0x08, 0x00, > + > + 0x45, 0x00, 0x00, 0x5a, /* ICE_IPV4_OFOS 14 */ > + 0x00, 0x01, 0x00, 0x00, > + 0x40, 0x11, 0x00, 0x00, > + 0x00, 0x00, 0x00, 0x00, > + 0x00, 0x00, 0x00, 0x00, > + > + 0x00, 0x00, 0x12, 0xb5, /* ICE_UDP_OF 34 */ > + 0x00, 0x46, 0x00, 0x00, > + > + 0x04, 0x00, 0x00, 0x03, /* ICE_VXLAN 42 */ > + 0x00, 0x00, 0x00, 0x00, > + > + 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_IL 50 */ > + 0x00, 0x00, 0x00, 0x00, > + 0x00, 0x00, 0x00, 0x00, > + 0x08, 0x00, > + > + 0x45, 0x00, 0x00, 0x28, /* ICE_IPV4_IL 64 */ > + 0x00, 0x01, 0x00, 0x00, > + 0x40, 0x06, 0x00, 0x00, > + 0x00, 0x00, 0x00, 0x00, > + 0x00, 0x00, 0x00, 0x00, > + > + 0x00, 0x00, 0x00, 0x00, /* ICE_TCP_IL 84 */ > + 0x00, 0x00, 0x00, 0x00, > + 0x00, 0x00, 0x00, 0x00, > + 0x50, 0x02, 0x20, 0x00, > + 0x00, 0x00, 0x00, 0x00 > +}; > + > +static const > +struct ice_dummy_pkt_offsets dummy_tcp_tun_packet_offsets[] = { > + { ICE_MAC_OFOS, 0 }, > + { ICE_IPV4_OFOS, 14 }, > + { ICE_TCP_IL, 34 }, > + { ICE_PROTOCOL_LAST, 0 }, > +}; > + > static const u8 > -dummy_tcp_tun_packet[] = {0, 0, 0, 0, /* Ether starts */ > +dummy_tcp_tun_packet[] = {0, 0, 0, 0, /* ICE_MAC_OFOS 0 */ > 0, 0, 0, 0, > 0, 0, 0, 0, > - 0x08, 0, /* Ether ends */ > - 0x45, 0, 0, 0x28, /* IP starts */ > + 0x08, 0, > + 0x45, 0, 0, 0x28, /* ICE_IPV4_OFOS 14 */ > 0, 0x01, 0, 0, > 0x40, 0x06, 0xF5, 0x69, > 0, 0, 0, 0, > - 0, 0, 0, 0, /* IP ends */ > 0, 0, 0, 0, > + 0, 0, 0, 0, /* ICE_TCP_IL 34 */ > 0, 0, 0, 0, > 0, 0, 0, 0, > 0x50, 0x02, 0x20, > @@ -184,6 +233,9 @@ ice_get_recp_frm_fw(struct ice_hw *hw, struct ice_sw_recipe *recps, u8 rid) > u8 lkup_indx = root_bufs.content.lkup_indx[i + 1]; > > rg_entry->fv_idx[i] = lkup_indx; > + rg_entry->fv_mask[i] = > + LE16_TO_CPU(root_bufs.content.mask[i + 1]); > + > /* If the recipe is a chained recipe then all its > * child recipe's result will have a result index. > * To fill fv_words we should not use those result > @@ -4254,10 +4306,11 @@ static const struct ice_prot_ext_tbl_entry ice_prot_ext[] = { > { ICE_IPV6_OFOS, { 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, > 26, 28, 30, 32, 34, 36, 38 } }, > { ICE_TCP_IL, { 0, 2 } }, > + { ICE_UDP_OF, { 0, 2 } }, > { ICE_UDP_ILOS, { 0, 2 } }, > { ICE_SCTP_IL, { 0, 2 } }, > - { ICE_VXLAN, { 8, 10, 12 } }, > - { ICE_GENEVE, { 8, 10, 12 } }, > + { ICE_VXLAN, { 8, 10, 12, 14 } }, > + { ICE_GENEVE, { 8, 10, 12, 14 } }, > { ICE_VXLAN_GPE, { 0, 2, 4 } }, > { ICE_NVGRE, { 0, 2 } }, > { ICE_PROTOCOL_LAST, { 0 } } > @@ -4270,11 +4323,14 @@ static const struct ice_prot_ext_tbl_entry ice_prot_ext[] = { > */ > static const struct ice_pref_recipe_group ice_recipe_pack[] = { > {3, { { ICE_MAC_OFOS_HW, 0, 0 }, { ICE_MAC_OFOS_HW, 2, 0 }, > - { ICE_MAC_OFOS_HW, 4, 0 } } }, > + { ICE_MAC_OFOS_HW, 4, 0 } }, { 0xffff, 0xffff, 0xffff, 0xffff } }, > {4, { { ICE_MAC_IL_HW, 0, 0 }, { ICE_MAC_IL_HW, 2, 0 }, > - { ICE_MAC_IL_HW, 4, 0 }, { ICE_META_DATA_ID_HW, 44, 0 } } }, > - {2, { { ICE_IPV4_IL_HW, 0, 0 }, { ICE_IPV4_IL_HW, 2, 0 } } }, > - {2, { { ICE_IPV4_IL_HW, 12, 0 }, { ICE_IPV4_IL_HW, 14, 0 } } }, > + { ICE_MAC_IL_HW, 4, 0 }, { ICE_META_DATA_ID_HW, 44, 0 } }, > + { 0xffff, 0xffff, 0xffff, 0xffff } }, > + {2, { { ICE_IPV4_IL_HW, 0, 0 }, { ICE_IPV4_IL_HW, 2, 0 } }, > + { 0xffff, 0xffff, 0xffff, 0xffff } }, > + {2, { { ICE_IPV4_IL_HW, 12, 0 }, { ICE_IPV4_IL_HW, 14, 0 } }, > + { 0xffff, 0xffff, 0xffff, 0xffff } }, > }; > > static const struct ice_protocol_entry ice_prot_id_tbl[] = { > @@ -4285,6 +4341,7 @@ static const struct ice_protocol_entry ice_prot_id_tbl[] = { > { ICE_IPV6_OFOS, ICE_IPV6_OFOS_HW }, > { ICE_IPV6_IL, ICE_IPV6_IL_HW }, > { ICE_TCP_IL, ICE_TCP_IL_HW }, > + { ICE_UDP_OF, ICE_UDP_OF_HW }, > { ICE_UDP_ILOS, ICE_UDP_ILOS_HW }, > { ICE_SCTP_IL, ICE_SCTP_IL_HW }, > { ICE_VXLAN, ICE_UDP_OF_HW }, > @@ -4403,7 +4460,7 @@ ice_fill_valid_words(struct ice_adv_lkup_elem *rule, > word = lkup_exts->n_val_words; > > for (j = 0; j < sizeof(rule->m_u) / sizeof(u16); j++) > - if (((u16 *)&rule->m_u)[j] == 0xffff && > + if (((u16 *)&rule->m_u)[j] && > rule->type < ARRAY_SIZE(ice_prot_ext)) { > /* No more space to accommodate */ > if (word >= ICE_MAX_CHAIN_WORDS) > @@ -4412,6 +4469,7 @@ ice_fill_valid_words(struct ice_adv_lkup_elem *rule, > ice_prot_ext[rule->type].offs[j]; > lkup_exts->fv_words[word].prot_id = > ice_prot_id_tbl[rule->type].protocol_id; > + lkup_exts->field_mask[word] = ((u16 *)&rule->m_u)[j]; > word++; > } > > @@ -4535,6 +4593,7 @@ ice_create_first_fit_recp_def(struct ice_hw *hw, > lkup_exts->fv_words[j].prot_id; > grp->pairs[grp->n_val_pairs].off = > lkup_exts->fv_words[j].off; > + grp->mask[grp->n_val_pairs] = lkup_exts->field_mask[j]; > grp->n_val_pairs++; > } > > @@ -4569,14 +4628,22 @@ ice_fill_fv_word_index(struct ice_hw *hw, struct LIST_HEAD_TYPE *fv_list, > > for (i = 0; i < rg->r_group.n_val_pairs; i++) { > struct ice_fv_word *pr; > + u16 mask; > u8 j; > > pr = &rg->r_group.pairs[i]; > + mask = rg->r_group.mask[i]; > + > for (j = 0; j < hw->blk[ICE_BLK_SW].es.fvw; j++) > if (fv_ext[j].prot_id == pr->prot_id && > fv_ext[j].off == pr->off) { > /* Store index of field vector */ > rg->fv_idx[i] = j; > + /* Mask is given by caller as big > + * endian, but sent to FW as little > + * endian > + */ > + rg->fv_mask[i] = mask << 8 | mask >> 8; > break; > } > } > @@ -4674,7 +4741,8 @@ ice_add_sw_recipe(struct ice_hw *hw, struct ice_sw_recipe *rm, > > for (i = 0; i < entry->r_group.n_val_pairs; i++) { > buf[recps].content.lkup_indx[i + 1] = entry->fv_idx[i]; > - buf[recps].content.mask[i + 1] = CPU_TO_LE16(0xFFFF); > + buf[recps].content.mask[i + 1] = > + CPU_TO_LE16(entry->fv_mask[i]); > } > > if (rm->n_grp_count > 1) { > @@ -4896,6 +4964,8 @@ ice_create_recipe_group(struct ice_hw *hw, struct ice_sw_recipe *rm, > rm->n_ext_words = lkup_exts->n_val_words; > ice_memcpy(&rm->ext_words, lkup_exts->fv_words, > sizeof(rm->ext_words), ICE_NONDMA_TO_NONDMA); > + ice_memcpy(rm->word_masks, lkup_exts->field_mask, > + sizeof(rm->word_masks), ICE_NONDMA_TO_NONDMA); > goto out; > } > > @@ -5097,16 +5167,8 @@ ice_add_adv_recipe(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups, > return status; > } > > -#define ICE_MAC_HDR_OFFSET 0 > -#define ICE_IP_HDR_OFFSET 14 > -#define ICE_GRE_HDR_OFFSET 34 > -#define ICE_MAC_IL_HDR_OFFSET 42 > -#define ICE_IP_IL_HDR_OFFSET 56 > -#define ICE_L4_HDR_OFFSET 34 > -#define ICE_UDP_TUN_HDR_OFFSET 42 > - > /** > - * ice_find_dummy_packet - find dummy packet with given match criteria > + * ice_find_dummy_packet - find dummy packet by tunnel type > * > * @lkups: lookup elements or match criteria for the advanced recipe, one > * structure per protocol header > @@ -5114,17 +5176,20 @@ ice_add_adv_recipe(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups, > * @tun_type: tunnel type from the match criteria > * @pkt: dummy packet to fill according to filter match criteria > * @pkt_len: packet length of dummy packet > + * @offsets: pointer to receive the pointer to the offsets for the packet > */ > static void > ice_find_dummy_packet(struct ice_adv_lkup_elem *lkups, u16 lkups_cnt, > enum ice_sw_tunnel_type tun_type, const u8 **pkt, > - u16 *pkt_len) > + u16 *pkt_len, > + const struct ice_dummy_pkt_offsets **offsets) > { > u16 i; > > if (tun_type == ICE_SW_TUN_NVGRE || tun_type == ICE_ALL_TUNNELS) { > *pkt = dummy_gre_packet; > *pkt_len = sizeof(dummy_gre_packet); > + *offsets = dummy_gre_packet_offsets; > return; > } > > @@ -5132,6 +5197,7 @@ ice_find_dummy_packet(struct ice_adv_lkup_elem *lkups, u16 lkups_cnt, > tun_type == ICE_SW_TUN_VXLAN_GPE) { > *pkt = dummy_udp_tun_packet; > *pkt_len = sizeof(dummy_udp_tun_packet); > + *offsets = dummy_udp_tun_packet_offsets; > return; > } > > @@ -5139,12 +5205,14 @@ ice_find_dummy_packet(struct ice_adv_lkup_elem *lkups, u16 lkups_cnt, > if (lkups[i].type == ICE_UDP_ILOS) { > *pkt = dummy_udp_tun_packet; > *pkt_len = sizeof(dummy_udp_tun_packet); > + *offsets = dummy_udp_tun_packet_offsets; > return; > } > } > > *pkt = dummy_tcp_tun_packet; > *pkt_len = sizeof(dummy_tcp_tun_packet); > + *offsets = dummy_tcp_tun_packet_offsets; > } > > /** > @@ -5153,16 +5221,16 @@ ice_find_dummy_packet(struct ice_adv_lkup_elem *lkups, u16 lkups_cnt, > * @lkups: lookup elements or match criteria for the advanced recipe, one > * structure per protocol header > * @lkups_cnt: number of protocols > - * @tun_type: to know if the dummy packet is supposed to be tunnel packet > * @s_rule: stores rule information from the match criteria > * @dummy_pkt: dummy packet to fill according to filter match criteria > * @pkt_len: packet length of dummy packet > + * @offsets: offset info for the dummy packet > */ > -static void > +static enum ice_status > ice_fill_adv_dummy_packet(struct ice_adv_lkup_elem *lkups, u16 lkups_cnt, > - enum ice_sw_tunnel_type tun_type, > struct ice_aqc_sw_rules_elem *s_rule, > - const u8 *dummy_pkt, u16 pkt_len) > + const u8 *dummy_pkt, u16 pkt_len, > + const struct ice_dummy_pkt_offsets *offsets) > { > u8 *pkt; > u16 i; > @@ -5175,124 +5243,74 @@ ice_fill_adv_dummy_packet(struct ice_adv_lkup_elem *lkups, u16 lkups_cnt, > ice_memcpy(pkt, dummy_pkt, pkt_len, ICE_NONDMA_TO_NONDMA); > > for (i = 0; i < lkups_cnt; i++) { > - u32 len, pkt_off, hdr_size, field_off; > + enum ice_protocol_type type; > + u16 offset = 0, len = 0, j; > + bool found = false; > + > + /* find the start of this layer; it should be found since this > + * was already checked when search for the dummy packet > + */ > + type = lkups[i].type; > + for (j = 0; offsets[j].type != ICE_PROTOCOL_LAST; j++) { > + if (type == offsets[j].type) { > + offset = offsets[j].offset; > + found = true; > + break; > + } > + } > + /* this should never happen in a correct calling sequence */ > + if (!found) > + return ICE_ERR_PARAM; > > switch (lkups[i].type) { > case ICE_MAC_OFOS: > case ICE_MAC_IL: > - pkt_off = offsetof(struct ice_ether_hdr, dst_addr) + > - ((lkups[i].type == ICE_MAC_IL) ? > - ICE_MAC_IL_HDR_OFFSET : 0); > - len = sizeof(lkups[i].h_u.eth_hdr.dst_addr); > - if ((tun_type == ICE_SW_TUN_VXLAN || > - tun_type == ICE_SW_TUN_GENEVE || > - tun_type == ICE_SW_TUN_VXLAN_GPE) && > - lkups[i].type == ICE_MAC_IL) { > - pkt_off += sizeof(struct ice_udp_tnl_hdr); > - } > - > - ice_memcpy(&pkt[pkt_off], > - &lkups[i].h_u.eth_hdr.dst_addr, len, > - ICE_NONDMA_TO_NONDMA); > - pkt_off = offsetof(struct ice_ether_hdr, src_addr) + > - ((lkups[i].type == ICE_MAC_IL) ? > - ICE_MAC_IL_HDR_OFFSET : 0); > - len = sizeof(lkups[i].h_u.eth_hdr.src_addr); > - if ((tun_type == ICE_SW_TUN_VXLAN || > - tun_type == ICE_SW_TUN_GENEVE || > - tun_type == ICE_SW_TUN_VXLAN_GPE) && > - lkups[i].type == ICE_MAC_IL) { > - pkt_off += sizeof(struct ice_udp_tnl_hdr); > - } > - ice_memcpy(&pkt[pkt_off], > - &lkups[i].h_u.eth_hdr.src_addr, len, > - ICE_NONDMA_TO_NONDMA); > - if (lkups[i].h_u.eth_hdr.ethtype_id) { > - pkt_off = offsetof(struct ice_ether_hdr, > - ethtype_id) + > - ((lkups[i].type == ICE_MAC_IL) ? > - ICE_MAC_IL_HDR_OFFSET : 0); > - len = sizeof(lkups[i].h_u.eth_hdr.ethtype_id); > - if ((tun_type == ICE_SW_TUN_VXLAN || > - tun_type == ICE_SW_TUN_GENEVE || > - tun_type == ICE_SW_TUN_VXLAN_GPE) && > - lkups[i].type == ICE_MAC_IL) { > - pkt_off += > - sizeof(struct ice_udp_tnl_hdr); > - } > - ice_memcpy(&pkt[pkt_off], > - &lkups[i].h_u.eth_hdr.ethtype_id, > - len, ICE_NONDMA_TO_NONDMA); > - } > + len = sizeof(struct ice_ether_hdr); > break; > case ICE_IPV4_OFOS: > - hdr_size = sizeof(struct ice_ipv4_hdr); > - if (lkups[i].h_u.ipv4_hdr.dst_addr) { > - pkt_off = ICE_IP_HDR_OFFSET + > - offsetof(struct ice_ipv4_hdr, > - dst_addr); > - field_off = offsetof(struct ice_ipv4_hdr, > - dst_addr); > - len = hdr_size - field_off; > - ice_memcpy(&pkt[pkt_off], > - &lkups[i].h_u.ipv4_hdr.dst_addr, > - len, ICE_NONDMA_TO_NONDMA); > - } > - if (lkups[i].h_u.ipv4_hdr.src_addr) { > - pkt_off = ICE_IP_HDR_OFFSET + > - offsetof(struct ice_ipv4_hdr, > - src_addr); > - field_off = offsetof(struct ice_ipv4_hdr, > - src_addr); > - len = hdr_size - field_off; > - ice_memcpy(&pkt[pkt_off], > - &lkups[i].h_u.ipv4_hdr.src_addr, > - len, ICE_NONDMA_TO_NONDMA); > - } > - break; > case ICE_IPV4_IL: > + len = sizeof(struct ice_ipv4_hdr); > break; > case ICE_TCP_IL: > + case ICE_UDP_OF: > case ICE_UDP_ILOS: > + len = sizeof(struct ice_l4_hdr); > + break; > case ICE_SCTP_IL: > - hdr_size = sizeof(struct ice_udp_tnl_hdr); > - if (lkups[i].h_u.l4_hdr.dst_port) { > - pkt_off = ICE_L4_HDR_OFFSET + > - offsetof(struct ice_l4_hdr, > - dst_port); > - field_off = offsetof(struct ice_l4_hdr, > - dst_port); > - len = hdr_size - field_off; > - ice_memcpy(&pkt[pkt_off], > - &lkups[i].h_u.l4_hdr.dst_port, > - len, ICE_NONDMA_TO_NONDMA); > - } > - if (lkups[i].h_u.l4_hdr.src_port) { > - pkt_off = ICE_L4_HDR_OFFSET + > - offsetof(struct ice_l4_hdr, src_port); > - field_off = offsetof(struct ice_l4_hdr, > - src_port); > - len = hdr_size - field_off; > - ice_memcpy(&pkt[pkt_off], > - &lkups[i].h_u.l4_hdr.src_port, > - len, ICE_NONDMA_TO_NONDMA); > - } > + len = sizeof(struct ice_sctp_hdr); > break; > case ICE_VXLAN: > case ICE_GENEVE: > case ICE_VXLAN_GPE: > - pkt_off = ICE_UDP_TUN_HDR_OFFSET + > - offsetof(struct ice_udp_tnl_hdr, vni); > - field_off = offsetof(struct ice_udp_tnl_hdr, vni); > - len = sizeof(struct ice_udp_tnl_hdr) - field_off; > - ice_memcpy(&pkt[pkt_off], &lkups[i].h_u.tnl_hdr.vni, > - len, ICE_NONDMA_TO_NONDMA); > + len = sizeof(struct ice_udp_tnl_hdr); > break; > default: > - break; > + return ICE_ERR_PARAM; > } > + > + /* the length should be a word multiple */ > + if (len % ICE_BYTES_PER_WORD) > + return ICE_ERR_CFG; > + > + /* We have the offset to the header start, the length, the > + * caller's header values and mask. Use this information to > + * copy the data into the dummy packet appropriately based on > + * the mask. Note that we need to only write the bits as > + * indicated by the mask to make sure we don't improperly write > + * over any significant packet data. > + */ > + for (j = 0; j < len / sizeof(u16); j++) > + if (((u16 *)&lkups[i].m_u)[j]) > + ((u16 *)(pkt + offset))[j] = > + (((u16 *)(pkt + offset))[j] & > + ~((u16 *)&lkups[i].m_u)[j]) | > + (((u16 *)&lkups[i].h_u)[j] & > + ((u16 *)&lkups[i].m_u)[j]); > } > + > s_rule->pdata.lkup_tx_rx.hdr_len = CPU_TO_LE16(pkt_len); > + > + return ICE_SUCCESS; > } > > /** > @@ -5446,7 +5464,7 @@ ice_adv_add_update_vsi_list(struct ice_hw *hw, > } > > /** > - * ice_add_adv_rule - create an advanced switch rule > + * ice_add_adv_rule - helper function to create an advanced switch rule > * @hw: pointer to the hardware structure > * @lkups: information on the words that needs to be looked up. All words > * together makes one recipe > @@ -5470,11 +5488,13 @@ ice_add_adv_rule(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups, > { > struct ice_adv_fltr_mgmt_list_entry *m_entry, *adv_fltr = NULL; > u16 rid = 0, i, pkt_len, rule_buf_sz, vsi_handle; > - struct ice_aqc_sw_rules_elem *s_rule; > + const struct ice_dummy_pkt_offsets *pkt_offsets; > + struct ice_aqc_sw_rules_elem *s_rule = NULL; > struct LIST_HEAD_TYPE *rule_head; > struct ice_switch_info *sw; > enum ice_status status; > const u8 *pkt = NULL; > + bool found = false; > u32 act = 0; > > if (!lkups_cnt) > @@ -5483,13 +5503,25 @@ ice_add_adv_rule(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups, > for (i = 0; i < lkups_cnt; i++) { > u16 j, *ptr; > > - /* Validate match masks to make sure they match complete 16-bit > - * words. > + /* Validate match masks to make sure that there is something > + * to match. > */ > - ptr = (u16 *)&lkups->m_u; > + ptr = (u16 *)&lkups[i].m_u; > for (j = 0; j < sizeof(lkups->m_u) / sizeof(u16); j++) > - if (ptr[j] != 0 && ptr[j] != 0xffff) > - return ICE_ERR_PARAM; > + if (ptr[j] != 0) { > + found = true; > + break; > + } > + } > + if (!found) > + return ICE_ERR_PARAM; > + > + /* make sure that we can locate a dummy packet */ > + ice_find_dummy_packet(lkups, lkups_cnt, rinfo->tun_type, &pkt, &pkt_len, > + &pkt_offsets); > + if (!pkt) { > + status = ICE_ERR_PARAM; > + goto err_ice_add_adv_rule; > } > > if (!(rinfo->sw_act.fltr_act == ICE_FWD_TO_VSI || > @@ -5530,8 +5562,6 @@ ice_add_adv_rule(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups, > } > return status; > } > - ice_find_dummy_packet(lkups, lkups_cnt, rinfo->tun_type, &pkt, > - &pkt_len); > rule_buf_sz = ICE_SW_RULE_RX_TX_NO_HDR_SIZE + pkt_len; > s_rule = (struct ice_aqc_sw_rules_elem *)ice_malloc(hw, rule_buf_sz); > if (!s_rule) > @@ -5576,8 +5606,8 @@ ice_add_adv_rule(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups, > s_rule->pdata.lkup_tx_rx.recipe_id = CPU_TO_LE16(rid); > s_rule->pdata.lkup_tx_rx.act = CPU_TO_LE32(act); > > - ice_fill_adv_dummy_packet(lkups, lkups_cnt, rinfo->tun_type, s_rule, > - pkt, pkt_len); > + ice_fill_adv_dummy_packet(lkups, lkups_cnt, s_rule, pkt, pkt_len, > + pkt_offsets); Now that ice_fill_adv_dummy_packet() propagates an error, the caller should do the same. > > status = ice_aq_sw_rules(hw, (struct ice_aqc_sw_rules *)s_rule, > rule_buf_sz, 1, ice_aqc_opc_add_sw_rules, > @@ -5753,11 +5783,12 @@ ice_rem_adv_rule(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups, > u16 lkups_cnt, struct ice_adv_rule_info *rinfo) > { > struct ice_adv_fltr_mgmt_list_entry *list_elem; > + const struct ice_dummy_pkt_offsets *offsets; > struct ice_prot_lkup_ext lkup_exts; > u16 rule_buf_sz, pkt_len, i, rid; > + struct ice_lock *rule_lock; /* Lock to protect filter rule list */ > enum ice_status status = ICE_SUCCESS; > bool remove_rule = false; > - struct ice_lock *rule_lock; /* Lock to protect filter rule list */ > const u8 *pkt = NULL; > u16 vsi_handle; > > @@ -5805,7 +5836,7 @@ ice_rem_adv_rule(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups, > struct ice_aqc_sw_rules_elem *s_rule; > > ice_find_dummy_packet(lkups, lkups_cnt, rinfo->tun_type, &pkt, > - &pkt_len); > + &pkt_len, &offsets); > rule_buf_sz = ICE_SW_RULE_RX_TX_NO_HDR_SIZE + pkt_len; > s_rule = > (struct ice_aqc_sw_rules_elem *)ice_malloc(hw, > diff --git a/drivers/net/ice/base/ice_switch.h b/drivers/net/ice/base/ice_switch.h > index 05b1170c9..db79e41eb 100644 > --- a/drivers/net/ice/base/ice_switch.h > +++ b/drivers/net/ice/base/ice_switch.h > @@ -192,6 +192,7 @@ struct ice_sw_recipe { > * recipe > */ > struct ice_fv_word ext_words[ICE_MAX_CHAIN_WORDS]; > + u16 word_masks[ICE_MAX_CHAIN_WORDS]; > > /* if this recipe is a collection of other recipe */ > u8 big_recp; >