[dpdk-dev] [PATCH 47/49] net/ice/base: enable additional switch rules
Stillwell Jr, Paul M
paul.m.stillwell.jr at intel.com
Wed Jun 5 18:34:17 CEST 2019
> -----Original Message-----
> From: Maxime Coquelin <maxime.coquelin at redhat.com>
> Sent: Wednesday, June 5, 2019 5:24 AM
> To: Rong, Leyi <leyi.rong at intel.com>; Zhang, Qi Z <qi.z.zhang at intel.com>
> Cc: dev at dpdk.org; Nowlin, Dan <dan.nowlin at intel.com>; Stillwell Jr, Paul M
> <paul.m.stillwell.jr at 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 at intel.com>
> > Signed-off-by: Paul M Stillwell Jr <paul.m.stillwell.jr at intel.com>
> > Signed-off-by: Leyi Rong <leyi.rong at 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;
> >
More information about the dev
mailing list