From: Qi Zhang Date: Tue, 20 Oct 2020 02:43:08 +0000 (+0800) Subject: net/ice/base: refactor RSS configure API X-Git-Url: http://git.droids-corp.org/?a=commitdiff_plain;h=16187528a923;p=dpdk.git net/ice/base: refactor RSS configure API Use struct ice_rss_hash_cfg as parameter for ice_add_rss_cfg, ice_add_rss_cfg_sync and ice_rem_rss_cfg, ice_rem_rss_cfg_sync. Introduce enmu ice_rss_cfg_hdr_type to allow user specify the more flexible RSS configure. ICE_RSS_OUTER_HEADERS - take outer layer as RSS inputset ICE_RSS_INNER_HEADERS - take inner layer as RSS inputset ICE_RSS_INNER_HEADERS_W_OUTER_IPV4 - take inner layer as RSS inputset for packet with outer IPV4 ICE_RSS_INNER_HEADERS_W_OUTER_IPV6 - take inner layer as RSS inputset for packet with outer IPV6 ICE_RSS_ANY_HEADERS - try with outer first then inner (same as the behaviour without this change) Signed-off-by: Qi Zhang Acked-by: Qiming Yang --- diff --git a/drivers/net/ice/base/ice_flow.c b/drivers/net/ice/base/ice_flow.c index 4512b12368..1b36c2b897 100644 --- a/drivers/net/ice/base/ice_flow.c +++ b/drivers/net/ice/base/ice_flow.c @@ -3244,37 +3244,49 @@ ice_flow_add_fld_raw(struct ice_flow_seg_info *seg, u16 off, u8 len, /** * ice_flow_set_rss_seg_info - setup packet segments for RSS * @segs: pointer to the flow field segment(s) - * @hash_fields: fields to be hashed on for the segment(s) - * @flow_hdr: protocol header fields within a packet segment + * @seg_cnt: segment count + * @cfg: configure parameters * * Helper function to extract fields from hash bitmap and use flow * header value to set flow field segment for further use in flow * profile entry or removal. */ static enum ice_status -ice_flow_set_rss_seg_info(struct ice_flow_seg_info *segs, u64 hash_fields, - u32 flow_hdr) +ice_flow_set_rss_seg_info(struct ice_flow_seg_info *segs, u8 seg_cnt, + const struct ice_rss_hash_cfg *cfg) { + struct ice_flow_seg_info *seg; u64 val; u8 i; - ice_for_each_set_bit(i, (ice_bitmap_t *)&hash_fields, + /* set inner most segment */ + seg = &segs[seg_cnt - 1]; + + ice_for_each_set_bit(i, (const ice_bitmap_t *)&cfg->hash_flds, ICE_FLOW_FIELD_IDX_MAX) - ice_flow_set_fld(segs, (enum ice_flow_field)i, + ice_flow_set_fld(seg, (enum ice_flow_field)i, ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL, false); - ICE_FLOW_SET_HDRS(segs, flow_hdr); + ICE_FLOW_SET_HDRS(seg, cfg->addl_hdrs); + + /* set outer most header */ + if (cfg->hdr_type == ICE_RSS_INNER_HEADERS_W_OUTER_IPV4) + segs[ICE_RSS_OUTER_HEADERS].hdrs |= ICE_FLOW_SEG_HDR_IPV4 | + ICE_FLOW_SEG_HDR_IPV_OTHER; + else if (cfg->hdr_type == ICE_RSS_INNER_HEADERS_W_OUTER_IPV6) + segs[ICE_RSS_OUTER_HEADERS].hdrs |= ICE_FLOW_SEG_HDR_IPV6 | + ICE_FLOW_SEG_HDR_IPV_OTHER; - if (segs->hdrs & ~ICE_FLOW_RSS_SEG_HDR_VAL_MASKS & + if (seg->hdrs & ~ICE_FLOW_RSS_SEG_HDR_VAL_MASKS & ~ICE_FLOW_RSS_HDRS_INNER_MASK & ~ICE_FLOW_SEG_HDR_IPV_OTHER) return ICE_ERR_PARAM; - val = (u64)(segs->hdrs & ICE_FLOW_RSS_SEG_HDR_L3_MASKS); + val = (u64)(seg->hdrs & ICE_FLOW_RSS_SEG_HDR_L3_MASKS); if (val && !ice_is_pow2(val)) return ICE_ERR_CFG; - val = (u64)(segs->hdrs & ICE_FLOW_RSS_SEG_HDR_L4_MASKS); + val = (u64)(seg->hdrs & ICE_FLOW_RSS_SEG_HDR_L4_MASKS); if (val && !ice_is_pow2(val)) return ICE_ERR_CFG; @@ -3346,6 +3358,29 @@ enum ice_status ice_rem_vsi_rss_cfg(struct ice_hw *hw, u16 vsi_handle) return status; } +/** + * ice_get_rss_hdr_type - get a RSS profile's header type + * @prof: RSS flow profile + */ +static enum ice_rss_cfg_hdr_type +ice_get_rss_hdr_type(struct ice_flow_prof *prof) +{ + enum ice_rss_cfg_hdr_type hdr_type = ICE_RSS_ANY_HEADERS; + + if (prof->segs_cnt == ICE_FLOW_SEG_SINGLE) { + hdr_type = ICE_RSS_OUTER_HEADERS; + } else if (prof->segs_cnt == ICE_FLOW_SEG_MAX) { + if (prof->segs[ICE_RSS_OUTER_HEADERS].hdrs == ICE_FLOW_SEG_HDR_NONE) + hdr_type = ICE_RSS_INNER_HEADERS; + if (prof->segs[ICE_RSS_OUTER_HEADERS].hdrs & ICE_FLOW_SEG_HDR_IPV4) + hdr_type = ICE_RSS_INNER_HEADERS_W_OUTER_IPV4; + if (prof->segs[ICE_RSS_OUTER_HEADERS].hdrs & ICE_FLOW_SEG_HDR_IPV6) + hdr_type = ICE_RSS_INNER_HEADERS_W_OUTER_IPV6; + } + + return hdr_type; +} + /** * ice_rem_rss_list - remove RSS configuration from list * @hw: pointer to the hardware structure @@ -3357,16 +3392,19 @@ enum ice_status ice_rem_vsi_rss_cfg(struct ice_hw *hw, u16 vsi_handle) static void ice_rem_rss_list(struct ice_hw *hw, u16 vsi_handle, struct ice_flow_prof *prof) { + enum ice_rss_cfg_hdr_type hdr_type; struct ice_rss_cfg *r, *tmp; /* Search for RSS hash fields associated to the VSI that match the * hash configurations associated to the flow profile. If found * remove from the RSS entry list of the VSI context and delete entry. */ + hdr_type = ice_get_rss_hdr_type(prof); LIST_FOR_EACH_ENTRY_SAFE(r, tmp, &hw->rss_list_head, ice_rss_cfg, l_entry) - if (r->hashed_flds == prof->segs[prof->segs_cnt - 1].match && - r->packet_hdr == prof->segs[prof->segs_cnt - 1].hdrs) { + if (r->hash.hash_flds == prof->segs[prof->segs_cnt - 1].match && + r->hash.addl_hdrs == prof->segs[prof->segs_cnt - 1].hdrs && + r->hash.hdr_type == hdr_type) { ice_clear_bit(vsi_handle, r->vsis); if (!ice_is_any_bit_set(r->vsis, ICE_MAX_VSI)) { LIST_DEL(&r->l_entry); @@ -3387,12 +3425,15 @@ ice_rem_rss_list(struct ice_hw *hw, u16 vsi_handle, struct ice_flow_prof *prof) static enum ice_status ice_add_rss_list(struct ice_hw *hw, u16 vsi_handle, struct ice_flow_prof *prof) { + enum ice_rss_cfg_hdr_type hdr_type; struct ice_rss_cfg *r, *rss_cfg; + hdr_type = ice_get_rss_hdr_type(prof); LIST_FOR_EACH_ENTRY(r, &hw->rss_list_head, ice_rss_cfg, l_entry) - if (r->hashed_flds == prof->segs[prof->segs_cnt - 1].match && - r->packet_hdr == prof->segs[prof->segs_cnt - 1].hdrs) { + if (r->hash.hash_flds == prof->segs[prof->segs_cnt - 1].match && + r->hash.addl_hdrs == prof->segs[prof->segs_cnt - 1].hdrs && + r->hash.hdr_type == hdr_type) { ice_set_bit(vsi_handle, r->vsis); return ICE_SUCCESS; } @@ -3401,9 +3442,10 @@ ice_add_rss_list(struct ice_hw *hw, u16 vsi_handle, struct ice_flow_prof *prof) if (!rss_cfg) return ICE_ERR_NO_MEMORY; - rss_cfg->hashed_flds = prof->segs[prof->segs_cnt - 1].match; - rss_cfg->packet_hdr = prof->segs[prof->segs_cnt - 1].hdrs; - rss_cfg->symm = prof->cfg.symm; + rss_cfg->hash.hash_flds = prof->segs[prof->segs_cnt - 1].match; + rss_cfg->hash.addl_hdrs = prof->segs[prof->segs_cnt - 1].hdrs; + rss_cfg->hash.hdr_type = hdr_type; + rss_cfg->hash.symm = prof->cfg.symm; ice_set_bit(vsi_handle, rss_cfg->vsis); LIST_ADD_TAIL(&rss_cfg->l_entry, &hw->rss_list_head); @@ -3415,21 +3457,22 @@ ice_add_rss_list(struct ice_hw *hw, u16 vsi_handle, struct ice_flow_prof *prof) #define ICE_FLOW_PROF_HASH_M (0xFFFFFFFFULL << ICE_FLOW_PROF_HASH_S) #define ICE_FLOW_PROF_HDR_S 32 #define ICE_FLOW_PROF_HDR_M (0x3FFFFFFFULL << ICE_FLOW_PROF_HDR_S) -#define ICE_FLOW_PROF_ENCAP_S 63 -#define ICE_FLOW_PROF_ENCAP_M (BIT_ULL(ICE_FLOW_PROF_ENCAP_S)) - -#define ICE_RSS_OUTER_HEADERS 1 -#define ICE_RSS_INNER_HEADERS 2 +#define ICE_FLOW_PROF_ENCAP_S 62 +#define ICE_FLOW_PROF_ENCAP_M (0x3ULL << ICE_FLOW_PROF_ENCAP_S) /* Flow profile ID format: * [0:31] - Packet match fields - * [32:62] - Protocol header - * [63] - Encapsulation flag, 0 if non-tunneled, 1 if tunneled + * [32:61] - Protocol header + * [62:63] - Encapsulation flag: + * 0 if non-tunneled + * 1 if tunneled + * 2 for tunneled with outer ipv4 + * 3 for tunneled with outer ipv6 */ -#define ICE_FLOW_GEN_PROFID(hash, hdr, segs_cnt) \ +#define ICE_FLOW_GEN_PROFID(hash, hdr, encap) \ (u64)(((u64)(hash) & ICE_FLOW_PROF_HASH_M) | \ (((u64)(hdr) << ICE_FLOW_PROF_HDR_S) & ICE_FLOW_PROF_HDR_M) | \ - ((u8)((segs_cnt) - 1) ? ICE_FLOW_PROF_ENCAP_M : 0)) + (((u64)(encap) << ICE_FLOW_PROF_ENCAP_S) & ICE_FLOW_PROF_ENCAP_M)) static void ice_rss_config_xor_word(struct ice_hw *hw, u8 prof_id, u8 src, u8 dst) @@ -3540,24 +3583,22 @@ ice_rss_update_symm(struct ice_hw *hw, * ice_add_rss_cfg_sync - add an RSS configuration * @hw: pointer to the hardware structure * @vsi_handle: software VSI handle - * @hashed_flds: hash bit fields (ICE_FLOW_HASH_*) to configure - * @addl_hdrs: protocol header fields - * @segs_cnt: packet segment count - * @symm: symmetric hash enable/disable + * @cfg: configure parameters * * Assumption: lock has already been acquired for RSS list */ static enum ice_status -ice_add_rss_cfg_sync(struct ice_hw *hw, u16 vsi_handle, u64 hashed_flds, - u32 addl_hdrs, u8 segs_cnt, bool symm) +ice_add_rss_cfg_sync(struct ice_hw *hw, u16 vsi_handle, + const struct ice_rss_hash_cfg *cfg) { const enum ice_block blk = ICE_BLK_RSS; struct ice_flow_prof *prof = NULL; struct ice_flow_seg_info *segs; enum ice_status status; + u8 segs_cnt; - if (!segs_cnt || segs_cnt > ICE_FLOW_SEG_MAX) - return ICE_ERR_PARAM; + segs_cnt = (cfg->hdr_type == ICE_RSS_OUTER_HEADERS) ? + ICE_FLOW_SEG_SINGLE : ICE_FLOW_SEG_MAX; segs = (struct ice_flow_seg_info *)ice_calloc(hw, segs_cnt, sizeof(*segs)); @@ -3565,13 +3606,12 @@ ice_add_rss_cfg_sync(struct ice_hw *hw, u16 vsi_handle, u64 hashed_flds, return ICE_ERR_NO_MEMORY; /* Construct the packet segment info from the hashed fields */ - status = ice_flow_set_rss_seg_info(&segs[segs_cnt - 1], hashed_flds, - addl_hdrs); + status = ice_flow_set_rss_seg_info(segs, segs_cnt, cfg); if (status) goto exit; /* Don't do RSS for GTPU Outer */ - if (segs_cnt == ICE_RSS_OUTER_HEADERS && + if (segs_cnt == ICE_FLOW_SEG_SINGLE && segs[segs_cnt - 1].hdrs & ICE_FLOW_SEG_HDR_GTPU) { status = ICE_SUCCESS; goto exit; @@ -3586,9 +3626,9 @@ ice_add_rss_cfg_sync(struct ice_hw *hw, u16 vsi_handle, u64 hashed_flds, ICE_FLOW_FIND_PROF_CHK_FLDS | ICE_FLOW_FIND_PROF_CHK_VSI); if (prof) { - if (prof->cfg.symm == symm) + if (prof->cfg.symm == cfg->symm) goto exit; - prof->cfg.symm = symm; + prof->cfg.symm = cfg->symm; goto update_symm; } @@ -3621,7 +3661,7 @@ ice_add_rss_cfg_sync(struct ice_hw *hw, u16 vsi_handle, u64 hashed_flds, vsi_handle, ICE_FLOW_FIND_PROF_CHK_FLDS); if (prof) { - if (prof->cfg.symm == symm) { + if (prof->cfg.symm == cfg->symm) { status = ice_flow_assoc_prof(hw, blk, prof, vsi_handle); if (!status) @@ -3640,9 +3680,9 @@ ice_add_rss_cfg_sync(struct ice_hw *hw, u16 vsi_handle, u64 hashed_flds, * segment information. */ status = ice_flow_add_prof(hw, blk, ICE_FLOW_RX, - ICE_FLOW_GEN_PROFID(hashed_flds, + ICE_FLOW_GEN_PROFID(cfg->hash_flds, segs[segs_cnt - 1].hdrs, - segs_cnt), + cfg->hdr_type), segs, segs_cnt, NULL, 0, &prof); if (status) goto exit; @@ -3658,8 +3698,7 @@ ice_add_rss_cfg_sync(struct ice_hw *hw, u16 vsi_handle, u64 hashed_flds, status = ice_add_rss_list(hw, vsi_handle, prof); - prof->cfg.symm = symm; - + prof->cfg.symm = cfg->symm; update_symm: ice_rss_update_symm(hw, prof); @@ -3672,32 +3711,40 @@ exit: * ice_add_rss_cfg - add an RSS configuration with specified hashed fields * @hw: pointer to the hardware structure * @vsi_handle: software VSI handle - * @hashed_flds: hash bit fields (ICE_FLOW_HASH_*) to configure - * @addl_hdrs: protocol header fields - * @symm: symmetric hash enable/disable + * @cfg: configure parameters * * This function will generate a flow profile based on fields associated with * the input fields to hash on, the flow type and use the VSI number to add * a flow entry to the profile. */ enum ice_status -ice_add_rss_cfg(struct ice_hw *hw, u16 vsi_handle, u64 hashed_flds, - u32 addl_hdrs, bool symm) +ice_add_rss_cfg(struct ice_hw *hw, u16 vsi_handle, + const struct ice_rss_hash_cfg *cfg) { + struct ice_rss_hash_cfg local_cfg; enum ice_status status; - if (hashed_flds == ICE_HASH_INVALID || - !ice_is_vsi_valid(hw, vsi_handle)) + if (!ice_is_vsi_valid(hw, vsi_handle) || + !cfg || cfg->hdr_type > ICE_RSS_ANY_HEADERS || + cfg->hash_flds == ICE_HASH_INVALID) return ICE_ERR_PARAM; - ice_acquire_lock(&hw->rss_locks); - status = ice_add_rss_cfg_sync(hw, vsi_handle, hashed_flds, addl_hdrs, - ICE_RSS_OUTER_HEADERS, symm); - if (!status) - status = ice_add_rss_cfg_sync(hw, vsi_handle, hashed_flds, - addl_hdrs, ICE_RSS_INNER_HEADERS, - symm); - ice_release_lock(&hw->rss_locks); + local_cfg = *cfg; + if (cfg->hdr_type < ICE_RSS_ANY_HEADERS) { + ice_acquire_lock(&hw->rss_locks); + status = ice_add_rss_cfg_sync(hw, vsi_handle, &local_cfg); + ice_release_lock(&hw->rss_locks); + } else { + ice_acquire_lock(&hw->rss_locks); + local_cfg.hdr_type = ICE_RSS_OUTER_HEADERS; + status = ice_add_rss_cfg_sync(hw, vsi_handle, &local_cfg); + if (!status) { + local_cfg.hdr_type = ICE_RSS_INNER_HEADERS; + status = ice_add_rss_cfg_sync(hw, vsi_handle, + &local_cfg); + } + ice_release_lock(&hw->rss_locks); + } return status; } @@ -3706,34 +3753,34 @@ ice_add_rss_cfg(struct ice_hw *hw, u16 vsi_handle, u64 hashed_flds, * ice_rem_rss_cfg_sync - remove an existing RSS configuration * @hw: pointer to the hardware structure * @vsi_handle: software VSI handle - * @hashed_flds: Packet hash types (ICE_FLOW_HASH_*) to remove - * @addl_hdrs: Protocol header fields within a packet segment - * @segs_cnt: packet segment count + * @cfg: configure parameters * * Assumption: lock has already been acquired for RSS list */ static enum ice_status -ice_rem_rss_cfg_sync(struct ice_hw *hw, u16 vsi_handle, u64 hashed_flds, - u32 addl_hdrs, u8 segs_cnt) +ice_rem_rss_cfg_sync(struct ice_hw *hw, u16 vsi_handle, + const struct ice_rss_hash_cfg *cfg) { const enum ice_block blk = ICE_BLK_RSS; struct ice_flow_seg_info *segs; struct ice_flow_prof *prof; enum ice_status status; + u8 segs_cnt; + segs_cnt = (cfg->hdr_type == ICE_RSS_OUTER_HEADERS) ? + ICE_FLOW_SEG_SINGLE : ICE_FLOW_SEG_MAX; segs = (struct ice_flow_seg_info *)ice_calloc(hw, segs_cnt, sizeof(*segs)); if (!segs) return ICE_ERR_NO_MEMORY; /* Construct the packet segment info from the hashed fields */ - status = ice_flow_set_rss_seg_info(&segs[segs_cnt - 1], hashed_flds, - addl_hdrs); + status = ice_flow_set_rss_seg_info(segs, segs_cnt, cfg); if (status) goto out; /* Don't do RSS for GTPU Outer */ - if (segs_cnt == ICE_RSS_OUTER_HEADERS && + if (segs_cnt == ICE_FLOW_SEG_SINGLE && segs[segs_cnt - 1].hdrs & ICE_FLOW_SEG_HDR_GTPU) { status = ICE_SUCCESS; goto out; @@ -3768,8 +3815,7 @@ out: * ice_rem_rss_cfg - remove an existing RSS config with matching hashed fields * @hw: pointer to the hardware structure * @vsi_handle: software VSI handle - * @hashed_flds: Packet hash types (ICE_FLOW_HASH_*) to remove - * @addl_hdrs: Protocol header fields within a packet segment + * @cfg: configure parameters * * This function will lookup the flow profile based on the input * hash field bitmap, iterate through the profile entry list of @@ -3778,21 +3824,31 @@ out: * turn build or update buffers for RSS XLT1 section. */ enum ice_status -ice_rem_rss_cfg(struct ice_hw *hw, u16 vsi_handle, u64 hashed_flds, - u32 addl_hdrs) +ice_rem_rss_cfg(struct ice_hw *hw, u16 vsi_handle, + const struct ice_rss_hash_cfg *cfg) { + struct ice_rss_hash_cfg local_cfg; enum ice_status status; - if (hashed_flds == ICE_HASH_INVALID || - !ice_is_vsi_valid(hw, vsi_handle)) + if (!ice_is_vsi_valid(hw, vsi_handle) || + !cfg || cfg->hdr_type > ICE_RSS_ANY_HEADERS || + cfg->hash_flds == ICE_HASH_INVALID) return ICE_ERR_PARAM; ice_acquire_lock(&hw->rss_locks); - status = ice_rem_rss_cfg_sync(hw, vsi_handle, hashed_flds, addl_hdrs, - ICE_RSS_OUTER_HEADERS); - if (!status) - status = ice_rem_rss_cfg_sync(hw, vsi_handle, hashed_flds, - addl_hdrs, ICE_RSS_INNER_HEADERS); + local_cfg = *cfg; + if (cfg->hdr_type < ICE_RSS_ANY_HEADERS) { + status = ice_rem_rss_cfg_sync(hw, vsi_handle, &local_cfg); + } else { + local_cfg.hdr_type = ICE_RSS_OUTER_HEADERS; + status = ice_rem_rss_cfg_sync(hw, vsi_handle, &local_cfg); + + if (!status) { + local_cfg.hdr_type = ICE_RSS_INNER_HEADERS; + status = ice_rem_rss_cfg_sync(hw, vsi_handle, + &local_cfg); + } + } ice_release_lock(&hw->rss_locks); return status; @@ -3815,18 +3871,7 @@ enum ice_status ice_replay_rss_cfg(struct ice_hw *hw, u16 vsi_handle) LIST_FOR_EACH_ENTRY(r, &hw->rss_list_head, ice_rss_cfg, l_entry) { if (ice_is_bit_set(r->vsis, vsi_handle)) { - status = ice_add_rss_cfg_sync(hw, vsi_handle, - r->hashed_flds, - r->packet_hdr, - ICE_RSS_OUTER_HEADERS, - r->symm); - if (status) - break; - status = ice_add_rss_cfg_sync(hw, vsi_handle, - r->hashed_flds, - r->packet_hdr, - ICE_RSS_INNER_HEADERS, - r->symm); + status = ice_add_rss_cfg_sync(hw, vsi_handle, &r->hash); if (status) break; } @@ -3858,8 +3903,8 @@ u64 ice_get_rss_cfg(struct ice_hw *hw, u16 vsi_handle, u32 hdrs) LIST_FOR_EACH_ENTRY(r, &hw->rss_list_head, ice_rss_cfg, l_entry) if (ice_is_bit_set(r->vsis, vsi_handle) && - r->packet_hdr == hdrs) { - rss_hash = r->hashed_flds; + r->hash.addl_hdrs == hdrs) { + rss_hash = r->hash.hash_flds; break; } ice_release_lock(&hw->rss_locks); diff --git a/drivers/net/ice/base/ice_flow.h b/drivers/net/ice/base/ice_flow.h index 698a2303bc..2a9ae66454 100644 --- a/drivers/net/ice/base/ice_flow.h +++ b/drivers/net/ice/base/ice_flow.h @@ -323,6 +323,24 @@ enum ice_flow_avf_hdr_field { BIT_ULL(ICE_AVF_FLOW_FIELD_UNICAST_IPV6_UDP) | \ BIT_ULL(ICE_AVF_FLOW_FIELD_MULTICAST_IPV6_UDP)) +enum ice_rss_cfg_hdr_type { + ICE_RSS_OUTER_HEADERS, /* take outer headers as inputset. */ + ICE_RSS_INNER_HEADERS, /* take inner headers as inputset. */ + /* take inner headers as inputset for packet with outer ipv4. */ + ICE_RSS_INNER_HEADERS_W_OUTER_IPV4, + /* take inner headers as inputset for packet with outer ipv6. */ + ICE_RSS_INNER_HEADERS_W_OUTER_IPV6, + /* take outer headers first then inner headers as inputset */ + ICE_RSS_ANY_HEADERS +}; + +struct ice_rss_hash_cfg { + u32 addl_hdrs; /* protocol header fields */ + u64 hash_flds; /* hash bit field (ICE_FLOW_HASH_*) to configure */ + enum ice_rss_cfg_hdr_type hdr_type; /* to specify inner or outer */ + bool symm; /* symmetric or asymmetric hash */ +}; + enum ice_flow_dir { ICE_FLOW_DIR_UNDEFINED = 0, ICE_FLOW_TX = 0x01, @@ -336,6 +354,7 @@ enum ice_flow_priority { ICE_FLOW_PRIO_HIGH }; +#define ICE_FLOW_SEG_SINGLE 1 #define ICE_FLOW_SEG_MAX 2 #define ICE_FLOW_SEG_RAW_FLD_MAX 2 #define ICE_FLOW_PROFILE_MAX 1024 @@ -440,8 +459,7 @@ struct ice_flow_prof { struct ice_acl_scen *scen; /* struct fd */ u32 data; - /* Symmetric Hash for RSS */ - bool symm; + bool symm; /* Symmetric Hash for RSS */ } cfg; /* Default actions */ @@ -452,9 +470,7 @@ struct ice_rss_cfg { struct LIST_ENTRY_TYPE l_entry; /* bitmap of VSIs added to the RSS entry */ ice_declare_bitmap(vsis, ICE_MAX_VSI); - u64 hashed_flds; - u32 packet_hdr; - bool symm; + struct ice_rss_hash_cfg hash; }; enum ice_flow_action_type { @@ -531,10 +547,10 @@ enum ice_status ice_add_avf_rss_cfg(struct ice_hw *hw, u16 vsi_handle, u64 hashed_flds); enum ice_status ice_rem_vsi_rss_cfg(struct ice_hw *hw, u16 vsi_handle); enum ice_status -ice_add_rss_cfg(struct ice_hw *hw, u16 vsi_handle, u64 hashed_flds, - u32 addl_hdrs, bool symm); +ice_add_rss_cfg(struct ice_hw *hw, u16 vsi_handle, + const struct ice_rss_hash_cfg *cfg); enum ice_status -ice_rem_rss_cfg(struct ice_hw *hw, u16 vsi_handle, u64 hashed_flds, - u32 addl_hdrs); +ice_rem_rss_cfg(struct ice_hw *hw, u16 vsi_handle, + const struct ice_rss_hash_cfg *cfg); u64 ice_get_rss_cfg(struct ice_hw *hw, u16 vsi_handle, u32 hdrs); #endif /* _ICE_FLOW_H_ */ diff --git a/drivers/net/ice/ice_ethdev.c b/drivers/net/ice/ice_ethdev.c index eaf6024855..083a1b5b63 100644 --- a/drivers/net/ice/ice_ethdev.c +++ b/drivers/net/ice/ice_ethdev.c @@ -2436,10 +2436,7 @@ ice_dev_uninit(struct rte_eth_dev *dev) static bool is_hash_cfg_valid(struct ice_rss_hash_cfg *cfg) { - return ((cfg->hash_func >= ICE_RSS_HASH_TOEPLITZ && - cfg->hash_func <= ICE_RSS_HASH_JHASH) && - (cfg->hash_flds != 0 && cfg->addl_hdrs != 0)) ? - true : false; + return (cfg->hash_flds != 0 && cfg->addl_hdrs != 0) ? true : false; } static void @@ -2447,7 +2444,8 @@ hash_cfg_reset(struct ice_rss_hash_cfg *cfg) { cfg->hash_flds = 0; cfg->addl_hdrs = 0; - cfg->hash_func = 0; + cfg->symm = 0; + cfg->hdr_type = ICE_RSS_ANY_HEADERS; } static int @@ -2460,8 +2458,7 @@ ice_hash_moveout(struct ice_pf *pf, struct ice_rss_hash_cfg *cfg) if (!is_hash_cfg_valid(cfg)) return -ENOENT; - status = ice_rem_rss_cfg(hw, vsi->idx, cfg->hash_flds, - cfg->addl_hdrs); + status = ice_rem_rss_cfg(hw, vsi->idx, cfg); if (status && status != ICE_ERR_DOES_NOT_EXIST) { PMD_DRV_LOG(ERR, "ice_rem_rss_cfg failed for VSI:%d, error:%d\n", @@ -2478,16 +2475,11 @@ ice_hash_moveback(struct ice_pf *pf, struct ice_rss_hash_cfg *cfg) enum ice_status status = ICE_SUCCESS; struct ice_hw *hw = ICE_PF_TO_HW(pf); struct ice_vsi *vsi = pf->main_vsi; - bool symm; if (!is_hash_cfg_valid(cfg)) return -ENOENT; - symm = (cfg->hash_func == ICE_RSS_HASH_TOEPLITZ_SYMMETRIC) ? - true : false; - - status = ice_add_rss_cfg(hw, vsi->idx, cfg->hash_flds, - cfg->addl_hdrs, symm); + status = ice_add_rss_cfg(hw, vsi->idx, cfg); if (status) { PMD_DRV_LOG(ERR, "ice_add_rss_cfg failed for VSI:%d, error:%d\n", @@ -2764,15 +2756,12 @@ ice_add_rss_cfg_pre(struct ice_pf *pf, uint32_t hdr) static int ice_add_rss_cfg_post_gtpu(struct ice_pf *pf, struct ice_hash_gtpu_ctx *ctx, - u32 hdr, u64 fld, bool symm, u8 ctx_idx) + u8 ctx_idx, struct ice_rss_hash_cfg *cfg) { int ret; - if (ctx_idx < ICE_HASH_GTPU_CTX_MAX) { - ctx->ctx[ctx_idx].addl_hdrs = hdr; - ctx->ctx[ctx_idx].hash_flds = fld; - ctx->ctx[ctx_idx].hash_func = symm; - } + if (ctx_idx < ICE_HASH_GTPU_CTX_MAX) + ctx->ctx[ctx_idx] = *cfg; switch (ctx_idx) { case ICE_HASH_GTPU_CTX_EH_IP: @@ -2851,16 +2840,16 @@ ice_add_rss_cfg_post_gtpu(struct ice_pf *pf, struct ice_hash_gtpu_ctx *ctx, } static int -ice_add_rss_cfg_post(struct ice_pf *pf, uint32_t hdr, uint64_t fld, bool symm) +ice_add_rss_cfg_post(struct ice_pf *pf, struct ice_rss_hash_cfg *cfg) { - u8 gtpu_ctx_idx = calc_gtpu_ctx_idx(hdr); + u8 gtpu_ctx_idx = calc_gtpu_ctx_idx(cfg->addl_hdrs); - if (hdr & ICE_FLOW_SEG_HDR_IPV4) - return ice_add_rss_cfg_post_gtpu(pf, &pf->hash_ctx.gtpu4, hdr, - fld, symm, gtpu_ctx_idx); - else if (hdr & ICE_FLOW_SEG_HDR_IPV6) - return ice_add_rss_cfg_post_gtpu(pf, &pf->hash_ctx.gtpu6, hdr, - fld, symm, gtpu_ctx_idx); + if (cfg->addl_hdrs & ICE_FLOW_SEG_HDR_IPV4) + return ice_add_rss_cfg_post_gtpu(pf, &pf->hash_ctx.gtpu4, + gtpu_ctx_idx, cfg); + else if (cfg->addl_hdrs & ICE_FLOW_SEG_HDR_IPV6) + return ice_add_rss_cfg_post_gtpu(pf, &pf->hash_ctx.gtpu6, + gtpu_ctx_idx, cfg); return 0; } @@ -2881,36 +2870,36 @@ ice_rem_rss_cfg_post(struct ice_pf *pf, uint32_t hdr) int ice_rem_rss_cfg_wrap(struct ice_pf *pf, uint16_t vsi_id, - uint64_t fld, uint32_t hdr) + struct ice_rss_hash_cfg *cfg) { struct ice_hw *hw = ICE_PF_TO_HW(pf); int ret; - ret = ice_rem_rss_cfg(hw, vsi_id, fld, hdr); + ret = ice_rem_rss_cfg(hw, vsi_id, cfg); if (ret && ret != ICE_ERR_DOES_NOT_EXIST) PMD_DRV_LOG(ERR, "remove rss cfg failed\n"); - ice_rem_rss_cfg_post(pf, hdr); + ice_rem_rss_cfg_post(pf, cfg->addl_hdrs); return 0; } int ice_add_rss_cfg_wrap(struct ice_pf *pf, uint16_t vsi_id, - uint64_t fld, uint32_t hdr, bool symm) + struct ice_rss_hash_cfg *cfg) { struct ice_hw *hw = ICE_PF_TO_HW(pf); int ret; - ret = ice_add_rss_cfg_pre(pf, hdr); + ret = ice_add_rss_cfg_pre(pf, cfg->addl_hdrs); if (ret) PMD_DRV_LOG(ERR, "add rss cfg pre failed\n"); - ret = ice_add_rss_cfg(hw, vsi_id, fld, hdr, symm); + ret = ice_add_rss_cfg(hw, vsi_id, cfg); if (ret) PMD_DRV_LOG(ERR, "add rss cfg failed\n"); - ret = ice_add_rss_cfg_post(pf, hdr, fld, symm); + ret = ice_add_rss_cfg_post(pf, cfg); if (ret) PMD_DRV_LOG(ERR, "add rss cfg post failed\n"); @@ -2921,6 +2910,7 @@ static void ice_rss_hash_set(struct ice_pf *pf, uint64_t rss_hf) { struct ice_vsi *vsi = pf->main_vsi; + struct ice_rss_hash_cfg cfg; int ret; #define ICE_RSS_HF_ALL ( \ @@ -2933,11 +2923,13 @@ ice_rss_hash_set(struct ice_pf *pf, uint64_t rss_hf) ETH_RSS_NONFRAG_IPV4_SCTP | \ ETH_RSS_NONFRAG_IPV6_SCTP) + cfg.symm = 0; + cfg.hdr_type = ICE_RSS_ANY_HEADERS; /* Configure RSS for IPv4 with src/dst addr as input set */ if (rss_hf & ETH_RSS_IPV4) { - ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_FLOW_HASH_IPV4, - ICE_FLOW_SEG_HDR_IPV4 | - ICE_FLOW_SEG_HDR_IPV_OTHER, 0); + cfg.addl_hdrs = ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER; + cfg.hash_flds = ICE_FLOW_HASH_IPV4; + ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg); if (ret) PMD_DRV_LOG(ERR, "%s IPV4 rss flow fail %d", __func__, ret); @@ -2945,9 +2937,9 @@ ice_rss_hash_set(struct ice_pf *pf, uint64_t rss_hf) /* Configure RSS for IPv6 with src/dst addr as input set */ if (rss_hf & ETH_RSS_IPV6) { - ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_FLOW_HASH_IPV6, - ICE_FLOW_SEG_HDR_IPV6 | - ICE_FLOW_SEG_HDR_IPV_OTHER, 0); + cfg.addl_hdrs = ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER; + cfg.hash_flds = ICE_FLOW_HASH_IPV6; + ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg); if (ret) PMD_DRV_LOG(ERR, "%s IPV6 rss flow fail %d", __func__, ret); @@ -2955,10 +2947,10 @@ ice_rss_hash_set(struct ice_pf *pf, uint64_t rss_hf) /* Configure RSS for udp4 with src/dst addr and port as input set */ if (rss_hf & ETH_RSS_NONFRAG_IPV4_UDP) { - ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_UDP_IPV4, - ICE_FLOW_SEG_HDR_UDP | - ICE_FLOW_SEG_HDR_IPV4 | - ICE_FLOW_SEG_HDR_IPV_OTHER, 0); + cfg.addl_hdrs = ICE_FLOW_SEG_HDR_UDP | ICE_FLOW_SEG_HDR_IPV4 | + ICE_FLOW_SEG_HDR_IPV_OTHER; + cfg.hash_flds = ICE_HASH_UDP_IPV4; + ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg); if (ret) PMD_DRV_LOG(ERR, "%s UDP_IPV4 rss flow fail %d", __func__, ret); @@ -2966,10 +2958,10 @@ ice_rss_hash_set(struct ice_pf *pf, uint64_t rss_hf) /* Configure RSS for udp6 with src/dst addr and port as input set */ if (rss_hf & ETH_RSS_NONFRAG_IPV6_UDP) { - ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_UDP_IPV6, - ICE_FLOW_SEG_HDR_UDP | - ICE_FLOW_SEG_HDR_IPV6 | - ICE_FLOW_SEG_HDR_IPV_OTHER, 0); + cfg.addl_hdrs = ICE_FLOW_SEG_HDR_UDP | ICE_FLOW_SEG_HDR_IPV6 | + ICE_FLOW_SEG_HDR_IPV_OTHER; + cfg.hash_flds = ICE_HASH_UDP_IPV6; + ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg); if (ret) PMD_DRV_LOG(ERR, "%s UDP_IPV6 rss flow fail %d", __func__, ret); @@ -2977,10 +2969,10 @@ ice_rss_hash_set(struct ice_pf *pf, uint64_t rss_hf) /* Configure RSS for tcp4 with src/dst addr and port as input set */ if (rss_hf & ETH_RSS_NONFRAG_IPV4_TCP) { - ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_TCP_IPV4, - ICE_FLOW_SEG_HDR_TCP | - ICE_FLOW_SEG_HDR_IPV4 | - ICE_FLOW_SEG_HDR_IPV_OTHER, 0); + cfg.addl_hdrs = ICE_FLOW_SEG_HDR_TCP | ICE_FLOW_SEG_HDR_IPV4 | + ICE_FLOW_SEG_HDR_IPV_OTHER; + cfg.hash_flds = ICE_HASH_TCP_IPV4; + ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg); if (ret) PMD_DRV_LOG(ERR, "%s TCP_IPV4 rss flow fail %d", __func__, ret); @@ -2988,10 +2980,10 @@ ice_rss_hash_set(struct ice_pf *pf, uint64_t rss_hf) /* Configure RSS for tcp6 with src/dst addr and port as input set */ if (rss_hf & ETH_RSS_NONFRAG_IPV6_TCP) { - ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_TCP_IPV6, - ICE_FLOW_SEG_HDR_TCP | - ICE_FLOW_SEG_HDR_IPV6 | - ICE_FLOW_SEG_HDR_IPV_OTHER, 0); + cfg.addl_hdrs = ICE_FLOW_SEG_HDR_TCP | ICE_FLOW_SEG_HDR_IPV6 | + ICE_FLOW_SEG_HDR_IPV_OTHER; + cfg.hash_flds = ICE_HASH_TCP_IPV6; + ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg); if (ret) PMD_DRV_LOG(ERR, "%s TCP_IPV6 rss flow fail %d", __func__, ret); @@ -2999,10 +2991,10 @@ ice_rss_hash_set(struct ice_pf *pf, uint64_t rss_hf) /* Configure RSS for sctp4 with src/dst addr and port as input set */ if (rss_hf & ETH_RSS_NONFRAG_IPV4_SCTP) { - ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_SCTP_IPV4, - ICE_FLOW_SEG_HDR_SCTP | - ICE_FLOW_SEG_HDR_IPV4 | - ICE_FLOW_SEG_HDR_IPV_OTHER, 0); + cfg.addl_hdrs = ICE_FLOW_SEG_HDR_SCTP | ICE_FLOW_SEG_HDR_IPV4 | + ICE_FLOW_SEG_HDR_IPV_OTHER; + cfg.hash_flds = ICE_HASH_SCTP_IPV4; + ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg); if (ret) PMD_DRV_LOG(ERR, "%s SCTP_IPV4 rss flow fail %d", __func__, ret); @@ -3010,218 +3002,188 @@ ice_rss_hash_set(struct ice_pf *pf, uint64_t rss_hf) /* Configure RSS for sctp6 with src/dst addr and port as input set */ if (rss_hf & ETH_RSS_NONFRAG_IPV6_SCTP) { - ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_SCTP_IPV6, - ICE_FLOW_SEG_HDR_SCTP | - ICE_FLOW_SEG_HDR_IPV6 | - ICE_FLOW_SEG_HDR_IPV_OTHER, 0); + cfg.addl_hdrs = ICE_FLOW_SEG_HDR_SCTP | ICE_FLOW_SEG_HDR_IPV6 | + ICE_FLOW_SEG_HDR_IPV_OTHER; + cfg.hash_flds = ICE_HASH_SCTP_IPV6; + ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg); if (ret) PMD_DRV_LOG(ERR, "%s SCTP_IPV6 rss flow fail %d", __func__, ret); } if (rss_hf & ETH_RSS_IPV4) { - ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_FLOW_HASH_IPV4, - ICE_FLOW_SEG_HDR_GTPU_IP | - ICE_FLOW_SEG_HDR_IPV4 | - ICE_FLOW_SEG_HDR_IPV_OTHER, 0); + cfg.addl_hdrs = ICE_FLOW_SEG_HDR_GTPU_IP | ICE_FLOW_SEG_HDR_IPV4 | + ICE_FLOW_SEG_HDR_IPV_OTHER; + cfg.hash_flds = ICE_FLOW_HASH_IPV4; + ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg); if (ret) PMD_DRV_LOG(ERR, "%s GTPU_IPV4 rss flow fail %d", __func__, ret); - ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_FLOW_HASH_IPV4, - ICE_FLOW_SEG_HDR_GTPU_EH | - ICE_FLOW_SEG_HDR_IPV4 | - ICE_FLOW_SEG_HDR_IPV_OTHER, 0); + cfg.addl_hdrs = ICE_FLOW_SEG_HDR_GTPU_EH | ICE_FLOW_SEG_HDR_IPV4 | + ICE_FLOW_SEG_HDR_IPV_OTHER; + ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg); if (ret) PMD_DRV_LOG(ERR, "%s GTPU_EH_IPV4 rss flow fail %d", __func__, ret); - ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_FLOW_HASH_IPV4, - ICE_FLOW_SEG_HDR_PPPOE | - ICE_FLOW_SEG_HDR_IPV4 | - ICE_FLOW_SEG_HDR_IPV_OTHER, 0); + cfg.addl_hdrs = ICE_FLOW_SEG_HDR_PPPOE | ICE_FLOW_SEG_HDR_IPV4 | + ICE_FLOW_SEG_HDR_IPV_OTHER; + ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg); if (ret) PMD_DRV_LOG(ERR, "%s PPPoE_IPV4 rss flow fail %d", __func__, ret); } if (rss_hf & ETH_RSS_IPV6) { - ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_FLOW_HASH_IPV6, - ICE_FLOW_SEG_HDR_GTPU_IP | - ICE_FLOW_SEG_HDR_IPV6 | - ICE_FLOW_SEG_HDR_IPV_OTHER, 0); + cfg.addl_hdrs = ICE_FLOW_SEG_HDR_GTPU_IP | ICE_FLOW_SEG_HDR_IPV6 | + ICE_FLOW_SEG_HDR_IPV_OTHER; + cfg.hash_flds = ICE_FLOW_HASH_IPV6; + ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg); if (ret) PMD_DRV_LOG(ERR, "%s GTPU_IPV6 rss flow fail %d", __func__, ret); - ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_FLOW_HASH_IPV6, - ICE_FLOW_SEG_HDR_GTPU_EH | - ICE_FLOW_SEG_HDR_IPV6 | - ICE_FLOW_SEG_HDR_IPV_OTHER, 0); + cfg.addl_hdrs = ICE_FLOW_SEG_HDR_GTPU_EH | ICE_FLOW_SEG_HDR_IPV6 | + ICE_FLOW_SEG_HDR_IPV_OTHER; + ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg); if (ret) PMD_DRV_LOG(ERR, "%s GTPU_EH_IPV6 rss flow fail %d", __func__, ret); - ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_FLOW_HASH_IPV6, - ICE_FLOW_SEG_HDR_PPPOE | - ICE_FLOW_SEG_HDR_IPV6 | - ICE_FLOW_SEG_HDR_IPV_OTHER, 0); + cfg.addl_hdrs = ICE_FLOW_SEG_HDR_PPPOE | ICE_FLOW_SEG_HDR_IPV6 | + ICE_FLOW_SEG_HDR_IPV_OTHER; + ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg); if (ret) PMD_DRV_LOG(ERR, "%s PPPoE_IPV6 rss flow fail %d", __func__, ret); } if (rss_hf & ETH_RSS_NONFRAG_IPV4_UDP) { - ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_UDP_IPV4, - ICE_FLOW_SEG_HDR_GTPU_IP | - ICE_FLOW_SEG_HDR_UDP | - ICE_FLOW_SEG_HDR_IPV4 | - ICE_FLOW_SEG_HDR_IPV_OTHER, 0); + cfg.addl_hdrs = ICE_FLOW_SEG_HDR_GTPU_IP | ICE_FLOW_SEG_HDR_UDP | + ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER; + cfg.hash_flds = ICE_FLOW_HASH_IPV4; + ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg); if (ret) PMD_DRV_LOG(ERR, "%s GTPU_IPV4_UDP rss flow fail %d", __func__, ret); - ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_UDP_IPV4, - ICE_FLOW_SEG_HDR_GTPU_EH | - ICE_FLOW_SEG_HDR_UDP | - ICE_FLOW_SEG_HDR_IPV4 | - ICE_FLOW_SEG_HDR_IPV_OTHER, 0); + cfg.addl_hdrs = ICE_FLOW_SEG_HDR_GTPU_EH | ICE_FLOW_SEG_HDR_UDP | + ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER; + ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg); if (ret) PMD_DRV_LOG(ERR, "%s GTPU_EH_IPV4_UDP rss flow fail %d", __func__, ret); - ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_UDP_IPV4, - ICE_FLOW_SEG_HDR_PPPOE | - ICE_FLOW_SEG_HDR_UDP | - ICE_FLOW_SEG_HDR_IPV4 | - ICE_FLOW_SEG_HDR_IPV_OTHER, 0); + cfg.addl_hdrs = ICE_FLOW_SEG_HDR_PPPOE | ICE_FLOW_SEG_HDR_UDP | + ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER; + ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg); if (ret) PMD_DRV_LOG(ERR, "%s PPPoE_IPV4_UDP rss flow fail %d", __func__, ret); } if (rss_hf & ETH_RSS_NONFRAG_IPV6_UDP) { - ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_UDP_IPV6, - ICE_FLOW_SEG_HDR_GTPU_IP | - ICE_FLOW_SEG_HDR_UDP | - ICE_FLOW_SEG_HDR_IPV6 | - ICE_FLOW_SEG_HDR_IPV_OTHER, 0); + cfg.addl_hdrs = ICE_FLOW_SEG_HDR_GTPU_IP | ICE_FLOW_SEG_HDR_UDP | + ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER; + cfg.hash_flds = ICE_FLOW_HASH_IPV6; + ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg); if (ret) PMD_DRV_LOG(ERR, "%s GTPU_IPV6_UDP rss flow fail %d", __func__, ret); - ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_UDP_IPV6, - ICE_FLOW_SEG_HDR_GTPU_EH | - ICE_FLOW_SEG_HDR_UDP | - ICE_FLOW_SEG_HDR_IPV6 | - ICE_FLOW_SEG_HDR_IPV_OTHER, 0); + cfg.addl_hdrs = ICE_FLOW_SEG_HDR_GTPU_EH | ICE_FLOW_SEG_HDR_UDP | + ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER; + ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg); if (ret) PMD_DRV_LOG(ERR, "%s GTPU_EH_IPV6_UDP rss flow fail %d", __func__, ret); - ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_UDP_IPV6, - ICE_FLOW_SEG_HDR_PPPOE | - ICE_FLOW_SEG_HDR_UDP | - ICE_FLOW_SEG_HDR_IPV6 | - ICE_FLOW_SEG_HDR_IPV_OTHER, 0); + cfg.addl_hdrs = ICE_FLOW_SEG_HDR_PPPOE | ICE_FLOW_SEG_HDR_UDP | + ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER; + ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg); if (ret) PMD_DRV_LOG(ERR, "%s PPPoE_IPV6_UDP rss flow fail %d", __func__, ret); } if (rss_hf & ETH_RSS_NONFRAG_IPV4_TCP) { - ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_TCP_IPV4, - ICE_FLOW_SEG_HDR_GTPU_IP | - ICE_FLOW_SEG_HDR_TCP | - ICE_FLOW_SEG_HDR_IPV4 | - ICE_FLOW_SEG_HDR_IPV_OTHER, 0); + cfg.addl_hdrs = ICE_FLOW_SEG_HDR_GTPU_IP | ICE_FLOW_SEG_HDR_TCP | + ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER; + cfg.hash_flds = ICE_FLOW_HASH_IPV4; + ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg); if (ret) PMD_DRV_LOG(ERR, "%s GTPU_IPV4_TCP rss flow fail %d", __func__, ret); - ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_TCP_IPV4, - ICE_FLOW_SEG_HDR_GTPU_EH | - ICE_FLOW_SEG_HDR_TCP | - ICE_FLOW_SEG_HDR_IPV4 | - ICE_FLOW_SEG_HDR_IPV_OTHER, 0); + cfg.addl_hdrs = ICE_FLOW_SEG_HDR_GTPU_EH | ICE_FLOW_SEG_HDR_TCP | + ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER; + ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg); if (ret) PMD_DRV_LOG(ERR, "%s GTPU_EH_IPV4_TCP rss flow fail %d", __func__, ret); - ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_TCP_IPV4, - ICE_FLOW_SEG_HDR_PPPOE | - ICE_FLOW_SEG_HDR_TCP | - ICE_FLOW_SEG_HDR_IPV4 | - ICE_FLOW_SEG_HDR_IPV_OTHER, 0); + cfg.addl_hdrs = ICE_FLOW_SEG_HDR_PPPOE | ICE_FLOW_SEG_HDR_TCP | + ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER; + ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg); if (ret) PMD_DRV_LOG(ERR, "%s PPPoE_IPV4_TCP rss flow fail %d", __func__, ret); } if (rss_hf & ETH_RSS_NONFRAG_IPV6_TCP) { - ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_TCP_IPV6, - ICE_FLOW_SEG_HDR_GTPU_IP | - ICE_FLOW_SEG_HDR_TCP | - ICE_FLOW_SEG_HDR_IPV6 | - ICE_FLOW_SEG_HDR_IPV_OTHER, 0); + cfg.addl_hdrs = ICE_FLOW_SEG_HDR_GTPU_IP | ICE_FLOW_SEG_HDR_TCP | + ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER; + cfg.hash_flds = ICE_FLOW_HASH_IPV6; + ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg); if (ret) PMD_DRV_LOG(ERR, "%s GTPU_IPV6_TCP rss flow fail %d", __func__, ret); - ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_TCP_IPV6, - ICE_FLOW_SEG_HDR_GTPU_EH | - ICE_FLOW_SEG_HDR_TCP | - ICE_FLOW_SEG_HDR_IPV6 | - ICE_FLOW_SEG_HDR_IPV_OTHER, 0); + cfg.addl_hdrs = ICE_FLOW_SEG_HDR_GTPU_EH | ICE_FLOW_SEG_HDR_TCP | + ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER; + ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg); if (ret) PMD_DRV_LOG(ERR, "%s GTPU_EH_IPV6_TCP rss flow fail %d", __func__, ret); - ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_TCP_IPV6, - ICE_FLOW_SEG_HDR_PPPOE | - ICE_FLOW_SEG_HDR_TCP | - ICE_FLOW_SEG_HDR_IPV6 | - ICE_FLOW_SEG_HDR_IPV_OTHER, 0); + cfg.addl_hdrs = ICE_FLOW_SEG_HDR_PPPOE | ICE_FLOW_SEG_HDR_TCP | + ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER; + ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg); if (ret) PMD_DRV_LOG(ERR, "%s PPPoE_IPV6_TCP rss flow fail %d", __func__, ret); } if (rss_hf & ETH_RSS_NONFRAG_IPV4_SCTP) { - ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_SCTP_IPV4, - ICE_FLOW_SEG_HDR_GTPU_IP | - ICE_FLOW_SEG_HDR_SCTP | - ICE_FLOW_SEG_HDR_IPV4 | - ICE_FLOW_SEG_HDR_IPV_OTHER, 0); + cfg.addl_hdrs = ICE_FLOW_SEG_HDR_GTPU_IP | ICE_FLOW_SEG_HDR_SCTP | + ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER; + cfg.hash_flds = ICE_FLOW_HASH_IPV4; + ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg); if (ret) PMD_DRV_LOG(ERR, "%s GTPU_IPV4_SCTP rss flow fail %d", __func__, ret); - ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_SCTP_IPV4, - ICE_FLOW_SEG_HDR_GTPU_EH | - ICE_FLOW_SEG_HDR_SCTP | - ICE_FLOW_SEG_HDR_IPV4 | - ICE_FLOW_SEG_HDR_IPV_OTHER, 0); + cfg.addl_hdrs = ICE_FLOW_SEG_HDR_GTPU_EH | ICE_FLOW_SEG_HDR_SCTP | + ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER; + ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg); if (ret) PMD_DRV_LOG(ERR, "%s GTPU_EH_IPV4_SCTP rss flow fail %d", __func__, ret); } if (rss_hf & ETH_RSS_NONFRAG_IPV6_SCTP) { - ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_SCTP_IPV6, - ICE_FLOW_SEG_HDR_GTPU_IP | - ICE_FLOW_SEG_HDR_SCTP | - ICE_FLOW_SEG_HDR_IPV6 | - ICE_FLOW_SEG_HDR_IPV_OTHER, 0); + cfg.addl_hdrs = ICE_FLOW_SEG_HDR_GTPU_IP | ICE_FLOW_SEG_HDR_SCTP | + ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER; + cfg.hash_flds = ICE_FLOW_HASH_IPV6; + ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg); if (ret) PMD_DRV_LOG(ERR, "%s GTPU_IPV6_SCTP rss flow fail %d", __func__, ret); - ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_SCTP_IPV6, - ICE_FLOW_SEG_HDR_GTPU_EH | - ICE_FLOW_SEG_HDR_SCTP | - ICE_FLOW_SEG_HDR_IPV6 | - ICE_FLOW_SEG_HDR_IPV_OTHER, 0); + cfg.addl_hdrs = ICE_FLOW_SEG_HDR_GTPU_EH | ICE_FLOW_SEG_HDR_SCTP | + ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER; + ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg); if (ret) PMD_DRV_LOG(ERR, "%s GTPU_EH_IPV6_SCTP rss flow fail %d", __func__, ret); diff --git a/drivers/net/ice/ice_ethdev.h b/drivers/net/ice/ice_ethdev.h index 452fd90508..899f446cde 100644 --- a/drivers/net/ice/ice_ethdev.h +++ b/drivers/net/ice/ice_ethdev.h @@ -11,6 +11,7 @@ #include "base/ice_common.h" #include "base/ice_adminq_cmd.h" +#include "base/ice_flow.h" #define ICE_VLAN_TAG_SIZE 4 @@ -378,19 +379,6 @@ struct ice_fdir_info { #define ICE_HASH_GTPU_CTX_DW_IP_TCP 8 #define ICE_HASH_GTPU_CTX_MAX 9 -enum ice_rss_hash_func { - ICE_RSS_HASH_TOEPLITZ = 0, - ICE_RSS_HASH_TOEPLITZ_SYMMETRIC = 1, - ICE_RSS_HASH_XOR = 2, - ICE_RSS_HASH_JHASH = 3, -}; - -struct ice_rss_hash_cfg { - u32 addl_hdrs; - u64 hash_flds; - enum ice_rss_hash_func hash_func; -}; - struct ice_hash_gtpu_ctx { struct ice_rss_hash_cfg ctx[ICE_HASH_GTPU_CTX_MAX]; }; @@ -543,9 +531,9 @@ void ice_vsi_enable_queues_intr(struct ice_vsi *vsi); void ice_vsi_disable_queues_intr(struct ice_vsi *vsi); void ice_vsi_queues_bind_intr(struct ice_vsi *vsi); int ice_add_rss_cfg_wrap(struct ice_pf *pf, uint16_t vsi_id, - uint64_t hash_fld, uint32_t pkt_hdr, bool symm); + struct ice_rss_hash_cfg *cfg); int ice_rem_rss_cfg_wrap(struct ice_pf *pf, uint16_t vsi_id, - uint64_t hash_fld, uint32_t pkt_hdr); + struct ice_rss_hash_cfg *cfg); static inline int ice_align_floor(int n) diff --git a/drivers/net/ice/ice_hash.c b/drivers/net/ice/ice_hash.c index 45c69e6bfd..fe3e06c579 100644 --- a/drivers/net/ice/ice_hash.c +++ b/drivers/net/ice/ice_hash.c @@ -1274,16 +1274,15 @@ ice_hash_create(struct ice_adapter *ad, goto out; } else { - filter_ptr->rss_cfg.packet_hdr = headermask; - filter_ptr->rss_cfg.hashed_flds = hash_field; - filter_ptr->rss_cfg.symm = + filter_ptr->rss_cfg.hash.addl_hdrs = headermask; + filter_ptr->rss_cfg.hash.hash_flds = hash_field; + filter_ptr->rss_cfg.hash.symm = (hash_function == RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ); + filter_ptr->rss_cfg.hash.hdr_type = ICE_RSS_ANY_HEADERS; ret = ice_add_rss_cfg_wrap(pf, vsi->idx, - filter_ptr->rss_cfg.hashed_flds, - filter_ptr->rss_cfg.packet_hdr, - filter_ptr->rss_cfg.symm); + &filter_ptr->rss_cfg.hash); if (ret) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_HANDLE, NULL, @@ -1325,8 +1324,7 @@ ice_hash_destroy(struct ice_adapter *ad, ICE_WRITE_REG(hw, VSIQF_HASH_CTL(vsi->vsi_id), reg); } else { ret = ice_rem_rss_cfg_wrap(pf, vsi->idx, - filter_ptr->rss_cfg.hashed_flds, - filter_ptr->rss_cfg.packet_hdr); + &filter_ptr->rss_cfg.hash); /* Fixme: Ignore the error if a rule does not exist. * Currently a rule for inputset change or symm turn on/off * will overwrite an exist rule, while application still