// SPDX-License-Identifier: GPL-2.0 /* Copyright (c) 2019, Intel Corporation. */ #include "ice_common.h" #include "ice_flow.h" #include <net/gre.h> /* Describe properties of a protocol header field */ struct ice_flow_field_info { … }; #define ICE_FLOW_FLD_INFO(_hdr, _offset_bytes, _size_bytes) … #define ICE_FLOW_FLD_INFO_MSK(_hdr, _offset_bytes, _size_bytes, _mask) … /* Table containing properties of supported protocol header fields */ static const struct ice_flow_field_info ice_flds_info[ICE_FLOW_FIELD_IDX_MAX] = …; /* Bitmaps indicating relevant packet types for a particular protocol header * * Packet types for packets with an Outer/First/Single MAC header */ static const u32 ice_ptypes_mac_ofos[] = …; /* Packet types for packets with an Innermost/Last MAC VLAN header */ static const u32 ice_ptypes_macvlan_il[] = …; /* Packet types for packets with an Outer/First/Single IPv4 header, does NOT * include IPv4 other PTYPEs */ static const u32 ice_ptypes_ipv4_ofos[] = …; /* Packet types for packets with an Outer/First/Single IPv4 header, includes * IPv4 other PTYPEs */ static const u32 ice_ptypes_ipv4_ofos_all[] = …; /* Packet types for packets with an Innermost/Last IPv4 header */ static const u32 ice_ptypes_ipv4_il[] = …; /* Packet types for packets with an Outer/First/Single IPv6 header, does NOT * include IPv6 other PTYPEs */ static const u32 ice_ptypes_ipv6_ofos[] = …; /* Packet types for packets with an Outer/First/Single IPv6 header, includes * IPv6 other PTYPEs */ static const u32 ice_ptypes_ipv6_ofos_all[] = …; /* Packet types for packets with an Innermost/Last IPv6 header */ static const u32 ice_ptypes_ipv6_il[] = …; /* Packet types for packets with an Outer/First/Single IPv4 header - no L4 */ static const u32 ice_ptypes_ipv4_ofos_no_l4[] = …; /* Packet types for packets with an Outermost/First ARP header */ static const u32 ice_ptypes_arp_of[] = …; /* Packet types for packets with an Innermost/Last IPv4 header - no L4 */ static const u32 ice_ptypes_ipv4_il_no_l4[] = …; /* Packet types for packets with an Outer/First/Single IPv6 header - no L4 */ static const u32 ice_ptypes_ipv6_ofos_no_l4[] = …; /* Packet types for packets with an Innermost/Last IPv6 header - no L4 */ static const u32 ice_ptypes_ipv6_il_no_l4[] = …; /* UDP Packet types for non-tunneled packets or tunneled * packets with inner UDP. */ static const u32 ice_ptypes_udp_il[] = …; /* Packet types for packets with an Innermost/Last TCP header */ static const u32 ice_ptypes_tcp_il[] = …; /* Packet types for packets with an Innermost/Last SCTP header */ static const u32 ice_ptypes_sctp_il[] = …; /* Packet types for packets with an Outermost/First ICMP header */ static const u32 ice_ptypes_icmp_of[] = …; /* Packet types for packets with an Innermost/Last ICMP header */ static const u32 ice_ptypes_icmp_il[] = …; /* Packet types for packets with an Outermost/First GRE header */ static const u32 ice_ptypes_gre_of[] = …; /* Packet types for packets with an Innermost/Last MAC header */ static const u32 ice_ptypes_mac_il[] = …; /* Packet types for GTPC */ static const u32 ice_ptypes_gtpc[] = …; /* Packet types for GTPC with TEID */ static const u32 ice_ptypes_gtpc_tid[] = …; /* Packet types for GTPU */ static const struct ice_ptype_attributes ice_attr_gtpu_session[] = …; static const struct ice_ptype_attributes ice_attr_gtpu_eh[] = …; static const struct ice_ptype_attributes ice_attr_gtpu_down[] = …; static const struct ice_ptype_attributes ice_attr_gtpu_up[] = …; static const u32 ice_ptypes_gtpu[] = …; /* Packet types for PPPoE */ static const u32 ice_ptypes_pppoe[] = …; /* Packet types for packets with PFCP NODE header */ static const u32 ice_ptypes_pfcp_node[] = …; /* Packet types for packets with PFCP SESSION header */ static const u32 ice_ptypes_pfcp_session[] = …; /* Packet types for L2TPv3 */ static const u32 ice_ptypes_l2tpv3[] = …; /* Packet types for ESP */ static const u32 ice_ptypes_esp[] = …; /* Packet types for AH */ static const u32 ice_ptypes_ah[] = …; /* Packet types for packets with NAT_T ESP header */ static const u32 ice_ptypes_nat_t_esp[] = …; static const u32 ice_ptypes_mac_non_ip_ofos[] = …; /* Manage parameters and info. used during the creation of a flow profile */ struct ice_flow_prof_params { … }; #define ICE_FLOW_RSS_HDRS_INNER_MASK … #define ICE_FLOW_SEG_HDRS_L3_MASK … #define ICE_FLOW_SEG_HDRS_L4_MASK … /* mask for L4 protocols that are NOT part of IPv4/6 OTHER PTYPE groups */ #define ICE_FLOW_SEG_HDRS_L4_MASK_NO_OTHER … /** * ice_flow_val_hdrs - validates packet segments for valid protocol headers * @segs: array of one or more packet segments that describe the flow * @segs_cnt: number of packet segments provided */ static int ice_flow_val_hdrs(struct ice_flow_seg_info *segs, u8 segs_cnt) { … } /* Sizes of fixed known protocol headers without header options */ #define ICE_FLOW_PROT_HDR_SZ_MAC … #define ICE_FLOW_PROT_HDR_SZ_MAC_VLAN … #define ICE_FLOW_PROT_HDR_SZ_IPV4 … #define ICE_FLOW_PROT_HDR_SZ_IPV6 … #define ICE_FLOW_PROT_HDR_SZ_ARP … #define ICE_FLOW_PROT_HDR_SZ_ICMP … #define ICE_FLOW_PROT_HDR_SZ_TCP … #define ICE_FLOW_PROT_HDR_SZ_UDP … #define ICE_FLOW_PROT_HDR_SZ_SCTP … /** * ice_flow_calc_seg_sz - calculates size of a packet segment based on headers * @params: information about the flow to be processed * @seg: index of packet segment whose header size is to be determined */ static u16 ice_flow_calc_seg_sz(struct ice_flow_prof_params *params, u8 seg) { … } /** * ice_flow_proc_seg_hdrs - process protocol headers present in pkt segments * @params: information about the flow to be processed * * This function identifies the packet types associated with the protocol * headers being present in packet segments of the specified flow profile. */ static int ice_flow_proc_seg_hdrs(struct ice_flow_prof_params *params) { … } /** * ice_flow_xtract_fld - Create an extraction sequence entry for the given field * @hw: pointer to the HW struct * @params: information about the flow to be processed * @seg: packet segment index of the field to be extracted * @fld: ID of field to be extracted * @match: bit field of all fields * * This function determines the protocol ID, offset, and size of the given * field. It then allocates one or more extraction sequence entries for the * given field, and fill the entries with protocol ID and offset information. */ static int ice_flow_xtract_fld(struct ice_hw *hw, struct ice_flow_prof_params *params, u8 seg, enum ice_flow_field fld, u64 match) { … } /** * ice_flow_xtract_raws - Create extract sequence entries for raw bytes * @hw: pointer to the HW struct * @params: information about the flow to be processed * @seg: index of packet segment whose raw fields are to be extracted */ static int ice_flow_xtract_raws(struct ice_hw *hw, struct ice_flow_prof_params *params, u8 seg) { … } /** * ice_flow_create_xtrct_seq - Create an extraction sequence for given segments * @hw: pointer to the HW struct * @params: information about the flow to be processed * * This function iterates through all matched fields in the given segments, and * creates an extraction sequence for the fields. */ static int ice_flow_create_xtrct_seq(struct ice_hw *hw, struct ice_flow_prof_params *params) { … } /** * ice_flow_proc_segs - process all packet segments associated with a profile * @hw: pointer to the HW struct * @params: information about the flow to be processed */ static int ice_flow_proc_segs(struct ice_hw *hw, struct ice_flow_prof_params *params) { … } #define ICE_FLOW_FIND_PROF_CHK_FLDS … #define ICE_FLOW_FIND_PROF_CHK_VSI … #define ICE_FLOW_FIND_PROF_NOT_CHK_DIR … #define ICE_FLOW_FIND_PROF_CHK_SYMM … /** * ice_flow_find_prof_conds - Find a profile matching headers and conditions * @hw: pointer to the HW struct * @blk: classification stage * @dir: flow direction * @segs: array of one or more packet segments that describe the flow * @segs_cnt: number of packet segments provided * @symm: symmetric setting for RSS profiles * @vsi_handle: software VSI handle to check VSI (ICE_FLOW_FIND_PROF_CHK_VSI) * @conds: additional conditions to be checked (ICE_FLOW_FIND_PROF_CHK_*) */ static struct ice_flow_prof * ice_flow_find_prof_conds(struct ice_hw *hw, enum ice_block blk, enum ice_flow_dir dir, struct ice_flow_seg_info *segs, u8 segs_cnt, bool symm, u16 vsi_handle, u32 conds) { … } /** * ice_flow_find_prof_id - Look up a profile with given profile ID * @hw: pointer to the HW struct * @blk: classification stage * @prof_id: unique ID to identify this flow profile */ static struct ice_flow_prof * ice_flow_find_prof_id(struct ice_hw *hw, enum ice_block blk, u64 prof_id) { … } /** * ice_flow_rem_entry_sync - Remove a flow entry * @hw: pointer to the HW struct * @blk: classification stage * @entry: flow entry to be removed */ static int ice_flow_rem_entry_sync(struct ice_hw *hw, enum ice_block __always_unused blk, struct ice_flow_entry *entry) { … } /** * ice_flow_add_prof_sync - Add a flow profile for packet segments and fields * @hw: pointer to the HW struct * @blk: classification stage * @dir: flow direction * @segs: array of one or more packet segments that describe the flow * @segs_cnt: number of packet segments provided * @symm: symmetric setting for RSS profiles * @prof: stores the returned flow profile added * * Assumption: the caller has acquired the lock to the profile list */ static int ice_flow_add_prof_sync(struct ice_hw *hw, enum ice_block blk, enum ice_flow_dir dir, struct ice_flow_seg_info *segs, u8 segs_cnt, bool symm, struct ice_flow_prof **prof) { … } /** * ice_flow_rem_prof_sync - remove a flow profile * @hw: pointer to the hardware structure * @blk: classification stage * @prof: pointer to flow profile to remove * * Assumption: the caller has acquired the lock to the profile list */ static int ice_flow_rem_prof_sync(struct ice_hw *hw, enum ice_block blk, struct ice_flow_prof *prof) { … } /** * ice_flow_assoc_prof - associate a VSI with a flow profile * @hw: pointer to the hardware structure * @blk: classification stage * @prof: pointer to flow profile * @vsi_handle: software VSI handle * * Assumption: the caller has acquired the lock to the profile list * and the software VSI handle has been validated */ static int ice_flow_assoc_prof(struct ice_hw *hw, enum ice_block blk, struct ice_flow_prof *prof, u16 vsi_handle) { … } /** * ice_flow_disassoc_prof - disassociate a VSI from a flow profile * @hw: pointer to the hardware structure * @blk: classification stage * @prof: pointer to flow profile * @vsi_handle: software VSI handle * * Assumption: the caller has acquired the lock to the profile list * and the software VSI handle has been validated */ static int ice_flow_disassoc_prof(struct ice_hw *hw, enum ice_block blk, struct ice_flow_prof *prof, u16 vsi_handle) { … } #define FLAG_GTP_EH_PDU_LINK … #define FLAG_GTP_EH_PDU … #define HI_BYTE_IN_WORD … #define LO_BYTE_IN_WORD … #define FLAG_GTPU_MSK … #define FLAG_GTPU_UP … #define FLAG_GTPU_DW … /** * ice_flow_set_parser_prof - Set flow profile based on the parsed profile info * @hw: pointer to the HW struct * @dest_vsi: dest VSI * @fdir_vsi: fdir programming VSI * @prof: stores parsed profile info from raw flow * @blk: classification blk * * Return: 0 on success or negative errno on failure. */ int ice_flow_set_parser_prof(struct ice_hw *hw, u16 dest_vsi, u16 fdir_vsi, struct ice_parser_profile *prof, enum ice_block blk) { … } /** * ice_flow_add_prof - Add a flow profile for packet segments and matched fields * @hw: pointer to the HW struct * @blk: classification stage * @dir: flow direction * @segs: array of one or more packet segments that describe the flow * @segs_cnt: number of packet segments provided * @symm: symmetric setting for RSS profiles * @prof: stores the returned flow profile added */ int ice_flow_add_prof(struct ice_hw *hw, enum ice_block blk, enum ice_flow_dir dir, struct ice_flow_seg_info *segs, u8 segs_cnt, bool symm, struct ice_flow_prof **prof) { … } /** * ice_flow_rem_prof - Remove a flow profile and all entries associated with it * @hw: pointer to the HW struct * @blk: the block for which the flow profile is to be removed * @prof_id: unique ID of the flow profile to be removed */ int ice_flow_rem_prof(struct ice_hw *hw, enum ice_block blk, u64 prof_id) { … } /** * ice_flow_add_entry - Add a flow entry * @hw: pointer to the HW struct * @blk: classification stage * @prof_id: ID of the profile to add a new flow entry to * @entry_id: unique ID to identify this flow entry * @vsi_handle: software VSI handle for the flow entry * @prio: priority of the flow entry * @data: pointer to a data buffer containing flow entry's match values/masks * @entry_h: pointer to buffer that receives the new flow entry's handle */ int ice_flow_add_entry(struct ice_hw *hw, enum ice_block blk, u64 prof_id, u64 entry_id, u16 vsi_handle, enum ice_flow_priority prio, void *data, u64 *entry_h) { … } /** * ice_flow_rem_entry - Remove a flow entry * @hw: pointer to the HW struct * @blk: classification stage * @entry_h: handle to the flow entry to be removed */ int ice_flow_rem_entry(struct ice_hw *hw, enum ice_block blk, u64 entry_h) { … } /** * ice_flow_set_fld_ext - specifies locations of field from entry's input buffer * @seg: packet segment the field being set belongs to * @fld: field to be set * @field_type: type of the field * @val_loc: if not ICE_FLOW_FLD_OFF_INVAL, location of the value to match from * entry's input buffer * @mask_loc: if not ICE_FLOW_FLD_OFF_INVAL, location of mask value from entry's * input buffer * @last_loc: if not ICE_FLOW_FLD_OFF_INVAL, location of last/upper value from * entry's input buffer * * This helper function stores information of a field being matched, including * the type of the field and the locations of the value to match, the mask, and * the upper-bound value in the start of the input buffer for a flow entry. * This function should only be used for fixed-size data structures. * * This function also opportunistically determines the protocol headers to be * present based on the fields being set. Some fields cannot be used alone to * determine the protocol headers present. Sometimes, fields for particular * protocol headers are not matched. In those cases, the protocol headers * must be explicitly set. */ static void ice_flow_set_fld_ext(struct ice_flow_seg_info *seg, enum ice_flow_field fld, enum ice_flow_fld_match_type field_type, u16 val_loc, u16 mask_loc, u16 last_loc) { … } /** * ice_flow_set_fld - specifies locations of field from entry's input buffer * @seg: packet segment the field being set belongs to * @fld: field to be set * @val_loc: if not ICE_FLOW_FLD_OFF_INVAL, location of the value to match from * entry's input buffer * @mask_loc: if not ICE_FLOW_FLD_OFF_INVAL, location of mask value from entry's * input buffer * @last_loc: if not ICE_FLOW_FLD_OFF_INVAL, location of last/upper value from * entry's input buffer * @range: indicate if field being matched is to be in a range * * This function specifies the locations, in the form of byte offsets from the * start of the input buffer for a flow entry, from where the value to match, * the mask value, and upper value can be extracted. These locations are then * stored in the flow profile. When adding a flow entry associated with the * flow profile, these locations will be used to quickly extract the values and * create the content of a match entry. This function should only be used for * fixed-size data structures. */ void ice_flow_set_fld(struct ice_flow_seg_info *seg, enum ice_flow_field fld, u16 val_loc, u16 mask_loc, u16 last_loc, bool range) { … } /** * ice_flow_add_fld_raw - sets locations of a raw field from entry's input buf * @seg: packet segment the field being set belongs to * @off: offset of the raw field from the beginning of the segment in bytes * @len: length of the raw pattern to be matched * @val_loc: location of the value to match from entry's input buffer * @mask_loc: location of mask value from entry's input buffer * * This function specifies the offset of the raw field to be match from the * beginning of the specified packet segment, and the locations, in the form of * byte offsets from the start of the input buffer for a flow entry, from where * the value to match and the mask value to be extracted. These locations are * then stored in the flow profile. When adding flow entries to the associated * flow profile, these locations can be used to quickly extract the values to * create the content of a match entry. This function should only be used for * fixed-size data structures. */ void ice_flow_add_fld_raw(struct ice_flow_seg_info *seg, u16 off, u8 len, u16 val_loc, u16 mask_loc) { … } /** * ice_flow_rem_vsi_prof - remove VSI from flow profile * @hw: pointer to the hardware structure * @vsi_handle: software VSI handle * @prof_id: unique ID to identify this flow profile * * This function removes the flow entries associated to the input * VSI handle and disassociate the VSI from the flow profile. */ int ice_flow_rem_vsi_prof(struct ice_hw *hw, u16 vsi_handle, u64 prof_id) { … } #define ICE_FLOW_RSS_SEG_HDR_L2_MASKS … #define ICE_FLOW_RSS_SEG_HDR_L3_MASKS … #define ICE_FLOW_RSS_SEG_HDR_L4_MASKS … #define ICE_FLOW_RSS_SEG_HDR_VAL_MASKS … /** * ice_flow_set_rss_seg_info - setup packet segments for RSS * @segs: pointer to the flow field segment(s) * @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 int ice_flow_set_rss_seg_info(struct ice_flow_seg_info *segs, u8 seg_cnt, const struct ice_rss_hash_cfg *cfg) { … } /** * ice_rem_vsi_rss_list - remove VSI from RSS list * @hw: pointer to the hardware structure * @vsi_handle: software VSI handle * * Remove the VSI from all RSS configurations in the list. */ void ice_rem_vsi_rss_list(struct ice_hw *hw, u16 vsi_handle) { … } /** * ice_rem_vsi_rss_cfg - remove RSS configurations associated with VSI * @hw: pointer to the hardware structure * @vsi_handle: software VSI handle * * This function will iterate through all flow profiles and disassociate * the VSI from that profile. If the flow profile has no VSIs it will * be removed. */ int ice_rem_vsi_rss_cfg(struct ice_hw *hw, u16 vsi_handle) { … } /** * 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) { … } static bool ice_rss_match_prof(struct ice_rss_cfg *r, struct ice_flow_prof *prof, enum ice_rss_cfg_hdr_type hdr_type) { … } /** * ice_rem_rss_list - remove RSS configuration from list * @hw: pointer to the hardware structure * @vsi_handle: software VSI handle * @prof: pointer to flow profile * * Assumption: lock has already been acquired for RSS list */ static void ice_rem_rss_list(struct ice_hw *hw, u16 vsi_handle, struct ice_flow_prof *prof) { … } /** * ice_add_rss_list - add RSS configuration to list * @hw: pointer to the hardware structure * @vsi_handle: software VSI handle * @prof: pointer to flow profile * * Assumption: lock has already been acquired for RSS list */ static int ice_add_rss_list(struct ice_hw *hw, u16 vsi_handle, struct ice_flow_prof *prof) { … } /** * ice_rss_config_xor_word - set the HSYMM registers for one input set word * @hw: pointer to the hardware structure * @prof_id: RSS hardware profile id * @src: the FV index used by the protocol's source field * @dst: the FV index used by the protocol's destination field * * Write to the HSYMM register with the index of @src FV the value of the @dst * FV index. This will tell the hardware to XOR HSYMM[src] with INSET[dst] * while calculating the RSS input set. */ static void ice_rss_config_xor_word(struct ice_hw *hw, u8 prof_id, u8 src, u8 dst) { … } /** * ice_rss_config_xor - set the symmetric registers for a profile's protocol * @hw: pointer to the hardware structure * @prof_id: RSS hardware profile id * @src: the FV index used by the protocol's source field * @dst: the FV index used by the protocol's destination field * @len: length of the source/destination fields in words */ static void ice_rss_config_xor(struct ice_hw *hw, u8 prof_id, u8 src, u8 dst, u8 len) { … } /** * ice_rss_set_symm - set the symmetric settings for an RSS profile * @hw: pointer to the hardware structure * @prof: pointer to flow profile * * The symmetric hash will result from XORing the protocol's fields with * indexes in GLQF_HSYMM and GLQF_HINSET. This function configures the profile's * GLQF_HSYMM registers. */ static void ice_rss_set_symm(struct ice_hw *hw, struct ice_flow_prof *prof) { … } /** * ice_add_rss_cfg_sync - add an RSS configuration * @hw: pointer to the hardware structure * @vsi_handle: software VSI handle * @cfg: configure parameters * * Assumption: lock has already been acquired for RSS list */ static int ice_add_rss_cfg_sync(struct ice_hw *hw, u16 vsi_handle, const struct ice_rss_hash_cfg *cfg) { … } /** * ice_add_rss_cfg - add an RSS configuration with specified hashed fields * @hw: pointer to the hardware structure * @vsi: VSI to add the RSS configuration to * @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. */ int ice_add_rss_cfg(struct ice_hw *hw, struct ice_vsi *vsi, const struct ice_rss_hash_cfg *cfg) { … } /** * ice_rem_rss_cfg_sync - remove an existing RSS configuration * @hw: pointer to the hardware structure * @vsi_handle: software VSI handle * @cfg: configure parameters * * Assumption: lock has already been acquired for RSS list */ static int ice_rem_rss_cfg_sync(struct ice_hw *hw, u16 vsi_handle, const struct ice_rss_hash_cfg *cfg) { … } /** * ice_rem_rss_cfg - remove an existing RSS config with matching hashed fields * @hw: pointer to the hardware structure * @vsi_handle: software VSI handle * @cfg: configure parameters * * This function will lookup the flow profile based on the input * hash field bitmap, iterate through the profile entry list of * that profile and find entry associated with input VSI to be * removed. Calls are made to underlying flow apis which will in * turn build or update buffers for RSS XLT1 section. */ int ice_rem_rss_cfg(struct ice_hw *hw, u16 vsi_handle, const struct ice_rss_hash_cfg *cfg) { … } /* Mapping of AVF hash bit fields to an L3-L4 hash combination. * As the ice_flow_avf_hdr_field represent individual bit shifts in a hash, * convert its values to their appropriate flow L3, L4 values. */ #define ICE_FLOW_AVF_RSS_IPV4_MASKS … #define ICE_FLOW_AVF_RSS_TCP_IPV4_MASKS … #define ICE_FLOW_AVF_RSS_UDP_IPV4_MASKS … #define ICE_FLOW_AVF_RSS_ALL_IPV4_MASKS … #define ICE_FLOW_AVF_RSS_IPV6_MASKS … #define ICE_FLOW_AVF_RSS_UDP_IPV6_MASKS … #define ICE_FLOW_AVF_RSS_TCP_IPV6_MASKS … #define ICE_FLOW_AVF_RSS_ALL_IPV6_MASKS … /** * ice_add_avf_rss_cfg - add an RSS configuration for AVF driver * @hw: pointer to the hardware structure * @vsi: VF's VSI * @avf_hash: hash bit fields (ICE_AVF_FLOW_FIELD_*) to configure * * This function will take the hash bitmap provided by the AVF driver via a * message, convert it to ICE-compatible values, and configure RSS flow * profiles. */ int ice_add_avf_rss_cfg(struct ice_hw *hw, struct ice_vsi *vsi, u64 avf_hash) { … } static bool rss_cfg_symm_valid(u64 hfld) { … } /** * ice_set_rss_cfg_symm - set symmtery for all VSI's RSS configurations * @hw: pointer to the hardware structure * @vsi: VSI to set/unset Symmetric RSS * @symm: TRUE to set Symmetric RSS hashing */ int ice_set_rss_cfg_symm(struct ice_hw *hw, struct ice_vsi *vsi, bool symm) { … } /** * ice_replay_rss_cfg - replay RSS configurations associated with VSI * @hw: pointer to the hardware structure * @vsi_handle: software VSI handle */ int ice_replay_rss_cfg(struct ice_hw *hw, u16 vsi_handle) { … } /** * ice_get_rss_cfg - returns hashed fields for the given header types * @hw: pointer to the hardware structure * @vsi_handle: software VSI handle * @hdrs: protocol header type * @symm: whether the RSS is symmetric (bool, output) * * This function will return the match fields of the first instance of flow * profile having the given header types and containing input VSI */ u64 ice_get_rss_cfg(struct ice_hw *hw, u16 vsi_handle, u32 hdrs, bool *symm) { … }
Codebase Browser
linux