/* SPDX-License-Identifier: BSD-3-Clause
- * Copyright(c) 2014-2020 Broadcom
+ * Copyright(c) 2014-2021 Broadcom
* All rights reserved.
*/
-#include <rte_vxlan.h>
#include "bnxt.h"
#include "ulp_template_db_enum.h"
#include "ulp_template_struct.h"
#include "ulp_flow_db.h"
#include "ulp_mapper.h"
#include "ulp_tun.h"
+#include "ulp_template_db_tbl.h"
/* Local defines for the parsing functions */
#define ULP_VLAN_PRIORITY_SHIFT 13 /* First 3 bits */
/* Utility function to update the field_bitmap */
static void
ulp_rte_parser_field_bitmap_update(struct ulp_rte_parser_params *params,
- uint32_t idx)
+ uint32_t idx,
+ enum bnxt_ulp_prsr_action prsr_act)
{
struct ulp_rte_hdr_field *field;
field = ¶ms->hdr_field[idx];
if (ulp_bitmap_notzero(field->mask, field->size)) {
ULP_INDEX_BITMAP_SET(params->fld_bitmap.bits, idx);
+ if (!(prsr_act & ULP_PRSR_ACT_MATCH_IGNORE))
+ ULP_INDEX_BITMAP_SET(params->fld_s_bitmap.bits, idx);
/* Not exact match */
if (!ulp_bitmap_is_ones(field->mask, field->size))
- ULP_BITMAP_SET(params->fld_bitmap.bits,
- BNXT_ULP_MATCH_TYPE_BITMASK_WM);
+ ULP_COMP_FLD_IDX_WR(params,
+ BNXT_ULP_CF_IDX_WC_MATCH, 1);
} else {
ULP_INDEX_BITMAP_RESET(params->fld_bitmap.bits, idx);
}
}
-/* Utility function to copy field spec items */
-static struct ulp_rte_hdr_field *
-ulp_rte_parser_fld_copy(struct ulp_rte_hdr_field *field,
- const void *buffer,
- uint32_t size)
-{
- field->size = size;
- memcpy(field->spec, buffer, field->size);
- field++;
- return field;
-}
-
-/* Utility function to copy field masks items */
+#define ulp_deference_struct(x, y) ((x) ? &((x)->y) : NULL)
+/* Utility function to copy field spec and masks items */
static void
-ulp_rte_prsr_mask_copy(struct ulp_rte_parser_params *params,
- uint32_t *idx,
- const void *buffer,
- uint32_t size)
+ulp_rte_prsr_fld_mask(struct ulp_rte_parser_params *params,
+ uint32_t *idx,
+ uint32_t size,
+ const void *spec_buff,
+ const void *mask_buff,
+ enum bnxt_ulp_prsr_action prsr_act)
{
struct ulp_rte_hdr_field *field = ¶ms->hdr_field[*idx];
- memcpy(field->mask, buffer, size);
- ulp_rte_parser_field_bitmap_update(params, *idx);
+ /* update the field size */
+ field->size = size;
+
+ /* copy the mask specifications only if mask is not null */
+ if (!(prsr_act & ULP_PRSR_ACT_MASK_IGNORE) && mask_buff) {
+ memcpy(field->mask, mask_buff, size);
+ ulp_rte_parser_field_bitmap_update(params, *idx, prsr_act);
+ }
+
+ /* copy the protocol specifications only if mask is not null*/
+ if (spec_buff && mask_buff && ulp_bitmap_notzero(mask_buff, size))
+ memcpy(field->spec, spec_buff, size);
+
+ /* Increment the index */
*idx = *idx + 1;
}
-/* Utility function to ignore field masks items */
-static void
-ulp_rte_prsr_mask_ignore(struct ulp_rte_parser_params *params __rte_unused,
- uint32_t *idx,
- const void *buffer __rte_unused,
- uint32_t size __rte_unused)
+/* Utility function to copy field spec and masks items */
+static int32_t
+ulp_rte_prsr_fld_size_validate(struct ulp_rte_parser_params *params,
+ uint32_t *idx,
+ uint32_t size)
{
- *idx = *idx + 1;
+ if (params->field_idx + size >= BNXT_ULP_PROTO_HDR_MAX) {
+ BNXT_TF_DBG(ERR, "OOB for field processing %u\n", *idx);
+ return -EINVAL;
+ }
+ *idx = params->field_idx;
+ params->field_idx += size;
+ return 0;
}
/*
dir = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_DIRECTION);
/* read the port id details */
- port_id = ULP_COMP_FLD_IDX_RD(params,
- BNXT_ULP_CF_IDX_INCOMING_IF);
+ port_id = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_INCOMING_IF);
if (ulp_port_db_dev_port_to_ulp_index(params->ulp_ctx,
port_id,
&ifindex)) {
BNXT_ULP_CF_IDX_VF_FUNC_PARIF,
parif);
- /* populate the loopback parif */
- ULP_COMP_FLD_IDX_WR(params,
- BNXT_ULP_CF_IDX_LOOPBACK_PARIF,
- BNXT_ULP_SYM_VF_FUNC_PARIF);
-
} else {
/* Set DRV func PARIF */
if (ulp_port_db_parif_get(params->ulp_ctx, ifindex,
BNXT_ULP_CF_IDX_DRV_FUNC_PARIF,
parif);
}
+ if (mtype == BNXT_ULP_INTF_TYPE_PF) {
+ ULP_COMP_FLD_IDX_WR(params,
+ BNXT_ULP_CF_IDX_MATCH_PORT_IS_PF,
+ 1);
+ }
}
}
/* Update the decrement ttl computational fields */
if (ULP_BITMAP_ISSET(params->act_bitmap.bits,
- BNXT_ULP_ACTION_BIT_DEC_TTL)) {
+ BNXT_ULP_ACT_BIT_DEC_TTL)) {
/*
* Check that vxlan proto is included and vxlan decap
* action is not set then decrement tunnel ttl.
if ((ULP_BITMAP_ISSET(params->hdr_bitmap.bits,
BNXT_ULP_HDR_BIT_T_VXLAN) &&
!ULP_BITMAP_ISSET(params->act_bitmap.bits,
- BNXT_ULP_ACTION_BIT_VXLAN_DECAP))) {
+ BNXT_ULP_ACT_BIT_VXLAN_DECAP))) {
ULP_COMP_FLD_IDX_WR(params,
BNXT_ULP_CF_IDX_ACT_T_DEC_TTL, 1);
} else {
/* Merge the hdr_fp_bit into the proto header bit */
params->hdr_bitmap.bits |= params->hdr_fp_bit.bits;
+ /* Update the comp fld fid */
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_FID, params->fid);
+
/* Update the computed interface parameters */
bnxt_ulp_comp_fld_intf_update(params);
{
const struct rte_flow_item_eth *eth_spec = item->spec;
const struct rte_flow_item_eth *eth_mask = item->mask;
- struct ulp_rte_hdr_field *field;
- uint32_t idx = params->field_idx;
+ uint32_t idx = 0;
uint32_t size;
uint16_t eth_type = 0;
uint32_t inner_flag = 0;
- /*
- * Copy the rte_flow_item for eth into hdr_field using ethernet
- * header fields
- */
+ /* Perform validations */
if (eth_spec) {
- size = sizeof(eth_spec->dst.addr_bytes);
- field = ulp_rte_parser_fld_copy(¶ms->hdr_field[idx],
- eth_spec->dst.addr_bytes,
- size);
/* Todo: work around to avoid multicast and broadcast addr */
if (ulp_rte_parser_is_bcmc_addr(ð_spec->dst))
return BNXT_TF_RC_PARSE_ERR;
- size = sizeof(eth_spec->src.addr_bytes);
- field = ulp_rte_parser_fld_copy(field,
- eth_spec->src.addr_bytes,
- size);
- /* Todo: work around to avoid multicast and broadcast addr */
if (ulp_rte_parser_is_bcmc_addr(ð_spec->src))
return BNXT_TF_RC_PARSE_ERR;
- field = ulp_rte_parser_fld_copy(field,
- ð_spec->type,
- sizeof(eth_spec->type));
eth_type = eth_spec->type;
}
- if (eth_mask) {
- ulp_rte_prsr_mask_copy(params, &idx, eth_mask->dst.addr_bytes,
- sizeof(eth_mask->dst.addr_bytes));
- ulp_rte_prsr_mask_copy(params, &idx, eth_mask->src.addr_bytes,
- sizeof(eth_mask->src.addr_bytes));
- ulp_rte_prsr_mask_copy(params, &idx, ð_mask->type,
- sizeof(eth_mask->type));
+
+ if (ulp_rte_prsr_fld_size_validate(params, &idx,
+ BNXT_ULP_PROTO_HDR_ETH_NUM)) {
+ BNXT_TF_DBG(ERR, "Error parsing protocol header\n");
+ return BNXT_TF_RC_ERROR;
}
- /* Add number of vlan header elements */
- params->field_idx += BNXT_ULP_PROTO_HDR_ETH_NUM;
- params->vlan_idx = params->field_idx;
- params->field_idx += BNXT_ULP_PROTO_HDR_VLAN_NUM;
+ /*
+ * Copy the rte_flow_item for eth into hdr_field using ethernet
+ * header fields
+ */
+ size = sizeof(((struct rte_flow_item_eth *)NULL)->dst.addr_bytes);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(eth_spec, dst.addr_bytes),
+ ulp_deference_struct(eth_mask, dst.addr_bytes),
+ ULP_PRSR_ACT_DEFAULT);
+
+ size = sizeof(((struct rte_flow_item_eth *)NULL)->src.addr_bytes);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(eth_spec, src.addr_bytes),
+ ulp_deference_struct(eth_mask, src.addr_bytes),
+ ULP_PRSR_ACT_DEFAULT);
+
+ size = sizeof(((struct rte_flow_item_eth *)NULL)->type);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(eth_spec, type),
+ ulp_deference_struct(eth_mask, type),
+ ULP_PRSR_ACT_MATCH_IGNORE);
/* Update the protocol hdr bitmap */
if (ULP_BITMAP_ISSET(params->hdr_bitmap.bits,
{
const struct rte_flow_item_vlan *vlan_spec = item->spec;
const struct rte_flow_item_vlan *vlan_mask = item->mask;
- struct ulp_rte_hdr_field *field;
struct ulp_rte_hdr_bitmap *hdr_bit;
- uint32_t idx = params->vlan_idx;
- uint16_t vlan_tag, priority;
+ uint32_t idx = 0;
+ uint16_t vlan_tag = 0, priority = 0;
+ uint16_t vlan_tag_mask = 0, priority_mask = 0;
uint32_t outer_vtag_num;
uint32_t inner_vtag_num;
uint16_t eth_type = 0;
uint32_t inner_flag = 0;
+ uint32_t size;
- /*
- * Copy the rte_flow_item for vlan into hdr_field using Vlan
- * header fields
- */
if (vlan_spec) {
vlan_tag = ntohs(vlan_spec->tci);
priority = htons(vlan_tag >> ULP_VLAN_PRIORITY_SHIFT);
vlan_tag &= ULP_VLAN_TAG_MASK;
vlan_tag = htons(vlan_tag);
-
- field = ulp_rte_parser_fld_copy(¶ms->hdr_field[idx],
- &priority,
- sizeof(priority));
- field = ulp_rte_parser_fld_copy(field,
- &vlan_tag,
- sizeof(vlan_tag));
- field = ulp_rte_parser_fld_copy(field,
- &vlan_spec->inner_type,
- sizeof(vlan_spec->inner_type));
eth_type = vlan_spec->inner_type;
}
if (vlan_mask) {
- vlan_tag = ntohs(vlan_mask->tci);
- priority = htons(vlan_tag >> ULP_VLAN_PRIORITY_SHIFT);
- vlan_tag &= 0xfff;
+ vlan_tag_mask = ntohs(vlan_mask->tci);
+ priority_mask = htons(vlan_tag_mask >> ULP_VLAN_PRIORITY_SHIFT);
+ vlan_tag_mask &= 0xfff;
/*
* the storage for priority and vlan tag is 2 bytes
* then make the rest bits 13 bits as 1's
* so that it is matched as exact match.
*/
- if (priority == ULP_VLAN_PRIORITY_MASK)
- priority |= ~ULP_VLAN_PRIORITY_MASK;
- if (vlan_tag == ULP_VLAN_TAG_MASK)
- vlan_tag |= ~ULP_VLAN_TAG_MASK;
- vlan_tag = htons(vlan_tag);
-
- /*
- * The priority field is ignored since OVS is setting it as
- * wild card match and it is not supported. This is a work
- * around and shall be addressed in the future.
- */
- ulp_rte_prsr_mask_ignore(params, &idx, &priority,
- sizeof(priority));
+ if (priority_mask == ULP_VLAN_PRIORITY_MASK)
+ priority_mask |= ~ULP_VLAN_PRIORITY_MASK;
+ if (vlan_tag_mask == ULP_VLAN_TAG_MASK)
+ vlan_tag_mask |= ~ULP_VLAN_TAG_MASK;
+ vlan_tag_mask = htons(vlan_tag_mask);
+ }
- ulp_rte_prsr_mask_copy(params, &idx, &vlan_tag,
- sizeof(vlan_tag));
- ulp_rte_prsr_mask_copy(params, &idx, &vlan_mask->inner_type,
- sizeof(vlan_mask->inner_type));
+ if (ulp_rte_prsr_fld_size_validate(params, &idx,
+ BNXT_ULP_PROTO_HDR_S_VLAN_NUM)) {
+ BNXT_TF_DBG(ERR, "Error parsing protocol header\n");
+ return BNXT_TF_RC_ERROR;
}
- /* Set the vlan index to new incremented value */
- params->vlan_idx += BNXT_ULP_PROTO_HDR_S_VLAN_NUM;
+
+ /*
+ * Copy the rte_flow_item for vlan into hdr_field using Vlan
+ * header fields
+ */
+ size = sizeof(((struct rte_flow_item_vlan *)NULL)->tci);
+ /*
+ * The priority field is ignored since OVS is setting it as
+ * wild card match and it is not supported. This is a work
+ * around and shall be addressed in the future.
+ */
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ &priority,
+ &priority_mask,
+ ULP_PRSR_ACT_MASK_IGNORE);
+
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ &vlan_tag,
+ &vlan_tag_mask,
+ ULP_PRSR_ACT_DEFAULT);
+
+ size = sizeof(((struct rte_flow_item_vlan *)NULL)->inner_type);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(vlan_spec, inner_type),
+ ulp_deference_struct(vlan_mask, inner_type),
+ ULP_PRSR_ACT_MATCH_IGNORE);
/* Get the outer tag and inner tag counts */
outer_vtag_num = ULP_COMP_FLD_IDX_RD(params,
BNXT_ULP_HDR_BIT_II_VLAN);
inner_flag = 1;
} else {
- BNXT_TF_DBG(ERR, "Error Parsing:Vlan hdr found withtout eth\n");
+ BNXT_TF_DBG(ERR, "Error Parsing:Vlan hdr found without eth\n");
return BNXT_TF_RC_ERROR;
}
/* Update the field protocol hdr bitmap */
BNXT_ULP_HDR_BIT_O_TCP);
ULP_COMP_FLD_IDX_WR(param, BNXT_ULP_CF_IDX_O_L4, 1);
}
+ } else if (proto == IPPROTO_GRE) {
+ ULP_BITMAP_SET(param->hdr_bitmap.bits, BNXT_ULP_HDR_BIT_T_GRE);
+ } else if (proto == IPPROTO_ICMP) {
+ if (ULP_COMP_FLD_IDX_RD(param, BNXT_ULP_CF_IDX_L3_TUN))
+ ULP_BITMAP_SET(param->hdr_bitmap.bits,
+ BNXT_ULP_HDR_BIT_I_ICMP);
+ else
+ ULP_BITMAP_SET(param->hdr_bitmap.bits,
+ BNXT_ULP_HDR_BIT_O_ICMP);
+ }
+ if (proto) {
+ if (in_flag) {
+ ULP_COMP_FLD_IDX_WR(param,
+ BNXT_ULP_CF_IDX_I_L3_FB_PROTO_ID,
+ 1);
+ ULP_COMP_FLD_IDX_WR(param,
+ BNXT_ULP_CF_IDX_I_L3_PROTO_ID,
+ proto);
+ } else {
+ ULP_COMP_FLD_IDX_WR(param,
+ BNXT_ULP_CF_IDX_O_L3_FB_PROTO_ID,
+ 1);
+ ULP_COMP_FLD_IDX_WR(param,
+ BNXT_ULP_CF_IDX_O_L3_PROTO_ID,
+ proto);
+ }
}
}
{
const struct rte_flow_item_ipv4 *ipv4_spec = item->spec;
const struct rte_flow_item_ipv4 *ipv4_mask = item->mask;
- struct ulp_rte_hdr_field *field;
struct ulp_rte_hdr_bitmap *hdr_bitmap = ¶ms->hdr_bitmap;
- uint32_t idx = params->field_idx;
+ uint32_t idx = 0;
uint32_t size;
uint8_t proto = 0;
uint32_t inner_flag = 0;
params->field_idx = idx;
}
+ if (ulp_rte_prsr_fld_size_validate(params, &idx,
+ BNXT_ULP_PROTO_HDR_IPV4_NUM)) {
+ BNXT_TF_DBG(ERR, "Error parsing protocol header\n");
+ return BNXT_TF_RC_ERROR;
+ }
+
/*
* Copy the rte_flow_item for ipv4 into hdr_field using ipv4
* header fields
*/
- if (ipv4_spec) {
- size = sizeof(ipv4_spec->hdr.version_ihl);
- field = ulp_rte_parser_fld_copy(¶ms->hdr_field[idx],
- &ipv4_spec->hdr.version_ihl,
- size);
- size = sizeof(ipv4_spec->hdr.type_of_service);
- field = ulp_rte_parser_fld_copy(field,
- &ipv4_spec->hdr.type_of_service,
- size);
- size = sizeof(ipv4_spec->hdr.total_length);
- field = ulp_rte_parser_fld_copy(field,
- &ipv4_spec->hdr.total_length,
- size);
- size = sizeof(ipv4_spec->hdr.packet_id);
- field = ulp_rte_parser_fld_copy(field,
- &ipv4_spec->hdr.packet_id,
- size);
- size = sizeof(ipv4_spec->hdr.fragment_offset);
- field = ulp_rte_parser_fld_copy(field,
- &ipv4_spec->hdr.fragment_offset,
- size);
- size = sizeof(ipv4_spec->hdr.time_to_live);
- field = ulp_rte_parser_fld_copy(field,
- &ipv4_spec->hdr.time_to_live,
- size);
- size = sizeof(ipv4_spec->hdr.next_proto_id);
- field = ulp_rte_parser_fld_copy(field,
- &ipv4_spec->hdr.next_proto_id,
- size);
+ size = sizeof(((struct rte_flow_item_ipv4 *)NULL)->hdr.version_ihl);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(ipv4_spec, hdr.version_ihl),
+ ulp_deference_struct(ipv4_mask, hdr.version_ihl),
+ ULP_PRSR_ACT_DEFAULT);
+
+ /*
+ * The tos field is ignored since OVS is setting it as wild card
+ * match and it is not supported. This is a work around and
+ * shall be addressed in the future.
+ */
+ size = sizeof(((struct rte_flow_item_ipv4 *)NULL)->hdr.type_of_service);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(ipv4_spec,
+ hdr.type_of_service),
+ ulp_deference_struct(ipv4_mask,
+ hdr.type_of_service),
+ ULP_PRSR_ACT_MASK_IGNORE);
+
+ size = sizeof(((struct rte_flow_item_ipv4 *)NULL)->hdr.total_length);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(ipv4_spec, hdr.total_length),
+ ulp_deference_struct(ipv4_mask, hdr.total_length),
+ ULP_PRSR_ACT_DEFAULT);
+
+ size = sizeof(((struct rte_flow_item_ipv4 *)NULL)->hdr.packet_id);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(ipv4_spec, hdr.packet_id),
+ ulp_deference_struct(ipv4_mask, hdr.packet_id),
+ ULP_PRSR_ACT_DEFAULT);
+
+ size = sizeof(((struct rte_flow_item_ipv4 *)NULL)->hdr.fragment_offset);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(ipv4_spec,
+ hdr.fragment_offset),
+ ulp_deference_struct(ipv4_mask,
+ hdr.fragment_offset),
+ ULP_PRSR_ACT_DEFAULT);
+
+ size = sizeof(((struct rte_flow_item_ipv4 *)NULL)->hdr.time_to_live);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(ipv4_spec, hdr.time_to_live),
+ ulp_deference_struct(ipv4_mask, hdr.time_to_live),
+ ULP_PRSR_ACT_DEFAULT);
+
+ /* Ignore proto for matching templates */
+ size = sizeof(((struct rte_flow_item_ipv4 *)NULL)->hdr.next_proto_id);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(ipv4_spec,
+ hdr.next_proto_id),
+ ulp_deference_struct(ipv4_mask,
+ hdr.next_proto_id),
+ ULP_PRSR_ACT_MATCH_IGNORE);
+ if (ipv4_spec)
proto = ipv4_spec->hdr.next_proto_id;
- size = sizeof(ipv4_spec->hdr.hdr_checksum);
- field = ulp_rte_parser_fld_copy(field,
- &ipv4_spec->hdr.hdr_checksum,
- size);
- size = sizeof(ipv4_spec->hdr.src_addr);
- field = ulp_rte_parser_fld_copy(field,
- &ipv4_spec->hdr.src_addr,
- size);
- size = sizeof(ipv4_spec->hdr.dst_addr);
- field = ulp_rte_parser_fld_copy(field,
- &ipv4_spec->hdr.dst_addr,
- size);
- }
- if (ipv4_mask) {
- ulp_rte_prsr_mask_copy(params, &idx,
- &ipv4_mask->hdr.version_ihl,
- sizeof(ipv4_mask->hdr.version_ihl));
- /*
- * The tos field is ignored since OVS is setting it as wild card
- * match and it is not supported. This is a work around and
- * shall be addressed in the future.
- */
- ulp_rte_prsr_mask_ignore(params, &idx,
- &ipv4_mask->hdr.type_of_service,
- sizeof(ipv4_mask->hdr.type_of_service)
- );
-
- ulp_rte_prsr_mask_copy(params, &idx,
- &ipv4_mask->hdr.total_length,
- sizeof(ipv4_mask->hdr.total_length));
- ulp_rte_prsr_mask_copy(params, &idx,
- &ipv4_mask->hdr.packet_id,
- sizeof(ipv4_mask->hdr.packet_id));
- ulp_rte_prsr_mask_copy(params, &idx,
- &ipv4_mask->hdr.fragment_offset,
- sizeof(ipv4_mask->hdr.fragment_offset));
- ulp_rte_prsr_mask_copy(params, &idx,
- &ipv4_mask->hdr.time_to_live,
- sizeof(ipv4_mask->hdr.time_to_live));
- ulp_rte_prsr_mask_copy(params, &idx,
- &ipv4_mask->hdr.next_proto_id,
- sizeof(ipv4_mask->hdr.next_proto_id));
- ulp_rte_prsr_mask_copy(params, &idx,
- &ipv4_mask->hdr.hdr_checksum,
- sizeof(ipv4_mask->hdr.hdr_checksum));
- ulp_rte_prsr_mask_copy(params, &idx,
- &ipv4_mask->hdr.src_addr,
- sizeof(ipv4_mask->hdr.src_addr));
- ulp_rte_prsr_mask_copy(params, &idx,
- &ipv4_mask->hdr.dst_addr,
- sizeof(ipv4_mask->hdr.dst_addr));
- }
- /* Add the number of ipv4 header elements */
- params->field_idx += BNXT_ULP_PROTO_HDR_IPV4_NUM;
+
+ size = sizeof(((struct rte_flow_item_ipv4 *)NULL)->hdr.hdr_checksum);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(ipv4_spec, hdr.hdr_checksum),
+ ulp_deference_struct(ipv4_mask, hdr.hdr_checksum),
+ ULP_PRSR_ACT_DEFAULT);
+
+ size = sizeof(((struct rte_flow_item_ipv4 *)NULL)->hdr.src_addr);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(ipv4_spec, hdr.src_addr),
+ ulp_deference_struct(ipv4_mask, hdr.src_addr),
+ ULP_PRSR_ACT_DEFAULT);
+
+ size = sizeof(((struct rte_flow_item_ipv4 *)NULL)->hdr.dst_addr);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(ipv4_spec, hdr.dst_addr),
+ ulp_deference_struct(ipv4_mask, hdr.dst_addr),
+ ULP_PRSR_ACT_DEFAULT);
/* Set the ipv4 header bitmap and computed l3 header bitmaps */
if (ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_IPV4) ||
{
const struct rte_flow_item_ipv6 *ipv6_spec = item->spec;
const struct rte_flow_item_ipv6 *ipv6_mask = item->mask;
- struct ulp_rte_hdr_field *field;
struct ulp_rte_hdr_bitmap *hdr_bitmap = ¶ms->hdr_bitmap;
- uint32_t idx = params->field_idx;
+ uint32_t idx = 0;
uint32_t size;
- uint32_t vtcf, vtcf_mask;
+ uint32_t ver_spec = 0, ver_mask = 0;
+ uint32_t tc_spec = 0, tc_mask = 0;
+ uint32_t lab_spec = 0, lab_mask = 0;
uint8_t proto = 0;
uint32_t inner_flag = 0;
uint32_t cnt;
params->field_idx = idx;
}
+ if (ulp_rte_prsr_fld_size_validate(params, &idx,
+ BNXT_ULP_PROTO_HDR_IPV6_NUM)) {
+ BNXT_TF_DBG(ERR, "Error parsing protocol header\n");
+ return BNXT_TF_RC_ERROR;
+ }
+
/*
* Copy the rte_flow_item for ipv6 into hdr_field using ipv6
* header fields
*/
if (ipv6_spec) {
- size = sizeof(ipv6_spec->hdr.vtc_flow);
-
- vtcf = BNXT_ULP_GET_IPV6_VER(ipv6_spec->hdr.vtc_flow);
- field = ulp_rte_parser_fld_copy(¶ms->hdr_field[idx],
- &vtcf,
- size);
-
- vtcf = BNXT_ULP_GET_IPV6_TC(ipv6_spec->hdr.vtc_flow);
- field = ulp_rte_parser_fld_copy(field,
- &vtcf,
- size);
-
- vtcf = BNXT_ULP_GET_IPV6_FLOWLABEL(ipv6_spec->hdr.vtc_flow);
- field = ulp_rte_parser_fld_copy(field,
- &vtcf,
- size);
-
- size = sizeof(ipv6_spec->hdr.payload_len);
- field = ulp_rte_parser_fld_copy(field,
- &ipv6_spec->hdr.payload_len,
- size);
- size = sizeof(ipv6_spec->hdr.proto);
- field = ulp_rte_parser_fld_copy(field,
- &ipv6_spec->hdr.proto,
- size);
+ ver_spec = BNXT_ULP_GET_IPV6_VER(ipv6_spec->hdr.vtc_flow);
+ tc_spec = BNXT_ULP_GET_IPV6_TC(ipv6_spec->hdr.vtc_flow);
+ lab_spec = BNXT_ULP_GET_IPV6_FLOWLABEL(ipv6_spec->hdr.vtc_flow);
proto = ipv6_spec->hdr.proto;
- size = sizeof(ipv6_spec->hdr.hop_limits);
- field = ulp_rte_parser_fld_copy(field,
- &ipv6_spec->hdr.hop_limits,
- size);
- size = sizeof(ipv6_spec->hdr.src_addr);
- field = ulp_rte_parser_fld_copy(field,
- &ipv6_spec->hdr.src_addr,
- size);
- size = sizeof(ipv6_spec->hdr.dst_addr);
- field = ulp_rte_parser_fld_copy(field,
- &ipv6_spec->hdr.dst_addr,
- size);
}
+
if (ipv6_mask) {
- size = sizeof(ipv6_mask->hdr.vtc_flow);
+ ver_mask = BNXT_ULP_GET_IPV6_VER(ipv6_mask->hdr.vtc_flow);
+ tc_mask = BNXT_ULP_GET_IPV6_TC(ipv6_mask->hdr.vtc_flow);
+ lab_mask = BNXT_ULP_GET_IPV6_FLOWLABEL(ipv6_mask->hdr.vtc_flow);
- vtcf_mask = BNXT_ULP_GET_IPV6_VER(ipv6_mask->hdr.vtc_flow);
- ulp_rte_prsr_mask_copy(params, &idx,
- &vtcf_mask,
- size);
- /*
- * The TC and flow label field are ignored since OVS is
- * setting it for match and it is not supported.
- * This is a work around and
- * shall be addressed in the future.
+ /* Some of the PMD applications may set the protocol field
+ * in the IPv6 spec but don't set the mask. So, consider
+ * the mask in proto value calculation.
*/
- vtcf_mask = BNXT_ULP_GET_IPV6_TC(ipv6_mask->hdr.vtc_flow);
- ulp_rte_prsr_mask_ignore(params, &idx, &vtcf_mask, size);
- vtcf_mask =
- BNXT_ULP_GET_IPV6_FLOWLABEL(ipv6_mask->hdr.vtc_flow);
- ulp_rte_prsr_mask_ignore(params, &idx, &vtcf_mask, size);
-
- ulp_rte_prsr_mask_copy(params, &idx,
- &ipv6_mask->hdr.payload_len,
- sizeof(ipv6_mask->hdr.payload_len));
- ulp_rte_prsr_mask_copy(params, &idx,
- &ipv6_mask->hdr.proto,
- sizeof(ipv6_mask->hdr.proto));
- ulp_rte_prsr_mask_copy(params, &idx,
- &ipv6_mask->hdr.hop_limits,
- sizeof(ipv6_mask->hdr.hop_limits));
- ulp_rte_prsr_mask_copy(params, &idx,
- &ipv6_mask->hdr.src_addr,
- sizeof(ipv6_mask->hdr.src_addr));
- ulp_rte_prsr_mask_copy(params, &idx,
- &ipv6_mask->hdr.dst_addr,
- sizeof(ipv6_mask->hdr.dst_addr));
- }
- /* add number of ipv6 header elements */
- params->field_idx += BNXT_ULP_PROTO_HDR_IPV6_NUM;
+ proto &= ipv6_mask->hdr.proto;
+ }
+
+ size = sizeof(((struct rte_flow_item_ipv6 *)NULL)->hdr.vtc_flow);
+ ulp_rte_prsr_fld_mask(params, &idx, size, &ver_spec, &ver_mask,
+ ULP_PRSR_ACT_DEFAULT);
+ /*
+ * The TC and flow label field are ignored since OVS is setting
+ * it for match and it is not supported.
+ * This is a work around and
+ * shall be addressed in the future.
+ */
+ ulp_rte_prsr_fld_mask(params, &idx, size, &tc_spec, &tc_mask,
+ ULP_PRSR_ACT_MASK_IGNORE);
+ ulp_rte_prsr_fld_mask(params, &idx, size, &lab_spec, &lab_mask,
+ ULP_PRSR_ACT_MASK_IGNORE);
+
+ size = sizeof(((struct rte_flow_item_ipv6 *)NULL)->hdr.payload_len);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(ipv6_spec, hdr.payload_len),
+ ulp_deference_struct(ipv6_mask, hdr.payload_len),
+ ULP_PRSR_ACT_DEFAULT);
+
+ /* Ignore proto for template matching */
+ size = sizeof(((struct rte_flow_item_ipv6 *)NULL)->hdr.proto);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(ipv6_spec, hdr.proto),
+ ulp_deference_struct(ipv6_mask, hdr.proto),
+ ULP_PRSR_ACT_MATCH_IGNORE);
+
+ size = sizeof(((struct rte_flow_item_ipv6 *)NULL)->hdr.hop_limits);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(ipv6_spec, hdr.hop_limits),
+ ulp_deference_struct(ipv6_mask, hdr.hop_limits),
+ ULP_PRSR_ACT_DEFAULT);
+
+ size = sizeof(((struct rte_flow_item_ipv6 *)NULL)->hdr.src_addr);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(ipv6_spec, hdr.src_addr),
+ ulp_deference_struct(ipv6_mask, hdr.src_addr),
+ ULP_PRSR_ACT_DEFAULT);
+
+ size = sizeof(((struct rte_flow_item_ipv6 *)NULL)->hdr.dst_addr);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(ipv6_spec, hdr.dst_addr),
+ ulp_deference_struct(ipv6_mask, hdr.dst_addr),
+ ULP_PRSR_ACT_DEFAULT);
/* Set the ipv6 header bitmap and computed l3 header bitmaps */
if (ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_IPV4) ||
ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_O_L3, 1);
}
- /* Some of the PMD applications may set the protocol field
- * in the IPv6 spec but don't set the mask. So, consider
- * the mask in proto value calculation.
- */
- if (ipv6_mask)
- proto &= ipv6_mask->hdr.proto;
-
/* Update the field protocol hdr bitmap */
ulp_rte_l3_proto_type_update(params, proto, inner_flag);
ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_L3_HDR_CNT, ++cnt);
ulp_rte_l4_proto_type_update(struct ulp_rte_parser_params *param,
uint16_t dst_port)
{
- if (dst_port == tfp_cpu_to_be_16(ULP_UDP_PORT_VXLAN)) {
+ if (dst_port == tfp_cpu_to_be_16(ULP_UDP_PORT_VXLAN))
ULP_BITMAP_SET(param->hdr_fp_bit.bits,
BNXT_ULP_HDR_BIT_T_VXLAN);
+
+ if (ULP_BITMAP_ISSET(param->hdr_bitmap.bits,
+ BNXT_ULP_HDR_BIT_T_VXLAN) ||
+ ULP_BITMAP_ISSET(param->hdr_bitmap.bits,
+ BNXT_ULP_HDR_BIT_T_GRE))
ULP_COMP_FLD_IDX_WR(param, BNXT_ULP_CF_IDX_L3_TUN, 1);
- }
}
/* Function to handle the parsing of RTE Flow item UDP Header. */
{
const struct rte_flow_item_udp *udp_spec = item->spec;
const struct rte_flow_item_udp *udp_mask = item->mask;
- struct ulp_rte_hdr_field *field;
struct ulp_rte_hdr_bitmap *hdr_bitmap = ¶ms->hdr_bitmap;
- uint32_t idx = params->field_idx;
+ uint32_t idx = 0;
uint32_t size;
- uint16_t dst_port = 0;
+ uint16_t dport = 0, sport = 0;
uint32_t cnt;
cnt = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_L4_HDR_CNT);
return BNXT_TF_RC_ERROR;
}
+ if (udp_spec) {
+ sport = udp_spec->hdr.src_port;
+ dport = udp_spec->hdr.dst_port;
+ }
+
+ if (ulp_rte_prsr_fld_size_validate(params, &idx,
+ BNXT_ULP_PROTO_HDR_UDP_NUM)) {
+ BNXT_TF_DBG(ERR, "Error parsing protocol header\n");
+ return BNXT_TF_RC_ERROR;
+ }
+
/*
* Copy the rte_flow_item for ipv4 into hdr_field using ipv4
* header fields
*/
- if (udp_spec) {
- size = sizeof(udp_spec->hdr.src_port);
- field = ulp_rte_parser_fld_copy(¶ms->hdr_field[idx],
- &udp_spec->hdr.src_port,
- size);
-
- size = sizeof(udp_spec->hdr.dst_port);
- field = ulp_rte_parser_fld_copy(field,
- &udp_spec->hdr.dst_port,
- size);
- dst_port = udp_spec->hdr.dst_port;
- size = sizeof(udp_spec->hdr.dgram_len);
- field = ulp_rte_parser_fld_copy(field,
- &udp_spec->hdr.dgram_len,
- size);
- size = sizeof(udp_spec->hdr.dgram_cksum);
- field = ulp_rte_parser_fld_copy(field,
- &udp_spec->hdr.dgram_cksum,
- size);
- }
- if (udp_mask) {
- ulp_rte_prsr_mask_copy(params, &idx,
- &udp_mask->hdr.src_port,
- sizeof(udp_mask->hdr.src_port));
- ulp_rte_prsr_mask_copy(params, &idx,
- &udp_mask->hdr.dst_port,
- sizeof(udp_mask->hdr.dst_port));
- ulp_rte_prsr_mask_copy(params, &idx,
- &udp_mask->hdr.dgram_len,
- sizeof(udp_mask->hdr.dgram_len));
- ulp_rte_prsr_mask_copy(params, &idx,
- &udp_mask->hdr.dgram_cksum,
- sizeof(udp_mask->hdr.dgram_cksum));
- }
-
- /* Add number of UDP header elements */
- params->field_idx += BNXT_ULP_PROTO_HDR_UDP_NUM;
+ size = sizeof(((struct rte_flow_item_udp *)NULL)->hdr.src_port);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(udp_spec, hdr.src_port),
+ ulp_deference_struct(udp_mask, hdr.src_port),
+ ULP_PRSR_ACT_DEFAULT);
+
+ size = sizeof(((struct rte_flow_item_udp *)NULL)->hdr.dst_port);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(udp_spec, hdr.dst_port),
+ ulp_deference_struct(udp_mask, hdr.dst_port),
+ ULP_PRSR_ACT_DEFAULT);
+
+ size = sizeof(((struct rte_flow_item_udp *)NULL)->hdr.dgram_len);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(udp_spec, hdr.dgram_len),
+ ulp_deference_struct(udp_mask, hdr.dgram_len),
+ ULP_PRSR_ACT_DEFAULT);
+
+ size = sizeof(((struct rte_flow_item_udp *)NULL)->hdr.dgram_cksum);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(udp_spec, hdr.dgram_cksum),
+ ulp_deference_struct(udp_mask, hdr.dgram_cksum),
+ ULP_PRSR_ACT_DEFAULT);
/* Set the udp header bitmap and computed l4 header bitmaps */
if (ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_UDP) ||
ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_TCP)) {
ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_I_UDP);
ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_I_L4, 1);
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_I_L4_SRC_PORT,
+ (uint32_t)rte_be_to_cpu_16(sport));
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_I_L4_DST_PORT,
+ (uint32_t)rte_be_to_cpu_16(dport));
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_I_L3_FB_PROTO_ID,
+ 1);
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_I_L3_PROTO_ID,
+ IPPROTO_UDP);
+ if (udp_mask && udp_mask->hdr.src_port)
+ ULP_COMP_FLD_IDX_WR(params,
+ BNXT_ULP_CF_IDX_I_L4_FB_SRC_PORT,
+ 1);
+ if (udp_mask && udp_mask->hdr.dst_port)
+ ULP_COMP_FLD_IDX_WR(params,
+ BNXT_ULP_CF_IDX_I_L4_FB_DST_PORT,
+ 1);
} else {
ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_UDP);
ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_O_L4, 1);
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_O_L4_SRC_PORT,
+ (uint32_t)rte_be_to_cpu_16(sport));
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_O_L4_DST_PORT,
+ (uint32_t)rte_be_to_cpu_16(dport));
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_O_L3_FB_PROTO_ID,
+ 1);
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_O_L3_PROTO_ID,
+ IPPROTO_UDP);
+ if (udp_mask && udp_mask->hdr.src_port)
+ ULP_COMP_FLD_IDX_WR(params,
+ BNXT_ULP_CF_IDX_O_L4_FB_SRC_PORT,
+ 1);
+ if (udp_mask && udp_mask->hdr.dst_port)
+ ULP_COMP_FLD_IDX_WR(params,
+ BNXT_ULP_CF_IDX_O_L4_FB_DST_PORT,
+ 1);
+
/* Update the field protocol hdr bitmap */
- ulp_rte_l4_proto_type_update(params, dst_port);
+ ulp_rte_l4_proto_type_update(params, dport);
}
ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_L4_HDR_CNT, ++cnt);
return BNXT_TF_RC_SUCCESS;
{
const struct rte_flow_item_tcp *tcp_spec = item->spec;
const struct rte_flow_item_tcp *tcp_mask = item->mask;
- struct ulp_rte_hdr_field *field;
struct ulp_rte_hdr_bitmap *hdr_bitmap = ¶ms->hdr_bitmap;
- uint32_t idx = params->field_idx;
+ uint32_t idx = 0;
+ uint16_t dport = 0, sport = 0;
uint32_t size;
uint32_t cnt;
return BNXT_TF_RC_ERROR;
}
+ if (tcp_spec) {
+ sport = tcp_spec->hdr.src_port;
+ dport = tcp_spec->hdr.dst_port;
+ }
+
+ if (ulp_rte_prsr_fld_size_validate(params, &idx,
+ BNXT_ULP_PROTO_HDR_TCP_NUM)) {
+ BNXT_TF_DBG(ERR, "Error parsing protocol header\n");
+ return BNXT_TF_RC_ERROR;
+ }
+
/*
* Copy the rte_flow_item for ipv4 into hdr_field using ipv4
* header fields
*/
- if (tcp_spec) {
- size = sizeof(tcp_spec->hdr.src_port);
- field = ulp_rte_parser_fld_copy(¶ms->hdr_field[idx],
- &tcp_spec->hdr.src_port,
- size);
- size = sizeof(tcp_spec->hdr.dst_port);
- field = ulp_rte_parser_fld_copy(field,
- &tcp_spec->hdr.dst_port,
- size);
- size = sizeof(tcp_spec->hdr.sent_seq);
- field = ulp_rte_parser_fld_copy(field,
- &tcp_spec->hdr.sent_seq,
- size);
- size = sizeof(tcp_spec->hdr.recv_ack);
- field = ulp_rte_parser_fld_copy(field,
- &tcp_spec->hdr.recv_ack,
- size);
- size = sizeof(tcp_spec->hdr.data_off);
- field = ulp_rte_parser_fld_copy(field,
- &tcp_spec->hdr.data_off,
- size);
- size = sizeof(tcp_spec->hdr.tcp_flags);
- field = ulp_rte_parser_fld_copy(field,
- &tcp_spec->hdr.tcp_flags,
- size);
- size = sizeof(tcp_spec->hdr.rx_win);
- field = ulp_rte_parser_fld_copy(field,
- &tcp_spec->hdr.rx_win,
- size);
- size = sizeof(tcp_spec->hdr.cksum);
- field = ulp_rte_parser_fld_copy(field,
- &tcp_spec->hdr.cksum,
- size);
- size = sizeof(tcp_spec->hdr.tcp_urp);
- field = ulp_rte_parser_fld_copy(field,
- &tcp_spec->hdr.tcp_urp,
- size);
- } else {
- idx += BNXT_ULP_PROTO_HDR_TCP_NUM;
- }
-
- if (tcp_mask) {
- ulp_rte_prsr_mask_copy(params, &idx,
- &tcp_mask->hdr.src_port,
- sizeof(tcp_mask->hdr.src_port));
- ulp_rte_prsr_mask_copy(params, &idx,
- &tcp_mask->hdr.dst_port,
- sizeof(tcp_mask->hdr.dst_port));
- ulp_rte_prsr_mask_copy(params, &idx,
- &tcp_mask->hdr.sent_seq,
- sizeof(tcp_mask->hdr.sent_seq));
- ulp_rte_prsr_mask_copy(params, &idx,
- &tcp_mask->hdr.recv_ack,
- sizeof(tcp_mask->hdr.recv_ack));
- ulp_rte_prsr_mask_copy(params, &idx,
- &tcp_mask->hdr.data_off,
- sizeof(tcp_mask->hdr.data_off));
- ulp_rte_prsr_mask_copy(params, &idx,
- &tcp_mask->hdr.tcp_flags,
- sizeof(tcp_mask->hdr.tcp_flags));
- ulp_rte_prsr_mask_copy(params, &idx,
- &tcp_mask->hdr.rx_win,
- sizeof(tcp_mask->hdr.rx_win));
- ulp_rte_prsr_mask_copy(params, &idx,
- &tcp_mask->hdr.cksum,
- sizeof(tcp_mask->hdr.cksum));
- ulp_rte_prsr_mask_copy(params, &idx,
- &tcp_mask->hdr.tcp_urp,
- sizeof(tcp_mask->hdr.tcp_urp));
- }
- /* add number of TCP header elements */
- params->field_idx += BNXT_ULP_PROTO_HDR_TCP_NUM;
+ size = sizeof(((struct rte_flow_item_tcp *)NULL)->hdr.src_port);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(tcp_spec, hdr.src_port),
+ ulp_deference_struct(tcp_mask, hdr.src_port),
+ ULP_PRSR_ACT_DEFAULT);
+
+ size = sizeof(((struct rte_flow_item_tcp *)NULL)->hdr.dst_port);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(tcp_spec, hdr.dst_port),
+ ulp_deference_struct(tcp_mask, hdr.dst_port),
+ ULP_PRSR_ACT_DEFAULT);
+
+ size = sizeof(((struct rte_flow_item_tcp *)NULL)->hdr.sent_seq);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(tcp_spec, hdr.sent_seq),
+ ulp_deference_struct(tcp_mask, hdr.sent_seq),
+ ULP_PRSR_ACT_DEFAULT);
+
+ size = sizeof(((struct rte_flow_item_tcp *)NULL)->hdr.recv_ack);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(tcp_spec, hdr.recv_ack),
+ ulp_deference_struct(tcp_mask, hdr.recv_ack),
+ ULP_PRSR_ACT_DEFAULT);
+
+ size = sizeof(((struct rte_flow_item_tcp *)NULL)->hdr.data_off);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(tcp_spec, hdr.data_off),
+ ulp_deference_struct(tcp_mask, hdr.data_off),
+ ULP_PRSR_ACT_DEFAULT);
+
+ size = sizeof(((struct rte_flow_item_tcp *)NULL)->hdr.tcp_flags);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(tcp_spec, hdr.tcp_flags),
+ ulp_deference_struct(tcp_mask, hdr.tcp_flags),
+ ULP_PRSR_ACT_DEFAULT);
+
+ size = sizeof(((struct rte_flow_item_tcp *)NULL)->hdr.rx_win);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(tcp_spec, hdr.rx_win),
+ ulp_deference_struct(tcp_mask, hdr.rx_win),
+ ULP_PRSR_ACT_DEFAULT);
+
+ size = sizeof(((struct rte_flow_item_tcp *)NULL)->hdr.cksum);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(tcp_spec, hdr.cksum),
+ ulp_deference_struct(tcp_mask, hdr.cksum),
+ ULP_PRSR_ACT_DEFAULT);
+
+ size = sizeof(((struct rte_flow_item_tcp *)NULL)->hdr.tcp_urp);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(tcp_spec, hdr.tcp_urp),
+ ulp_deference_struct(tcp_mask, hdr.tcp_urp),
+ ULP_PRSR_ACT_DEFAULT);
/* Set the udp header bitmap and computed l4 header bitmaps */
if (ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_UDP) ||
ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_TCP)) {
ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_I_TCP);
ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_I_L4, 1);
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_I_L4_SRC_PORT,
+ (uint32_t)rte_be_to_cpu_16(sport));
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_I_L4_DST_PORT,
+ (uint32_t)rte_be_to_cpu_16(dport));
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_I_L3_FB_PROTO_ID,
+ 1);
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_I_L3_PROTO_ID,
+ IPPROTO_TCP);
+ if (tcp_mask && tcp_mask->hdr.src_port)
+ ULP_COMP_FLD_IDX_WR(params,
+ BNXT_ULP_CF_IDX_I_L4_FB_SRC_PORT,
+ 1);
+ if (tcp_mask && tcp_mask->hdr.dst_port)
+ ULP_COMP_FLD_IDX_WR(params,
+ BNXT_ULP_CF_IDX_I_L4_FB_DST_PORT,
+ 1);
} else {
ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_TCP);
ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_O_L4, 1);
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_O_L4_SRC_PORT,
+ (uint32_t)rte_be_to_cpu_16(sport));
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_O_L4_DST_PORT,
+ (uint32_t)rte_be_to_cpu_16(dport));
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_O_L3_FB_PROTO_ID,
+ 1);
+ ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_O_L3_PROTO_ID,
+ IPPROTO_TCP);
+ if (tcp_mask && tcp_mask->hdr.src_port)
+ ULP_COMP_FLD_IDX_WR(params,
+ BNXT_ULP_CF_IDX_O_L4_FB_SRC_PORT,
+ 1);
+ if (tcp_mask && tcp_mask->hdr.dst_port)
+ ULP_COMP_FLD_IDX_WR(params,
+ BNXT_ULP_CF_IDX_O_L4_FB_DST_PORT,
+ 1);
}
ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_L4_HDR_CNT, ++cnt);
return BNXT_TF_RC_SUCCESS;
{
const struct rte_flow_item_vxlan *vxlan_spec = item->spec;
const struct rte_flow_item_vxlan *vxlan_mask = item->mask;
- struct ulp_rte_hdr_field *field;
struct ulp_rte_hdr_bitmap *hdr_bitmap = ¶ms->hdr_bitmap;
- uint32_t idx = params->field_idx;
+ uint32_t idx = 0;
uint32_t size;
+ if (ulp_rte_prsr_fld_size_validate(params, &idx,
+ BNXT_ULP_PROTO_HDR_VXLAN_NUM)) {
+ BNXT_TF_DBG(ERR, "Error parsing protocol header\n");
+ return BNXT_TF_RC_ERROR;
+ }
+
/*
* Copy the rte_flow_item for vxlan into hdr_field using vxlan
* header fields
*/
- if (vxlan_spec) {
- size = sizeof(vxlan_spec->flags);
- field = ulp_rte_parser_fld_copy(¶ms->hdr_field[idx],
- &vxlan_spec->flags,
- size);
- size = sizeof(vxlan_spec->rsvd0);
- field = ulp_rte_parser_fld_copy(field,
- &vxlan_spec->rsvd0,
- size);
- size = sizeof(vxlan_spec->vni);
- field = ulp_rte_parser_fld_copy(field,
- &vxlan_spec->vni,
- size);
- size = sizeof(vxlan_spec->rsvd1);
- field = ulp_rte_parser_fld_copy(field,
- &vxlan_spec->rsvd1,
- size);
- }
- if (vxlan_mask) {
- ulp_rte_prsr_mask_copy(params, &idx,
- &vxlan_mask->flags,
- sizeof(vxlan_mask->flags));
- ulp_rte_prsr_mask_copy(params, &idx,
- &vxlan_mask->rsvd0,
- sizeof(vxlan_mask->rsvd0));
- ulp_rte_prsr_mask_copy(params, &idx,
- &vxlan_mask->vni,
- sizeof(vxlan_mask->vni));
- ulp_rte_prsr_mask_copy(params, &idx,
- &vxlan_mask->rsvd1,
- sizeof(vxlan_mask->rsvd1));
- }
- /* Add number of vxlan header elements */
- params->field_idx += BNXT_ULP_PROTO_HDR_VXLAN_NUM;
+ size = sizeof(((struct rte_flow_item_vxlan *)NULL)->flags);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(vxlan_spec, flags),
+ ulp_deference_struct(vxlan_mask, flags),
+ ULP_PRSR_ACT_DEFAULT);
+
+ size = sizeof(((struct rte_flow_item_vxlan *)NULL)->rsvd0);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(vxlan_spec, rsvd0),
+ ulp_deference_struct(vxlan_mask, rsvd0),
+ ULP_PRSR_ACT_DEFAULT);
+
+ size = sizeof(((struct rte_flow_item_vxlan *)NULL)->vni);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(vxlan_spec, vni),
+ ulp_deference_struct(vxlan_mask, vni),
+ ULP_PRSR_ACT_DEFAULT);
+
+ size = sizeof(((struct rte_flow_item_vxlan *)NULL)->rsvd1);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(vxlan_spec, rsvd1),
+ ulp_deference_struct(vxlan_mask, rsvd1),
+ ULP_PRSR_ACT_DEFAULT);
/* Update the hdr_bitmap with vxlan */
ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_T_VXLAN);
+ ulp_rte_l4_proto_type_update(params, 0);
+ return BNXT_TF_RC_SUCCESS;
+}
+
+/* Function to handle the parsing of RTE Flow item GRE Header. */
+int32_t
+ulp_rte_gre_hdr_handler(const struct rte_flow_item *item,
+ struct ulp_rte_parser_params *params)
+{
+ const struct rte_flow_item_gre *gre_spec = item->spec;
+ const struct rte_flow_item_gre *gre_mask = item->mask;
+ struct ulp_rte_hdr_bitmap *hdr_bitmap = ¶ms->hdr_bitmap;
+ uint32_t idx = 0;
+ uint32_t size;
+
+ if (ulp_rte_prsr_fld_size_validate(params, &idx,
+ BNXT_ULP_PROTO_HDR_GRE_NUM)) {
+ BNXT_TF_DBG(ERR, "Error parsing protocol header\n");
+ return BNXT_TF_RC_ERROR;
+ }
+
+ size = sizeof(((struct rte_flow_item_gre *)NULL)->c_rsvd0_ver);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(gre_spec, c_rsvd0_ver),
+ ulp_deference_struct(gre_mask, c_rsvd0_ver),
+ ULP_PRSR_ACT_DEFAULT);
+
+ size = sizeof(((struct rte_flow_item_gre *)NULL)->protocol);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(gre_spec, protocol),
+ ulp_deference_struct(gre_mask, protocol),
+ ULP_PRSR_ACT_DEFAULT);
+
+ /* Update the hdr_bitmap with GRE */
+ ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_T_GRE);
+ ulp_rte_l4_proto_type_update(params, 0);
+ return BNXT_TF_RC_SUCCESS;
+}
+
+/* Function to handle the parsing of RTE Flow item ANY. */
+int32_t
+ulp_rte_item_any_handler(const struct rte_flow_item *item __rte_unused,
+ struct ulp_rte_parser_params *params __rte_unused)
+{
+ return BNXT_TF_RC_SUCCESS;
+}
+
+/* Function to handle the parsing of RTE Flow item ICMP Header. */
+int32_t
+ulp_rte_icmp_hdr_handler(const struct rte_flow_item *item,
+ struct ulp_rte_parser_params *params)
+{
+ const struct rte_flow_item_icmp *icmp_spec = item->spec;
+ const struct rte_flow_item_icmp *icmp_mask = item->mask;
+ struct ulp_rte_hdr_bitmap *hdr_bitmap = ¶ms->hdr_bitmap;
+ uint32_t idx = 0;
+ uint32_t size;
+
+ if (ulp_rte_prsr_fld_size_validate(params, &idx,
+ BNXT_ULP_PROTO_HDR_ICMP_NUM)) {
+ BNXT_TF_DBG(ERR, "Error parsing protocol header\n");
+ return BNXT_TF_RC_ERROR;
+ }
+
+ size = sizeof(((struct rte_flow_item_icmp *)NULL)->hdr.icmp_type);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(icmp_spec, hdr.icmp_type),
+ ulp_deference_struct(icmp_mask, hdr.icmp_type),
+ ULP_PRSR_ACT_DEFAULT);
+
+ size = sizeof(((struct rte_flow_item_icmp *)NULL)->hdr.icmp_code);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(icmp_spec, hdr.icmp_code),
+ ulp_deference_struct(icmp_mask, hdr.icmp_code),
+ ULP_PRSR_ACT_DEFAULT);
+
+ size = sizeof(((struct rte_flow_item_icmp *)NULL)->hdr.icmp_cksum);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(icmp_spec, hdr.icmp_cksum),
+ ulp_deference_struct(icmp_mask, hdr.icmp_cksum),
+ ULP_PRSR_ACT_DEFAULT);
+
+ size = sizeof(((struct rte_flow_item_icmp *)NULL)->hdr.icmp_ident);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(icmp_spec, hdr.icmp_ident),
+ ulp_deference_struct(icmp_mask, hdr.icmp_ident),
+ ULP_PRSR_ACT_DEFAULT);
+
+ size = sizeof(((struct rte_flow_item_icmp *)NULL)->hdr.icmp_seq_nb);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(icmp_spec, hdr.icmp_seq_nb),
+ ulp_deference_struct(icmp_mask, hdr.icmp_seq_nb),
+ ULP_PRSR_ACT_DEFAULT);
+
+ /* Update the hdr_bitmap with ICMP */
+ if (ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_L3_TUN))
+ ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_I_ICMP);
+ else
+ ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_ICMP);
+ return BNXT_TF_RC_SUCCESS;
+}
+
+/* Function to handle the parsing of RTE Flow item ICMP6 Header. */
+int32_t
+ulp_rte_icmp6_hdr_handler(const struct rte_flow_item *item,
+ struct ulp_rte_parser_params *params)
+{
+ const struct rte_flow_item_icmp6 *icmp_spec = item->spec;
+ const struct rte_flow_item_icmp6 *icmp_mask = item->mask;
+ struct ulp_rte_hdr_bitmap *hdr_bitmap = ¶ms->hdr_bitmap;
+ uint32_t idx = 0;
+ uint32_t size;
+
+ if (ulp_rte_prsr_fld_size_validate(params, &idx,
+ BNXT_ULP_PROTO_HDR_ICMP_NUM)) {
+ BNXT_TF_DBG(ERR, "Error parsing protocol header\n");
+ return BNXT_TF_RC_ERROR;
+ }
+
+ size = sizeof(((struct rte_flow_item_icmp6 *)NULL)->type);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(icmp_spec, type),
+ ulp_deference_struct(icmp_mask, type),
+ ULP_PRSR_ACT_DEFAULT);
+
+ size = sizeof(((struct rte_flow_item_icmp6 *)NULL)->code);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(icmp_spec, code),
+ ulp_deference_struct(icmp_mask, code),
+ ULP_PRSR_ACT_DEFAULT);
+
+ size = sizeof(((struct rte_flow_item_icmp6 *)NULL)->checksum);
+ ulp_rte_prsr_fld_mask(params, &idx, size,
+ ulp_deference_struct(icmp_spec, checksum),
+ ulp_deference_struct(icmp_mask, checksum),
+ ULP_PRSR_ACT_DEFAULT);
+
+ if (ULP_BITMAP_ISSET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_IPV4)) {
+ BNXT_TF_DBG(ERR, "Error: incorrect icmp version\n");
+ return BNXT_TF_RC_ERROR;
+ }
+
+ /* Update the hdr_bitmap with ICMP */
+ if (ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_L3_TUN))
+ ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_I_ICMP);
+ else
+ ULP_BITMAP_SET(hdr_bitmap->bits, BNXT_ULP_HDR_BIT_O_ICMP);
return BNXT_TF_RC_SUCCESS;
}
&mark_id, BNXT_ULP_ACT_PROP_SZ_MARK);
/* Update the hdr_bitmap with vxlan */
- ULP_BITMAP_SET(act->bits, BNXT_ULP_ACTION_BIT_MARK);
+ ULP_BITMAP_SET(act->bits, BNXT_ULP_ACT_BIT_MARK);
return BNXT_TF_RC_SUCCESS;
}
BNXT_TF_DBG(ERR, "Parse Error: Mark arg is invalid\n");
ulp_rte_rss_act_handler(const struct rte_flow_action *action_item,
struct ulp_rte_parser_params *param)
{
- const struct rte_flow_action_rss *rss = action_item->conf;
+ const struct rte_flow_action_rss *rss;
+ struct ulp_rte_act_prop *ap = ¶m->act_prop;
- if (rss) {
- /* Update the hdr_bitmap with vxlan */
- ULP_BITMAP_SET(param->act_bitmap.bits, BNXT_ULP_ACTION_BIT_RSS);
- return BNXT_TF_RC_SUCCESS;
+ if (action_item == NULL || action_item->conf == NULL) {
+ BNXT_TF_DBG(ERR, "Parse Err: invalid rss configuration\n");
+ return BNXT_TF_RC_ERROR;
}
- BNXT_TF_DBG(ERR, "Parse Error: RSS arg is invalid\n");
- return BNXT_TF_RC_ERROR;
+
+ rss = action_item->conf;
+ /* Copy the rss into the specific action properties */
+ memcpy(&ap->act_details[BNXT_ULP_ACT_PROP_IDX_RSS_TYPES], &rss->types,
+ BNXT_ULP_ACT_PROP_SZ_RSS_TYPES);
+ memcpy(&ap->act_details[BNXT_ULP_ACT_PROP_IDX_RSS_LEVEL], &rss->level,
+ BNXT_ULP_ACT_PROP_SZ_RSS_LEVEL);
+ memcpy(&ap->act_details[BNXT_ULP_ACT_PROP_IDX_RSS_KEY_LEN],
+ &rss->key_len, BNXT_ULP_ACT_PROP_SZ_RSS_KEY_LEN);
+
+ if (rss->key_len > BNXT_ULP_ACT_PROP_SZ_RSS_KEY) {
+ BNXT_TF_DBG(ERR, "Parse Err: RSS key too big\n");
+ return BNXT_TF_RC_ERROR;
+ }
+ memcpy(&ap->act_details[BNXT_ULP_ACT_PROP_IDX_RSS_KEY], rss->key,
+ rss->key_len);
+
+ /* set the RSS action header bit */
+ ULP_BITMAP_SET(param->act_bitmap.bits, BNXT_ULP_ACT_BIT_RSS);
+
+ return BNXT_TF_RC_SUCCESS;
}
/* Function to handle the parsing of RTE Flow action vxlan_encap Header. */
buff = &ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_VTAG];
ulp_encap_buffer_copy(buff,
item->spec,
- sizeof(struct rte_vlan_hdr),
+ sizeof(struct rte_flow_item_vlan),
ULP_BUFFER_ALIGN_8_BYTE);
if (!ulp_rte_item_skip_void(&item, 1))
if (item->type == RTE_FLOW_ITEM_TYPE_VLAN) {
vlan_num++;
memcpy(&ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_VTAG +
- sizeof(struct rte_vlan_hdr)],
+ sizeof(struct rte_flow_item_vlan)],
item->spec,
- sizeof(struct rte_vlan_hdr));
+ sizeof(struct rte_flow_item_vlan));
if (!ulp_rte_item_skip_void(&item, 1))
return BNXT_TF_RC_ERROR;
}
/* Update the vlan count and size of more than one */
if (vlan_num) {
- vlan_size = vlan_num * sizeof(struct rte_vlan_hdr);
+ vlan_size = vlan_num * sizeof(struct rte_flow_item_vlan);
vlan_num = tfp_cpu_to_be_32(vlan_num);
memcpy(&ap->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_VTAG_NUM],
&vlan_num,
BNXT_TF_DBG(ERR, "vxlan encap does not have vni\n");
return BNXT_TF_RC_ERROR;
}
- vxlan_size = sizeof(struct rte_vxlan_hdr);
+ vxlan_size = sizeof(struct rte_flow_item_vxlan);
/* copy the vxlan details */
memcpy(&vxlan_spec, item->spec, vxlan_size);
vxlan_spec.flags = 0x08;
&vxlan_size, sizeof(uint32_t));
/* update the hdr_bitmap with vxlan */
- ULP_BITMAP_SET(act->bits, BNXT_ULP_ACTION_BIT_VXLAN_ENCAP);
+ ULP_BITMAP_SET(act->bits, BNXT_ULP_ACT_BIT_VXLAN_ENCAP);
return BNXT_TF_RC_SUCCESS;
}
{
/* update the hdr_bitmap with vxlan */
ULP_BITMAP_SET(params->act_bitmap.bits,
- BNXT_ULP_ACTION_BIT_VXLAN_DECAP);
+ BNXT_ULP_ACT_BIT_VXLAN_DECAP);
/* Update computational field with tunnel decap info */
ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_L3_TUN_DECAP, 1);
ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_L3_TUN, 1);
struct ulp_rte_parser_params *params)
{
/* Update the hdr_bitmap with drop */
- ULP_BITMAP_SET(params->act_bitmap.bits, BNXT_ULP_ACTION_BIT_DROP);
+ ULP_BITMAP_SET(params->act_bitmap.bits, BNXT_ULP_ACT_BIT_DROP);
return BNXT_TF_RC_SUCCESS;
}
int32_t
ulp_rte_count_act_handler(const struct rte_flow_action *action_item,
struct ulp_rte_parser_params *params)
-
{
const struct rte_flow_action_count *act_count;
struct ulp_rte_act_prop *act_prop = ¶ms->act_prop;
}
/* Update the hdr_bitmap with count */
- ULP_BITMAP_SET(params->act_bitmap.bits, BNXT_ULP_ACTION_BIT_COUNT);
+ ULP_BITMAP_SET(params->act_bitmap.bits, BNXT_ULP_ACT_BIT_COUNT);
return BNXT_TF_RC_SUCCESS;
}
struct ulp_rte_parser_params *params)
{
const struct rte_flow_action_vf *vf_action;
- uint32_t ifindex;
enum bnxt_ulp_intf_type intf_type;
+ uint32_t ifindex;
+ struct bnxt *bp;
vf_action = action_item->conf;
if (!vf_action) {
return BNXT_TF_RC_PARSE_ERR;
}
- /* Check the port is VF port */
- if (ulp_port_db_dev_func_id_to_ulp_index(params->ulp_ctx, vf_action->id,
+ bp = bnxt_get_bp(params->port_id);
+ if (bp == NULL) {
+ BNXT_TF_DBG(ERR, "Invalid bp\n");
+ return BNXT_TF_RC_ERROR;
+ }
+
+ /* vf_action->id is a logical number which in this case is an
+ * offset from the first VF. So, to get the absolute VF id, the
+ * offset must be added to the absolute first vf id of that port.
+ */
+ if (ulp_port_db_dev_func_id_to_ulp_index(params->ulp_ctx,
+ bp->first_vf_id +
+ vf_action->id,
&ifindex)) {
BNXT_TF_DBG(ERR, "VF is not valid interface\n");
return BNXT_TF_RC_ERROR;
}
+ /* Check the port is VF port */
intf_type = ulp_port_db_port_type_get(params->ulp_ctx, ifindex);
if (intf_type != BNXT_ULP_INTF_TYPE_VF &&
intf_type != BNXT_ULP_INTF_TYPE_TRUSTED_VF) {
struct ulp_rte_parser_params *params)
{
/* Update the act_bitmap with pop */
- ULP_BITMAP_SET(params->act_bitmap.bits, BNXT_ULP_ACTION_BIT_POP_VLAN);
+ ULP_BITMAP_SET(params->act_bitmap.bits, BNXT_ULP_ACT_BIT_POP_VLAN);
return BNXT_TF_RC_SUCCESS;
}
ðertype, BNXT_ULP_ACT_PROP_SZ_PUSH_VLAN);
/* Update the hdr_bitmap with push vlan */
ULP_BITMAP_SET(params->act_bitmap.bits,
- BNXT_ULP_ACTION_BIT_PUSH_VLAN);
+ BNXT_ULP_ACT_BIT_PUSH_VLAN);
return BNXT_TF_RC_SUCCESS;
}
BNXT_TF_DBG(ERR, "Parse Error: Push vlan arg is invalid\n");
&vid, BNXT_ULP_ACT_PROP_SZ_SET_VLAN_VID);
/* Update the hdr_bitmap with vlan vid */
ULP_BITMAP_SET(params->act_bitmap.bits,
- BNXT_ULP_ACTION_BIT_SET_VLAN_VID);
+ BNXT_ULP_ACT_BIT_SET_VLAN_VID);
return BNXT_TF_RC_SUCCESS;
}
BNXT_TF_DBG(ERR, "Parse Error: Vlan vid arg is invalid\n");
&pcp, BNXT_ULP_ACT_PROP_SZ_SET_VLAN_PCP);
/* Update the hdr_bitmap with vlan vid */
ULP_BITMAP_SET(params->act_bitmap.bits,
- BNXT_ULP_ACTION_BIT_SET_VLAN_PCP);
+ BNXT_ULP_ACT_BIT_SET_VLAN_PCP);
return BNXT_TF_RC_SUCCESS;
}
BNXT_TF_DBG(ERR, "Parse Error: Vlan pcp arg is invalid\n");
&set_ipv4->ipv4_addr, BNXT_ULP_ACT_PROP_SZ_SET_IPV4_SRC);
/* Update the hdr_bitmap with set ipv4 src */
ULP_BITMAP_SET(params->act_bitmap.bits,
- BNXT_ULP_ACTION_BIT_SET_IPV4_SRC);
+ BNXT_ULP_ACT_BIT_SET_IPV4_SRC);
return BNXT_TF_RC_SUCCESS;
}
BNXT_TF_DBG(ERR, "Parse Error: set ipv4 src arg is invalid\n");
&set_ipv4->ipv4_addr, BNXT_ULP_ACT_PROP_SZ_SET_IPV4_DST);
/* Update the hdr_bitmap with set ipv4 dst */
ULP_BITMAP_SET(params->act_bitmap.bits,
- BNXT_ULP_ACTION_BIT_SET_IPV4_DST);
+ BNXT_ULP_ACT_BIT_SET_IPV4_DST);
return BNXT_TF_RC_SUCCESS;
}
BNXT_TF_DBG(ERR, "Parse Error: set ipv4 dst arg is invalid\n");
&set_tp->port, BNXT_ULP_ACT_PROP_SZ_SET_TP_SRC);
/* Update the hdr_bitmap with set tp src */
ULP_BITMAP_SET(params->act_bitmap.bits,
- BNXT_ULP_ACTION_BIT_SET_TP_SRC);
+ BNXT_ULP_ACT_BIT_SET_TP_SRC);
return BNXT_TF_RC_SUCCESS;
}
&set_tp->port, BNXT_ULP_ACT_PROP_SZ_SET_TP_DST);
/* Update the hdr_bitmap with set tp dst */
ULP_BITMAP_SET(params->act_bitmap.bits,
- BNXT_ULP_ACTION_BIT_SET_TP_DST);
+ BNXT_ULP_ACT_BIT_SET_TP_DST);
return BNXT_TF_RC_SUCCESS;
}
struct ulp_rte_parser_params *params)
{
/* Update the act_bitmap with dec ttl */
- ULP_BITMAP_SET(params->act_bitmap.bits, BNXT_ULP_ACTION_BIT_DEC_TTL);
+ ULP_BITMAP_SET(params->act_bitmap.bits, BNXT_ULP_ACT_BIT_DEC_TTL);
return BNXT_TF_RC_SUCCESS;
}
/* Function to handle the parsing of RTE Flow action JUMP */
int32_t
ulp_rte_jump_act_handler(const struct rte_flow_action *action_item __rte_unused,
- struct ulp_rte_parser_params *params)
+ struct ulp_rte_parser_params *params)
{
/* Update the act_bitmap with dec ttl */
- ULP_BITMAP_SET(params->act_bitmap.bits, BNXT_ULP_ACTION_BIT_JUMP);
+ ULP_BITMAP_SET(params->act_bitmap.bits, BNXT_ULP_ACT_BIT_JUMP);
return BNXT_TF_RC_SUCCESS;
}
+
+int32_t
+ulp_rte_sample_act_handler(const struct rte_flow_action *action_item,
+ struct ulp_rte_parser_params *params)
+{
+ const struct rte_flow_action_sample *sample;
+ int ret;
+
+ sample = action_item->conf;
+
+ /* if SAMPLE bit is set it means this sample action is nested within the
+ * actions of another sample action; this is not allowed
+ */
+ if (ULP_BITMAP_ISSET(params->act_bitmap.bits,
+ BNXT_ULP_ACT_BIT_SAMPLE))
+ return BNXT_TF_RC_ERROR;
+
+ /* a sample action is only allowed as a shared action */
+ if (!ULP_BITMAP_ISSET(params->act_bitmap.bits,
+ BNXT_ULP_ACT_BIT_SHARED))
+ return BNXT_TF_RC_ERROR;
+
+ /* only a ratio of 1 i.e. 100% is supported */
+ if (sample->ratio != 1)
+ return BNXT_TF_RC_ERROR;
+
+ if (!sample->actions)
+ return BNXT_TF_RC_ERROR;
+
+ /* parse the nested actions for a sample action */
+ ret = bnxt_ulp_rte_parser_act_parse(sample->actions, params);
+ if (ret == BNXT_TF_RC_SUCCESS)
+ /* Update the act_bitmap with sample */
+ ULP_BITMAP_SET(params->act_bitmap.bits,
+ BNXT_ULP_ACT_BIT_SAMPLE);
+
+ return ret;
+}
git.droids-corp.org / dpdk.git / blobdiff