[47/49] net/ice/base: enable additional switch rules

Message ID 20190604054248.68510-48-leyi.rong@intel.com
State Superseded
Delegated to: Qi Zhang
Headers show
Series
  • shared code update
Related show

Checks

Context Check Description
ci/Intel-compilation fail Compilation issues
ci/checkpatch success coding style OK

Commit Message

Leyi Rong June 4, 2019, 5:42 a.m.
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 <dan.nowlin@intel.com>
Signed-off-by: Paul M Stillwell Jr <paul.m.stillwell.jr@intel.com>
Signed-off-by: Leyi Rong <leyi.rong@intel.com>
---
 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(-)

Comments

Maxime Coquelin June 5, 2019, 12:24 p.m. | #1
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 <dan.nowlin@intel.com>
> Signed-off-by: Paul M Stillwell Jr <paul.m.stillwell.jr@intel.com>
> Signed-off-by: Leyi Rong <leyi.rong@intel.com>
> ---
>   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;
>
Stillwell Jr, Paul M June 5, 2019, 4:34 p.m. | #2
> -----Original Message-----
> From: Maxime Coquelin <maxime.coquelin@redhat.com>
> Sent: Wednesday, June 5, 2019 5:24 AM
> To: Rong, Leyi <leyi.rong@intel.com>; Zhang, Qi Z <qi.z.zhang@intel.com>
> Cc: dev@dpdk.org; Nowlin, Dan <dan.nowlin@intel.com>; Stillwell Jr, Paul M
> <paul.m.stillwell.jr@intel.com>
> Subject: Re: [dpdk-dev] [PATCH 47/49] net/ice/base: enable additional
> switch rules
> 
> 
> 
> 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 <dan.nowlin@intel.com>
> > Signed-off-by: Paul M Stillwell Jr <paul.m.stillwell.jr@intel.com>
> > Signed-off-by: Leyi Rong <leyi.rong@intel.com>
> > ---
> >   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.
> 

OK, can we accept this patch and have a separate patch that propagates the error? It will take some time to get a patch that propagates the error done.

> >
> >   	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;
> >
Maxime Coquelin June 7, 2019, 12:41 p.m. | #3
On 6/5/19 6:34 PM, Stillwell Jr, Paul M wrote:
>>>    	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.
>>
> OK, can we accept this patch and have a separate patch that propagates the error? It will take some time to get a patch that propagates the error done.
> 

I'm OK with that, do you think it can be done for v19.08?
Stillwell Jr, Paul M June 7, 2019, 3:58 p.m. | #4
> -----Original Message-----
> From: Maxime Coquelin <maxime.coquelin@redhat.com>
> Sent: Friday, June 7, 2019 5:41 AM
> To: Stillwell Jr, Paul M <paul.m.stillwell.jr@intel.com>; Rong, Leyi
> <leyi.rong@intel.com>; Zhang, Qi Z <qi.z.zhang@intel.com>
> Cc: dev@dpdk.org; Nowlin, Dan <dan.nowlin@intel.com>
> Subject: Re: [dpdk-dev] [PATCH 47/49] net/ice/base: enable additional
> switch rules
> 
> 
> 
> On 6/5/19 6:34 PM, Stillwell Jr, Paul M wrote:
> >>>    	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.
> >>
> > OK, can we accept this patch and have a separate patch that propagates
> the error? It will take some time to get a patch that propagates the error
> done.
> >
> 
> I'm OK with that, do you think it can be done for v19.08?

I believe it will be done for 19.08, it just takes some time due to internal review process. As an FYI: the internal patch that I created to fix this has exposed an issue in our internal testing so thanks for that!

Patch

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);
 
 	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;