Commit 1b699f81 authored by Alexander Lobakin's avatar Alexander Lobakin Committed by Tony Nguyen
Browse files

ice: switch: use a struct to pass packet template params 



ice_find_dummy_packet() contains a lot of boilerplate code and a
nice room for copy-paste mistakes.
Instead of passing 3 separate pointers back and forth to get packet
template (dummy) params, directly return a structure containing
them. Then, use a macro to compose compound literals and avoid code
duplication on return path.
Now, dummy packet type/name is needed only once to return a full
correct triple pkt-pkt_len-offsets, and those are all one-liners.
dummy_ipv4_gtpu_ipv4_packet_offsets is just moved around and renamed
(as well as dummy_ipv6_gtp_packet_offsets) with no function changes.

Signed-off-by: default avatarAlexander Lobakin <alexandr.lobakin@intel.com>
Reviewed-by: default avatarMichal Swiatkowski <michal.swiatkowski@linux.intel.com>
Tested-by: default avatarMarcin Szycik <marcin.szycik@linux.intel.com>
Tested-by: default avatarSandeep Penigalapati <sandeep.penigalapati@intel.com>
Signed-off-by: default avatarTony Nguyen <anthony.l.nguyen@intel.com>
parent 27ffa273

drivers/net/ethernet/intel/ice/ice_switch.c

+94 −174
Original line number Diff line number Diff line
@@ -35,6 +35,20 @@ struct ice_dummy_pkt_offsets { 
	u16 offset; /* ICE_PROTOCOL_LAST indicates end of list */

};



struct ice_dummy_pkt_profile {

	const struct ice_dummy_pkt_offsets *offsets;

	const u8 *pkt;

	u16 pkt_len;

};



#define ICE_PKT_PROFILE(type) ({					\

	(struct ice_dummy_pkt_profile){					\

		.pkt		= dummy_##type##_packet,		\

		.pkt_len	= sizeof(dummy_##type##_packet),	\

		.offsets	= dummy_##type##_packet_offsets,	\

	};								\

})



static const struct ice_dummy_pkt_offsets dummy_gre_tcp_packet_offsets[] = {

	{ ICE_MAC_OFOS,		0 },

	{ ICE_ETYPE_OL,		12 },
@@ -1141,6 +1155,15 @@ static const u8 dummy_ipv6_gtpu_ipv6_udp_packet[] = { 
	0x00, 0x00, /* 2 bytes for 4 byte alignment */

};



static const

struct ice_dummy_pkt_offsets dummy_ipv4_gtpu_ipv4_packet_offsets[] = {

	{ ICE_MAC_OFOS,		0 },

	{ ICE_IPV4_OFOS,	14 },

	{ ICE_UDP_OF,		34 },

	{ ICE_GTP_NO_PAY,	42 },

	{ ICE_PROTOCOL_LAST,	0 },

};



static const u8 dummy_ipv4_gtpu_ipv4_packet[] = {

	0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */

	0x00, 0x00, 0x00, 0x00,
@@ -1172,16 +1195,7 @@ static const u8 dummy_ipv4_gtpu_ipv4_packet[] = { 
};



static const

struct ice_dummy_pkt_offsets dummy_ipv4_gtp_no_pay_packet_offsets[] = {

	{ ICE_MAC_OFOS,		0 },

	{ ICE_IPV4_OFOS,	14 },

	{ ICE_UDP_OF,		34 },

	{ ICE_GTP_NO_PAY,	42 },

	{ ICE_PROTOCOL_LAST,	0 },

};



static const

struct ice_dummy_pkt_offsets dummy_ipv6_gtp_no_pay_packet_offsets[] = {

struct ice_dummy_pkt_offsets dummy_ipv6_gtp_packet_offsets[] = {

	{ ICE_MAC_OFOS,		0 },

	{ ICE_IPV6_OFOS,	14 },

	{ ICE_UDP_OF,		54 },
@@ -5501,15 +5515,12 @@ ice_add_adv_recipe(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups, 
 *	   structure per protocol header

 * @lkups_cnt: number of protocols

 * @tun_type: tunnel type

 * @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

 *

 * Returns the &ice_dummy_pkt_profile corresponding to these lookup params.

 */

static void

static struct ice_dummy_pkt_profile

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,

		      const struct ice_dummy_pkt_offsets **offsets)

		      enum ice_sw_tunnel_type tun_type)

{

	bool inner_tcp = false, inner_udp = false, outer_ipv6 = false;

	bool vlan = false, inner_ipv6 = false, gtp_no_pay = false;
@@ -5545,168 +5556,86 @@ ice_find_dummy_packet(struct ice_adv_lkup_elem *lkups, u16 lkups_cnt, 
	if (tun_type == ICE_SW_TUN_GTPU) {

		if (outer_ipv6) {

			if (gtp_no_pay) {

				*pkt = dummy_ipv6_gtp_packet;

				*pkt_len = sizeof(dummy_ipv6_gtp_packet);

				*offsets = dummy_ipv6_gtp_no_pay_packet_offsets;

				return ICE_PKT_PROFILE(ipv6_gtp);

			} else if (inner_ipv6) {

				if (inner_udp) {

					*pkt = dummy_ipv6_gtpu_ipv6_udp_packet;

					*pkt_len = sizeof(dummy_ipv6_gtpu_ipv6_udp_packet);

					*offsets = dummy_ipv6_gtpu_ipv6_udp_packet_offsets;

				} else {

					*pkt = dummy_ipv6_gtpu_ipv6_tcp_packet;

					*pkt_len = sizeof(dummy_ipv6_gtpu_ipv6_tcp_packet);

					*offsets = dummy_ipv6_gtpu_ipv6_tcp_packet_offsets;

				}

			} else {

				if (inner_udp) {

					*pkt = dummy_ipv6_gtpu_ipv4_udp_packet;

					*pkt_len = sizeof(dummy_ipv6_gtpu_ipv4_udp_packet);

					*offsets = dummy_ipv6_gtpu_ipv4_udp_packet_offsets;

				if (inner_udp)

					return ICE_PKT_PROFILE(ipv6_gtpu_ipv6_udp);

				else

					return ICE_PKT_PROFILE(ipv6_gtpu_ipv6_tcp);

			} else {

					*pkt = dummy_ipv6_gtpu_ipv4_tcp_packet;

					*pkt_len = sizeof(dummy_ipv6_gtpu_ipv4_tcp_packet);

					*offsets = dummy_ipv6_gtpu_ipv4_tcp_packet_offsets;

				}

				if (inner_udp)

					return ICE_PKT_PROFILE(ipv6_gtpu_ipv4_udp);

				else

					return ICE_PKT_PROFILE(ipv6_gtpu_ipv4_tcp);

			}

		} else {

			if (gtp_no_pay) {

				*pkt = dummy_ipv4_gtpu_ipv4_packet;

				*pkt_len = sizeof(dummy_ipv4_gtpu_ipv4_packet);

				*offsets = dummy_ipv4_gtp_no_pay_packet_offsets;

				return ICE_PKT_PROFILE(ipv4_gtpu_ipv4);

			} else if (inner_ipv6) {

				if (inner_udp) {

					*pkt = dummy_ipv4_gtpu_ipv6_udp_packet;

					*pkt_len = sizeof(dummy_ipv4_gtpu_ipv6_udp_packet);

					*offsets = dummy_ipv4_gtpu_ipv6_udp_packet_offsets;

				} else {

					*pkt = dummy_ipv4_gtpu_ipv6_tcp_packet;

					*pkt_len = sizeof(dummy_ipv4_gtpu_ipv6_tcp_packet);

					*offsets = dummy_ipv4_gtpu_ipv6_tcp_packet_offsets;

				}

			} else {

				if (inner_udp) {

					*pkt = dummy_ipv4_gtpu_ipv4_udp_packet;

					*pkt_len = sizeof(dummy_ipv4_gtpu_ipv4_udp_packet);

					*offsets = dummy_ipv4_gtpu_ipv4_udp_packet_offsets;

				if (inner_udp)

					return ICE_PKT_PROFILE(ipv4_gtpu_ipv6_udp);

				else

					return ICE_PKT_PROFILE(ipv4_gtpu_ipv6_tcp);

			} else {

					*pkt = dummy_ipv4_gtpu_ipv4_tcp_packet;

					*pkt_len = sizeof(dummy_ipv4_gtpu_ipv4_tcp_packet);

					*offsets = dummy_ipv4_gtpu_ipv4_tcp_packet_offsets;

				if (inner_udp)

					return ICE_PKT_PROFILE(ipv4_gtpu_ipv4_udp);

				else

					return ICE_PKT_PROFILE(ipv4_gtpu_ipv4_tcp);

			}

		}

	}

		return;

	}



	if (tun_type == ICE_SW_TUN_GTPC) {

		if (outer_ipv6) {

			*pkt = dummy_ipv6_gtp_packet;

			*pkt_len = sizeof(dummy_ipv6_gtp_packet);

			*offsets = dummy_ipv6_gtp_no_pay_packet_offsets;

		} else {

			*pkt = dummy_ipv4_gtpu_ipv4_packet;

			*pkt_len = sizeof(dummy_ipv4_gtpu_ipv4_packet);

			*offsets = dummy_ipv4_gtp_no_pay_packet_offsets;

		}

		return;

		if (outer_ipv6)

			return ICE_PKT_PROFILE(ipv6_gtp);

		else

			return ICE_PKT_PROFILE(ipv4_gtpu_ipv4);

	}



	if (tun_type == ICE_SW_TUN_NVGRE) {

		if (inner_tcp && inner_ipv6) {

			*pkt = dummy_gre_ipv6_tcp_packet;

			*pkt_len = sizeof(dummy_gre_ipv6_tcp_packet);

			*offsets = dummy_gre_ipv6_tcp_packet_offsets;

			return;

		}

		if (inner_tcp) {

			*pkt = dummy_gre_tcp_packet;

			*pkt_len = sizeof(dummy_gre_tcp_packet);

			*offsets = dummy_gre_tcp_packet_offsets;

			return;

		}

		if (inner_ipv6) {

			*pkt = dummy_gre_ipv6_udp_packet;

			*pkt_len = sizeof(dummy_gre_ipv6_udp_packet);

			*offsets = dummy_gre_ipv6_udp_packet_offsets;

			return;

		}

		*pkt = dummy_gre_udp_packet;

		*pkt_len = sizeof(dummy_gre_udp_packet);

		*offsets = dummy_gre_udp_packet_offsets;

		return;

		if (inner_tcp && inner_ipv6)

			return ICE_PKT_PROFILE(gre_ipv6_tcp);

		else if (inner_tcp)

			return ICE_PKT_PROFILE(gre_tcp);

		else if (inner_ipv6)

			return ICE_PKT_PROFILE(gre_ipv6_udp);

		else

			return ICE_PKT_PROFILE(gre_udp);

	}



	if (tun_type == ICE_SW_TUN_VXLAN ||

	    tun_type == ICE_SW_TUN_GENEVE) {

		if (inner_tcp && inner_ipv6) {

			*pkt = dummy_udp_tun_ipv6_tcp_packet;

			*pkt_len = sizeof(dummy_udp_tun_ipv6_tcp_packet);

			*offsets = dummy_udp_tun_ipv6_tcp_packet_offsets;

			return;

		}

		if (inner_tcp) {

			*pkt = dummy_udp_tun_tcp_packet;

			*pkt_len = sizeof(dummy_udp_tun_tcp_packet);

			*offsets = dummy_udp_tun_tcp_packet_offsets;

			return;

		}

		if (inner_ipv6) {

			*pkt = dummy_udp_tun_ipv6_udp_packet;

			*pkt_len = sizeof(dummy_udp_tun_ipv6_udp_packet);

			*offsets = dummy_udp_tun_ipv6_udp_packet_offsets;

			return;

		}

		*pkt = dummy_udp_tun_udp_packet;

		*pkt_len = sizeof(dummy_udp_tun_udp_packet);

		*offsets = dummy_udp_tun_udp_packet_offsets;

		return;

		if (inner_tcp && inner_ipv6)

			return ICE_PKT_PROFILE(udp_tun_ipv6_tcp);

		else if (inner_tcp)

			return ICE_PKT_PROFILE(udp_tun_tcp);

		else if (inner_ipv6)

			return ICE_PKT_PROFILE(udp_tun_ipv6_udp);

		else

			return ICE_PKT_PROFILE(udp_tun_udp);

	}



	if (inner_udp && !outer_ipv6) {

		if (vlan) {

			*pkt = dummy_vlan_udp_packet;

			*pkt_len = sizeof(dummy_vlan_udp_packet);

			*offsets = dummy_vlan_udp_packet_offsets;

			return;

		}

		*pkt = dummy_udp_packet;

		*pkt_len = sizeof(dummy_udp_packet);

		*offsets = dummy_udp_packet_offsets;

		return;

		if (vlan)

			return ICE_PKT_PROFILE(vlan_udp);

		else

			return ICE_PKT_PROFILE(udp);

	} else if (inner_udp && outer_ipv6) {

		if (vlan) {

			*pkt = dummy_vlan_udp_ipv6_packet;

			*pkt_len = sizeof(dummy_vlan_udp_ipv6_packet);

			*offsets = dummy_vlan_udp_ipv6_packet_offsets;

			return;

		}

		*pkt = dummy_udp_ipv6_packet;

		*pkt_len = sizeof(dummy_udp_ipv6_packet);

		*offsets = dummy_udp_ipv6_packet_offsets;

		return;

		if (vlan)

			return ICE_PKT_PROFILE(vlan_udp_ipv6);

		else

			return ICE_PKT_PROFILE(udp_ipv6);

	} else if ((inner_tcp && outer_ipv6) || outer_ipv6) {

		if (vlan) {

			*pkt = dummy_vlan_tcp_ipv6_packet;

			*pkt_len = sizeof(dummy_vlan_tcp_ipv6_packet);

			*offsets = dummy_vlan_tcp_ipv6_packet_offsets;

			return;

		}

		*pkt = dummy_tcp_ipv6_packet;

		*pkt_len = sizeof(dummy_tcp_ipv6_packet);

		*offsets = dummy_tcp_ipv6_packet_offsets;

		return;

		if (vlan)

			return ICE_PKT_PROFILE(vlan_tcp_ipv6);

		else

			return ICE_PKT_PROFILE(tcp_ipv6);

	}



	if (vlan) {

		*pkt = dummy_vlan_tcp_packet;

		*pkt_len = sizeof(dummy_vlan_tcp_packet);

		*offsets = dummy_vlan_tcp_packet_offsets;

	} else {

		*pkt = dummy_tcp_packet;

		*pkt_len = sizeof(dummy_tcp_packet);

		*offsets = dummy_tcp_packet_offsets;

	}

	if (vlan)

		return ICE_PKT_PROFILE(vlan_tcp);



	return ICE_PKT_PROFILE(tcp);

}



/**
@@ -5716,15 +5645,12 @@ ice_find_dummy_packet(struct ice_adv_lkup_elem *lkups, u16 lkups_cnt, 
 *	   structure per protocol header

 * @lkups_cnt: number of protocols

 * @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

 * @profile: dummy packet profile (the template, its size and header offsets)

 */

static int

ice_fill_adv_dummy_packet(struct ice_adv_lkup_elem *lkups, u16 lkups_cnt,

			  struct ice_aqc_sw_rules_elem *s_rule,

			  const u8 *dummy_pkt, u16 pkt_len,

			  const struct ice_dummy_pkt_offsets *offsets)

			  const struct ice_dummy_pkt_profile *profile)

{

	u8 *pkt;

	u16 i;
@@ -5734,9 +5660,10 @@ ice_fill_adv_dummy_packet(struct ice_adv_lkup_elem *lkups, u16 lkups_cnt, 
	 */

	pkt = s_rule->pdata.lkup_tx_rx.hdr;



	memcpy(pkt, dummy_pkt, pkt_len);

	memcpy(pkt, profile->pkt, profile->pkt_len);



	for (i = 0; i < lkups_cnt; i++) {

		const struct ice_dummy_pkt_offsets *offsets = profile->offsets;

		enum ice_protocol_type type;

		u16 offset = 0, len = 0, j;

		bool found = false;
@@ -5821,7 +5748,7 @@ ice_fill_adv_dummy_packet(struct ice_adv_lkup_elem *lkups, u16 lkups_cnt, 
		}

	}



	s_rule->pdata.lkup_tx_rx.hdr_len = cpu_to_le16(pkt_len);

	s_rule->pdata.lkup_tx_rx.hdr_len = cpu_to_le16(profile->pkt_len);



	return 0;

}
@@ -6044,12 +5971,11 @@ ice_add_adv_rule(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups, 
		 struct ice_rule_query_data *added_entry)

{

	struct ice_adv_fltr_mgmt_list_entry *m_entry, *adv_fltr = NULL;

	u16 rid = 0, i, pkt_len, rule_buf_sz, vsi_handle;

	const struct ice_dummy_pkt_offsets *pkt_offsets;

	struct ice_aqc_sw_rules_elem *s_rule = NULL;

	u16 rid = 0, i, rule_buf_sz, vsi_handle;

	struct ice_dummy_pkt_profile profile;

	struct list_head *rule_head;

	struct ice_switch_info *sw;

	const u8 *pkt = NULL;

	u16 word_cnt;

	u32 act = 0;

	int status;
@@ -6077,13 +6003,8 @@ ice_add_adv_rule(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups, 
	if (!word_cnt || word_cnt > ICE_MAX_CHAIN_WORDS)

		return -EINVAL;



	/* 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 = -EINVAL;

		goto err_ice_add_adv_rule;

	}

	/* locate a dummy packet */

	profile = ice_find_dummy_packet(lkups, lkups_cnt, rinfo->tun_type);



	if (!(rinfo->sw_act.fltr_act == ICE_FWD_TO_VSI ||

	      rinfo->sw_act.fltr_act == ICE_FWD_TO_Q ||
@@ -6124,7 +6045,7 @@ ice_add_adv_rule(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups, 
		}

		return status;

	}

	rule_buf_sz = ICE_SW_RULE_RX_TX_NO_HDR_SIZE + pkt_len;

	rule_buf_sz = ICE_SW_RULE_RX_TX_NO_HDR_SIZE + profile.pkt_len;

	s_rule = kzalloc(rule_buf_sz, GFP_KERNEL);

	if (!s_rule)

		return -ENOMEM;
@@ -6184,8 +6105,7 @@ 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);



	status = ice_fill_adv_dummy_packet(lkups, lkups_cnt, s_rule, pkt,

					   pkt_len, pkt_offsets);

	status = ice_fill_adv_dummy_packet(lkups, lkups_cnt, s_rule, &profile);

	if (status)

		goto err_ice_add_adv_rule;
@@ -6193,7 +6113,7 @@ ice_add_adv_rule(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups, 
	    rinfo->tun_type != ICE_SW_TUN_AND_NON_TUN) {

		status = ice_fill_adv_packet_tun(hw, rinfo->tun_type,

						 s_rule->pdata.lkup_tx_rx.hdr,

						 pkt_offsets);

						 profile.offsets);

		if (status)

			goto err_ice_add_adv_rule;

	}