func = (((res_info->nxt_resource_idx & ULP_FLOW_DB_RES_FUNC_MASK) >>
ULP_FLOW_DB_RES_FUNC_BITS) << ULP_FLOW_DB_RES_FUNC_UPPER);
- /* The reource func is split into upper and lower */
+ /* The resource func is split into upper and lower */
if (func & ULP_FLOW_DB_RES_FUNC_NEED_LOWER)
return (func | res_info->resource_func_lower);
return func;
}
}
-/* internal validation function for parent flow tbl */
-static struct bnxt_ulp_flow_db *
-ulp_flow_db_parent_arg_validation(struct bnxt_ulp_context *ulp_ctxt,
- uint32_t fid)
-{
- struct bnxt_ulp_flow_db *flow_db;
-
- flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
- if (!flow_db) {
- BNXT_TF_DBG(ERR, "Invalid Arguments\n");
- return NULL;
- }
-
- /* check for max flows */
- if (fid >= flow_db->flow_tbl.num_flows || !fid) {
- BNXT_TF_DBG(ERR, "Invalid flow index\n");
- return NULL;
- }
-
- /* No support for parent child db then just exit */
- if (!flow_db->parent_child_db.entries_count) {
- BNXT_TF_DBG(ERR, "parent child db not supported\n");
- return NULL;
- }
-
- return flow_db;
-}
-
-/*
- * Set the tunnel index in the parent flow
- *
- * ulp_ctxt [in] Ptr to ulp_context
- * parent_idx [in] The parent index of the parent flow entry
- *
- * returns index on success and negative on failure.
- */
-static int32_t
-ulp_flow_db_parent_tun_idx_set(struct bnxt_ulp_context *ulp_ctxt,
- uint32_t parent_idx, uint8_t tun_idx)
-{
- struct bnxt_ulp_flow_db *flow_db;
- struct ulp_fdb_parent_child_db *p_pdb;
-
- flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
- if (!flow_db) {
- BNXT_TF_DBG(ERR, "Invalid Arguments\n");
- return -EINVAL;
- }
-
- /* check for parent idx validity */
- p_pdb = &flow_db->parent_child_db;
- if (parent_idx >= p_pdb->entries_count ||
- !p_pdb->parent_flow_tbl[parent_idx].parent_fid) {
- BNXT_TF_DBG(ERR, "Invalid parent flow index %x\n", parent_idx);
- return -EINVAL;
- }
-
- p_pdb->parent_flow_tbl[parent_idx].tun_idx = tun_idx;
- return 0;
-}
-
-/*
- * Get the tunnel index from the parent flow
- *
- * ulp_ctxt [in] Ptr to ulp_context
- * parent_fid [in] The flow id of the parent flow entry
- *
- * returns 0 if counter accum is set else -1.
- */
-static int32_t
-ulp_flow_db_parent_tun_idx_get(struct bnxt_ulp_context *ulp_ctxt,
- uint32_t parent_fid, uint8_t *tun_idx)
-{
- struct bnxt_ulp_flow_db *flow_db;
- struct ulp_fdb_parent_child_db *p_pdb;
- uint32_t idx;
-
- /* validate the arguments */
- flow_db = ulp_flow_db_parent_arg_validation(ulp_ctxt, parent_fid);
- if (!flow_db) {
- BNXT_TF_DBG(ERR, "parent child db validation failed\n");
- return -EINVAL;
- }
-
- p_pdb = &flow_db->parent_child_db;
- for (idx = 0; idx < p_pdb->entries_count; idx++) {
- if (p_pdb->parent_flow_tbl[idx].parent_fid == parent_fid) {
- *tun_idx = p_pdb->parent_flow_tbl[idx].tun_idx;
- return 0;
- }
- }
-
- return -EINVAL;
-}
-
/*
* Initialize the flow database. Memory is allocated in this
* call and assigned to the flow database.
if (flow_type == BNXT_ULP_FDB_TYPE_REGULAR)
ulp_flow_db_func_id_set(flow_db, *fid, func_id);
+#ifdef RTE_LIBRTE_BNXT_TRUFLOW_DEBUG
+ BNXT_TF_DBG(ERR, "flow_id = %u:%u allocated\n", flow_type, *fid);
+#endif
/* return success */
return 0;
}
}
fid_resource = &flow_tbl->flow_resources[fid];
+ if (params->critical_resource && fid_resource->resource_em_handle) {
+ BNXT_TF_DBG(DEBUG, "Ignore multiple critical resources\n");
+ /* Ignore the multiple critical resources */
+ params->critical_resource = BNXT_ULP_CRITICAL_RESOURCE_NO;
+ }
+
if (!params->critical_resource) {
/* Not the critical_resource so allocate a resource */
idx = flow_tbl->flow_tbl_stack[flow_tbl->tail_index];
if (params->resource_type == TF_TBL_TYPE_ACT_STATS_64 &&
params->resource_sub_type ==
BNXT_ULP_RESOURCE_SUB_TYPE_INDEX_TABLE_INT_COUNT &&
- ulp_fc_info) {
+ ulp_fc_info && ulp_fc_info->num_counters) {
/* Store the first HW counter ID for this table */
if (!ulp_fc_mgr_start_idx_isset(ulp_ctxt, params->direction))
ulp_fc_mgr_start_idx_set(ulp_ctxt, params->direction,
* flow_type [in] Specify it is regular or default flow
* fid [in] The index to the flow entry
* params [in/out] The contents to be copied into params.
- * Onlythe critical_resource needs to be set by the caller.
+ * Only the critical_resource needs to be set by the caller.
*
* Returns 0 on success and negative on failure.
*/
struct bnxt_ulp_flow_tbl *flow_tbl;
struct ulp_fdb_resource_info *nxt_resource, *fid_resource;
uint32_t nxt_idx = 0;
- struct bnxt_tun_cache_entry *tun_tbl;
- uint8_t tun_idx = 0;
- int rc;
flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
if (!flow_db) {
params->resource_hndl);
}
- if (params->resource_func == BNXT_ULP_RESOURCE_FUNC_PARENT_FLOW) {
- tun_tbl = bnxt_ulp_cntxt_ptr2_tun_tbl_get(ulp_ctxt);
- if (!tun_tbl)
- return -EINVAL;
-
- rc = ulp_flow_db_parent_tun_idx_get(ulp_ctxt, fid, &tun_idx);
- if (rc)
- return rc;
-
- ulp_clear_tun_entry(tun_tbl, tun_idx);
- }
-
/* all good, return success */
return 0;
}
enum bnxt_ulp_fdb_type flow_type,
uint32_t fid)
{
- struct bnxt_tun_cache_entry *tun_tbl;
struct bnxt_ulp_flow_tbl *flow_tbl;
struct bnxt_ulp_flow_db *flow_db;
if (flow_type == BNXT_ULP_FDB_TYPE_REGULAR)
ulp_flow_db_func_id_set(flow_db, fid, 0);
- tun_tbl = bnxt_ulp_cntxt_ptr2_tun_tbl_get(ulp_ctxt);
- if (!tun_tbl)
- return -EINVAL;
-
- ulp_clear_tun_inner_entry(tun_tbl, fid);
-
+#ifdef RTE_LIBRTE_BNXT_TRUFLOW_DEBUG
+ BNXT_TF_DBG(ERR, "flow_id = %u:%u freed\n", flow_type, fid);
+#endif
/* all good, return success */
return 0;
}
BNXT_ULP_RESOURCE_FUNC_INDEX_TABLE,
sub_typ, ¶ms);
if (rc) {
- BNXT_TF_DBG(ERR, "CFA Action ptr not found for flow id %u\n",
+ BNXT_TF_DBG(INFO, "CFA Action ptr not found for flow id %u\n",
flow_id);
return -ENOENT;
}
return 0;
}
+/* internal validation function for parent flow tbl */
+static struct ulp_fdb_parent_info *
+ulp_flow_db_pc_db_entry_get(struct bnxt_ulp_context *ulp_ctxt,
+ uint32_t pc_idx)
+{
+ struct bnxt_ulp_flow_db *flow_db;
+
+ flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
+ if (!flow_db) {
+ BNXT_TF_DBG(ERR, "Invalid Arguments\n");
+ return NULL;
+ }
+
+ /* check for max flows */
+ if (pc_idx >= BNXT_ULP_MAX_TUN_CACHE_ENTRIES) {
+ BNXT_TF_DBG(ERR, "Invalid tunnel index\n");
+ return NULL;
+ }
+
+ /* No support for parent child db then just exit */
+ if (!flow_db->parent_child_db.entries_count) {
+ BNXT_TF_DBG(ERR, "parent child db not supported\n");
+ return NULL;
+ }
+ if (!flow_db->parent_child_db.parent_flow_tbl[pc_idx].valid) {
+ BNXT_TF_DBG(ERR, "Not a valid tunnel index\n");
+ return NULL;
+ }
+
+ return &flow_db->parent_child_db.parent_flow_tbl[pc_idx];
+}
+
+/* internal validation function for parent flow tbl */
+static struct bnxt_ulp_flow_db *
+ulp_flow_db_parent_arg_validation(struct bnxt_ulp_context *ulp_ctxt,
+ uint32_t tun_idx)
+{
+ struct bnxt_ulp_flow_db *flow_db;
+
+ flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
+ if (!flow_db) {
+ BNXT_TF_DBG(ERR, "Invalid Arguments\n");
+ return NULL;
+ }
+
+ /* check for max flows */
+ if (tun_idx >= BNXT_ULP_MAX_TUN_CACHE_ENTRIES) {
+ BNXT_TF_DBG(ERR, "Invalid tunnel index\n");
+ return NULL;
+ }
+
+ /* No support for parent child db then just exit */
+ if (!flow_db->parent_child_db.entries_count) {
+ BNXT_TF_DBG(ERR, "parent child db not supported\n");
+ return NULL;
+ }
+
+ return flow_db;
+}
+
/*
* Allocate the entry in the parent-child database
*
* ulp_ctxt [in] Ptr to ulp_context
- * fid [in] The flow id to the flow entry
+ * tun_idx [in] The tunnel index of the flow entry
*
* returns index on success and negative on failure.
*/
-int32_t
-ulp_flow_db_parent_flow_alloc(struct bnxt_ulp_context *ulp_ctxt,
- uint32_t fid)
+static int32_t
+ulp_flow_db_pc_db_idx_alloc(struct bnxt_ulp_context *ulp_ctxt,
+ uint32_t tun_idx)
{
struct bnxt_ulp_flow_db *flow_db;
struct ulp_fdb_parent_child_db *p_pdb;
uint32_t idx, free_idx = 0;
/* validate the arguments */
- flow_db = ulp_flow_db_parent_arg_validation(ulp_ctxt, fid);
+ flow_db = ulp_flow_db_parent_arg_validation(ulp_ctxt, tun_idx);
if (!flow_db) {
BNXT_TF_DBG(ERR, "parent child db validation failed\n");
return -EINVAL;
p_pdb = &flow_db->parent_child_db;
for (idx = 0; idx < p_pdb->entries_count; idx++) {
- if (p_pdb->parent_flow_tbl[idx].parent_fid == fid) {
- BNXT_TF_DBG(ERR, "fid is already allocated\n");
- return -EINVAL;
+ if (p_pdb->parent_flow_tbl[idx].valid &&
+ p_pdb->parent_flow_tbl[idx].tun_idx == tun_idx) {
+ return idx;
}
- if (!p_pdb->parent_flow_tbl[idx].parent_fid && !free_idx)
+ if (!p_pdb->parent_flow_tbl[idx].valid && !free_idx)
free_idx = idx + 1;
}
/* no free slots */
free_idx -= 1;
/* set the Fid in the parent child */
- p_pdb->parent_flow_tbl[free_idx].parent_fid = fid;
+ p_pdb->parent_flow_tbl[free_idx].tun_idx = tun_idx;
+ p_pdb->parent_flow_tbl[free_idx].valid = 1;
return free_idx;
}
/*
* Free the entry in the parent-child database
*
- * ulp_ctxt [in] Ptr to ulp_context
- * fid [in] The flow id to the flow entry
+ * pc_entry [in] Ptr to parent child db entry
*
- * returns 0 on success and negative on failure.
+ * returns none.
*/
-int32_t
-ulp_flow_db_parent_flow_free(struct bnxt_ulp_context *ulp_ctxt,
- uint32_t fid)
+static void
+ulp_flow_db_pc_db_entry_free(struct bnxt_ulp_context *ulp_ctxt,
+ struct ulp_fdb_parent_info *pc_entry)
{
+ struct bnxt_tun_cache_entry *tun_tbl;
struct bnxt_ulp_flow_db *flow_db;
- struct ulp_fdb_parent_child_db *p_pdb;
- uint32_t idx;
+ uint64_t *tmp_bitset;
- /* validate the arguments */
- flow_db = ulp_flow_db_parent_arg_validation(ulp_ctxt, fid);
- if (!flow_db) {
- BNXT_TF_DBG(ERR, "parent child db validation failed\n");
- return -EINVAL;
- }
+ /* free the tunnel entry */
+ tun_tbl = bnxt_ulp_cntxt_ptr2_tun_tbl_get(ulp_ctxt);
+ if (tun_tbl)
+ ulp_tunnel_offload_entry_clear(tun_tbl, pc_entry->tun_idx);
- p_pdb = &flow_db->parent_child_db;
- for (idx = 0; idx < p_pdb->entries_count; idx++) {
- if (p_pdb->parent_flow_tbl[idx].parent_fid == fid) {
- /* free the contents */
- p_pdb->parent_flow_tbl[idx].parent_fid = 0;
- memset(p_pdb->parent_flow_tbl[idx].child_fid_bitset,
- 0, p_pdb->child_bitset_size);
- return 0;
- }
- }
- BNXT_TF_DBG(ERR, "parent entry not found = %x\n", fid);
- return -EINVAL;
+ /* free the child bitset*/
+ flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
+ if (flow_db)
+ memset(pc_entry->child_fid_bitset, 0,
+ flow_db->parent_child_db.child_bitset_size);
+
+ /* free the contents */
+ tmp_bitset = pc_entry->child_fid_bitset;
+ memset(pc_entry, 0, sizeof(struct ulp_fdb_parent_info));
+ pc_entry->child_fid_bitset = tmp_bitset;
}
/*
- * Set or reset the child flow in the parent-child database
+ * Set or reset the parent flow in the parent-child database
*
* ulp_ctxt [in] Ptr to ulp_context
+ * pc_idx [in] The index to parent child db
* parent_fid [in] The flow id of the parent flow entry
- * child_fid [in] The flow id of the child flow entry
* set_flag [in] Use 1 for setting child, 0 to reset
*
* returns zero on success and negative on failure.
*/
int32_t
-ulp_flow_db_parent_child_flow_set(struct bnxt_ulp_context *ulp_ctxt,
+ulp_flow_db_pc_db_parent_flow_set(struct bnxt_ulp_context *ulp_ctxt,
+ uint32_t pc_idx,
uint32_t parent_fid,
- uint32_t child_fid,
uint32_t set_flag)
{
+ struct ulp_fdb_parent_info *pc_entry;
struct bnxt_ulp_flow_db *flow_db;
- struct ulp_fdb_parent_child_db *p_pdb;
- uint32_t idx, a_idx;
- uint64_t *t;
- /* validate the arguments */
- flow_db = ulp_flow_db_parent_arg_validation(ulp_ctxt, parent_fid);
+ flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
if (!flow_db) {
BNXT_TF_DBG(ERR, "parent child db validation failed\n");
return -EINVAL;
}
/* check for fid validity */
- if (child_fid >= flow_db->flow_tbl.num_flows || !child_fid) {
- BNXT_TF_DBG(ERR, "Invalid child flow index %x\n", child_fid);
+ if (parent_fid >= flow_db->flow_tbl.num_flows || !parent_fid) {
+ BNXT_TF_DBG(ERR, "Invalid parent flow index %x\n", parent_fid);
return -EINVAL;
}
- p_pdb = &flow_db->parent_child_db;
- a_idx = child_fid / ULP_INDEX_BITMAP_SIZE;
- for (idx = 0; idx < p_pdb->entries_count; idx++) {
- if (p_pdb->parent_flow_tbl[idx].parent_fid == parent_fid) {
- t = p_pdb->parent_flow_tbl[idx].child_fid_bitset;
- if (set_flag)
- ULP_INDEX_BITMAP_SET(t[a_idx], child_fid);
- else
- ULP_INDEX_BITMAP_RESET(t[a_idx], child_fid);
- return 0;
- }
+ /* validate the arguments and parent child entry */
+ pc_entry = ulp_flow_db_pc_db_entry_get(ulp_ctxt, pc_idx);
+ if (!pc_entry) {
+ BNXT_TF_DBG(ERR, "failed to get the parent child entry\n");
+ return -EINVAL;
}
- BNXT_TF_DBG(ERR, "Unable to set the parent-child flow %x:%x\n",
- parent_fid, child_fid);
- return -1;
+
+ if (set_flag) {
+ pc_entry->parent_fid = parent_fid;
+ } else {
+ if (pc_entry->parent_fid != parent_fid)
+ BNXT_TF_DBG(ERR, "Panic: invalid parent id\n");
+ pc_entry->parent_fid = 0;
+
+ /* Free the parent child db entry if no user present */
+ if (!pc_entry->f2_cnt)
+ ulp_flow_db_pc_db_entry_free(ulp_ctxt, pc_entry);
+ }
+ return 0;
}
/*
- * Get the parent index from the parent-child database
+ * Set or reset the child flow in the parent-child database
*
* ulp_ctxt [in] Ptr to ulp_context
- * parent_fid [in] The flow id of the parent flow entry
- * parent_idx [out] The parent index of parent flow entry
+ * pc_idx [in] The index to parent child db
+ * child_fid [in] The flow id of the child flow entry
+ * set_flag [in] Use 1 for setting child, 0 to reset
*
* returns zero on success and negative on failure.
*/
int32_t
-ulp_flow_db_parent_flow_idx_get(struct bnxt_ulp_context *ulp_ctxt,
- uint32_t parent_fid,
- uint32_t *parent_idx)
+ulp_flow_db_pc_db_child_flow_set(struct bnxt_ulp_context *ulp_ctxt,
+ uint32_t pc_idx,
+ uint32_t child_fid,
+ uint32_t set_flag)
{
+ struct ulp_fdb_parent_info *pc_entry;
struct bnxt_ulp_flow_db *flow_db;
- struct ulp_fdb_parent_child_db *p_pdb;
- uint32_t idx;
+ uint32_t a_idx;
+ uint64_t *t;
- /* validate the arguments */
- flow_db = ulp_flow_db_parent_arg_validation(ulp_ctxt, parent_fid);
+ flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
if (!flow_db) {
BNXT_TF_DBG(ERR, "parent child db validation failed\n");
return -EINVAL;
}
- p_pdb = &flow_db->parent_child_db;
- for (idx = 0; idx < p_pdb->entries_count; idx++) {
- if (p_pdb->parent_flow_tbl[idx].parent_fid == parent_fid) {
- *parent_idx = idx;
- return 0;
- }
+ /* check for fid validity */
+ if (child_fid >= flow_db->flow_tbl.num_flows || !child_fid) {
+ BNXT_TF_DBG(ERR, "Invalid child flow index %x\n", child_fid);
+ return -EINVAL;
}
- BNXT_TF_DBG(ERR, "Unable to get the parent flow %x\n", parent_fid);
- return -1;
+
+ /* validate the arguments and parent child entry */
+ pc_entry = ulp_flow_db_pc_db_entry_get(ulp_ctxt, pc_idx);
+ if (!pc_entry) {
+ BNXT_TF_DBG(ERR, "failed to get the parent child entry\n");
+ return -EINVAL;
+ }
+
+ a_idx = child_fid / ULP_INDEX_BITMAP_SIZE;
+ t = pc_entry->child_fid_bitset;
+ if (set_flag) {
+ ULP_INDEX_BITMAP_SET(t[a_idx], child_fid);
+ pc_entry->f2_cnt++;
+ } else {
+ ULP_INDEX_BITMAP_RESET(t[a_idx], child_fid);
+ if (pc_entry->f2_cnt)
+ pc_entry->f2_cnt--;
+ if (!pc_entry->f2_cnt && !pc_entry->parent_fid)
+ ulp_flow_db_pc_db_entry_free(ulp_ctxt, pc_entry);
+ }
+ return 0;
}
/*
* Set the counter accumulation in the parent flow
*
* ulp_ctxt [in] Ptr to ulp_context
- * parent_idx [in] The parent index of the parent flow entry
+ * pc_idx [in] The parent child index of the parent flow entry
*
* returns index on success and negative on failure.
*/
static int32_t
ulp_flow_db_parent_flow_count_accum_set(struct bnxt_ulp_context *ulp_ctxt,
- uint32_t parent_idx)
+ uint32_t pc_idx)
{
struct bnxt_ulp_flow_db *flow_db;
struct ulp_fdb_parent_child_db *p_pdb;
/* check for parent idx validity */
p_pdb = &flow_db->parent_child_db;
- if (parent_idx >= p_pdb->entries_count ||
- !p_pdb->parent_flow_tbl[parent_idx].parent_fid) {
- BNXT_TF_DBG(ERR, "Invalid parent flow index %x\n", parent_idx);
+ if (pc_idx >= p_pdb->entries_count ||
+ !p_pdb->parent_flow_tbl[pc_idx].parent_fid) {
+ BNXT_TF_DBG(ERR, "Invalid parent child index %x\n", pc_idx);
return -EINVAL;
}
- p_pdb->parent_flow_tbl[parent_idx].counter_acc = 1;
+ p_pdb->parent_flow_tbl[pc_idx].counter_acc = 1;
return 0;
}
-/*
- * Get the counter accumulation in the parent flow
- *
- * ulp_ctxt [in] Ptr to ulp_context
- * parent_fid [in] The flow id of the parent flow entry
- *
- * returns 0 if counter accum is set else -1.
- */
-static int32_t
-ulp_flow_db_parent_flow_count_accum_get(struct bnxt_ulp_context *ulp_ctxt,
- uint32_t parent_fid)
-{
- struct bnxt_ulp_flow_db *flow_db;
- struct ulp_fdb_parent_child_db *p_pdb;
- uint32_t idx;
-
- /* validate the arguments */
- flow_db = ulp_flow_db_parent_arg_validation(ulp_ctxt, parent_fid);
- if (!flow_db) {
- BNXT_TF_DBG(ERR, "parent child db validation failed\n");
- return -EINVAL;
- }
-
- p_pdb = &flow_db->parent_child_db;
- for (idx = 0; idx < p_pdb->entries_count; idx++) {
- if (p_pdb->parent_flow_tbl[idx].parent_fid == parent_fid) {
- if (p_pdb->parent_flow_tbl[idx].counter_acc)
- return 0;
- break;
- }
- }
- return -1;
-}
-
/*
* Orphan the child flow entry
* This is called only for child flows that have
ulp_flow_db_parent_flow_create(struct bnxt_ulp_mapper_parms *parms)
{
struct ulp_flow_db_res_params fid_parms;
- uint32_t sub_typ = BNXT_ULP_RESOURCE_SUB_TYPE_INDEX_TABLE_INT_COUNT_ACC;
+ uint32_t sub_typ = BNXT_ULP_RESOURCE_SUB_TYPE_INDEX_TABLE_INT_COUNT;
struct ulp_flow_db_res_params res_params;
- int32_t fid_idx, rc;
+ int32_t pc_idx;
- /* create the child flow entry in parent flow table */
- fid_idx = ulp_flow_db_parent_flow_alloc(parms->ulp_ctx, parms->fid);
- if (fid_idx < 0) {
- BNXT_TF_DBG(ERR, "Error in creating parent flow fid %x\n",
- parms->fid);
- return -1;
+ /* create or get the parent child database */
+ pc_idx = ulp_flow_db_pc_db_idx_alloc(parms->ulp_ctx, parms->tun_idx);
+ if (pc_idx < 0) {
+ BNXT_TF_DBG(ERR, "Error in getting parent child db %x\n",
+ parms->tun_idx);
+ return -EINVAL;
+ }
+
+ /* Update the parent fid */
+ if (ulp_flow_db_pc_db_parent_flow_set(parms->ulp_ctx, pc_idx,
+ parms->fid, 1)) {
+ BNXT_TF_DBG(ERR, "Error in setting parent fid %x\n",
+ parms->tun_idx);
+ return -EINVAL;
}
/* Add the parent details in the resource list of the flow */
memset(&fid_parms, 0, sizeof(fid_parms));
fid_parms.resource_func = BNXT_ULP_RESOURCE_FUNC_PARENT_FLOW;
- fid_parms.resource_hndl = fid_idx;
+ fid_parms.resource_hndl = pc_idx;
fid_parms.critical_resource = BNXT_ULP_CRITICAL_RESOURCE_NO;
if (ulp_flow_db_resource_add(parms->ulp_ctx, BNXT_ULP_FDB_TYPE_REGULAR,
parms->fid, &fid_parms)) {
&res_params)) {
/* Enable the counter accumulation in parent entry */
if (ulp_flow_db_parent_flow_count_accum_set(parms->ulp_ctx,
- fid_idx)) {
+ pc_idx)) {
BNXT_TF_DBG(ERR, "Error in setting counter acc %x\n",
parms->fid);
return -1;
}
}
- rc = ulp_flow_db_parent_tun_idx_set(parms->ulp_ctx, fid_idx,
- parms->tun_idx);
- if (rc) {
- BNXT_TF_DBG(ERR, "Error setting tun_idx in the parent flow\n");
- return rc;
- }
-
return 0;
}
uint32_t sub_type = BNXT_ULP_RESOURCE_SUB_TYPE_INDEX_TABLE_INT_COUNT;
enum bnxt_ulp_resource_func res_fun;
struct ulp_flow_db_res_params res_p;
- uint32_t parent_fid = parms->parent_fid;
- int32_t rc;
+ int32_t rc, pc_idx;
+
+ /* create or get the parent child database */
+ pc_idx = ulp_flow_db_pc_db_idx_alloc(parms->ulp_ctx, parms->tun_idx);
+ if (pc_idx < 0) {
+ BNXT_TF_DBG(ERR, "Error in getting parent child db %x\n",
+ parms->tun_idx);
+ return -1;
+ }
/* create the parent flow entry in parent flow table */
- rc = ulp_flow_db_parent_child_flow_set(parms->ulp_ctx,
- parms->parent_fid,
- parms->fid, 1);
+ rc = ulp_flow_db_pc_db_child_flow_set(parms->ulp_ctx, pc_idx,
+ parms->fid, 1);
if (rc) {
BNXT_TF_DBG(ERR, "Error in setting child fid %x\n", parms->fid);
return rc;
/* Add the parent details in the resource list of the flow */
memset(&fid_parms, 0, sizeof(fid_parms));
fid_parms.resource_func = BNXT_ULP_RESOURCE_FUNC_CHILD_FLOW;
- fid_parms.resource_hndl = parms->parent_fid;
+ fid_parms.resource_hndl = pc_idx;
fid_parms.critical_resource = BNXT_ULP_CRITICAL_RESOURCE_NO;
rc = ulp_flow_db_resource_add(parms->ulp_ctx,
BNXT_ULP_FDB_TYPE_REGULAR,
return rc;
}
- /* check if accumulation count is set for parent flow */
- rc = ulp_flow_db_parent_flow_count_accum_get(parms->ulp_ctx,
- parms->parent_fid);
+ /* check if internal count action included for this flow.*/
+ res_fun = BNXT_ULP_RESOURCE_FUNC_INDEX_TABLE;
+ rc = ulp_flow_db_resource_params_get(parms->ulp_ctx,
+ BNXT_ULP_FDB_TYPE_REGULAR,
+ parms->fid,
+ res_fun,
+ sub_type,
+ &res_p);
if (!rc) {
- /* check if internal count action included for this flow.*/
- res_fun = BNXT_ULP_RESOURCE_FUNC_INDEX_TABLE;
- rc = ulp_flow_db_resource_params_get(parms->ulp_ctx,
- BNXT_ULP_FDB_TYPE_REGULAR,
- parms->fid,
- res_fun,
- sub_type,
- &res_p);
- if (!rc) {
- /* update the counter manager to include parent fid */
- if (ulp_fc_mgr_cntr_parent_flow_set(parms->ulp_ctx,
- res_p.direction,
- res_p.resource_hndl,
- parent_fid)) {
- BNXT_TF_DBG(ERR, "Error in setting child %x\n",
- parms->fid);
- return -1;
- }
+ /* update the counter manager to include parent fid */
+ if (ulp_fc_mgr_cntr_parent_flow_set(parms->ulp_ctx,
+ res_p.direction,
+ res_p.resource_hndl,
+ pc_idx)) {
+ BNXT_TF_DBG(ERR, "Error in setting child %x\n",
+ parms->fid);
+ return -1;
}
}
+
/* return success */
return 0;
}
* Update the parent counters
*
* ulp_ctxt [in] Ptr to ulp_context
- * parent_fid [in] The flow id of the parent flow entry
+ * pc_idx [in] The parent flow entry idx
* packet_count [in] - packet count
* byte_count [in] - byte count
*
*/
int32_t
ulp_flow_db_parent_flow_count_update(struct bnxt_ulp_context *ulp_ctxt,
- uint32_t parent_fid,
+ uint32_t pc_idx,
uint64_t packet_count,
uint64_t byte_count)
{
- struct bnxt_ulp_flow_db *flow_db;
- struct ulp_fdb_parent_child_db *p_pdb;
- uint32_t idx;
+ struct ulp_fdb_parent_info *pc_entry;
- /* validate the arguments */
- flow_db = ulp_flow_db_parent_arg_validation(ulp_ctxt, parent_fid);
- if (!flow_db) {
- BNXT_TF_DBG(ERR, "parent child db validation failed\n");
+ /* validate the arguments and get parent child entry */
+ pc_entry = ulp_flow_db_pc_db_entry_get(ulp_ctxt, pc_idx);
+ if (!pc_entry) {
+ BNXT_TF_DBG(ERR, "failed to get the parent child entry\n");
return -EINVAL;
}
- p_pdb = &flow_db->parent_child_db;
- for (idx = 0; idx < p_pdb->entries_count; idx++) {
- if (p_pdb->parent_flow_tbl[idx].parent_fid == parent_fid) {
- if (p_pdb->parent_flow_tbl[idx].counter_acc) {
- p_pdb->parent_flow_tbl[idx].pkt_count +=
- packet_count;
- p_pdb->parent_flow_tbl[idx].byte_count +=
- byte_count;
- }
- return 0;
- }
+ if (pc_entry->counter_acc) {
+ pc_entry->pkt_count += packet_count;
+ pc_entry->byte_count += byte_count;
}
- return -ENOENT;
+ return 0;
}
/*
* Get the parent accumulation counters
*
* ulp_ctxt [in] Ptr to ulp_context
- * parent_fid [in] The flow id of the parent flow entry
+ * pc_idx [in] The parent flow entry idx
* packet_count [out] - packet count
* byte_count [out] - byte count
*
*/
int32_t
ulp_flow_db_parent_flow_count_get(struct bnxt_ulp_context *ulp_ctxt,
- uint32_t parent_fid, uint64_t *packet_count,
+ uint32_t pc_idx, uint64_t *packet_count,
uint64_t *byte_count, uint8_t count_reset)
{
- struct bnxt_ulp_flow_db *flow_db;
- struct ulp_fdb_parent_child_db *p_pdb;
- uint32_t idx;
+ struct ulp_fdb_parent_info *pc_entry;
- /* validate the arguments */
- flow_db = ulp_flow_db_parent_arg_validation(ulp_ctxt, parent_fid);
- if (!flow_db) {
- BNXT_TF_DBG(ERR, "parent child db validation failed\n");
+ /* validate the arguments and get parent child entry */
+ pc_entry = ulp_flow_db_pc_db_entry_get(ulp_ctxt, pc_idx);
+ if (!pc_entry) {
+ BNXT_TF_DBG(ERR, "failed to get the parent child entry\n");
return -EINVAL;
}
- p_pdb = &flow_db->parent_child_db;
- for (idx = 0; idx < p_pdb->entries_count; idx++) {
- if (p_pdb->parent_flow_tbl[idx].parent_fid == parent_fid) {
- if (p_pdb->parent_flow_tbl[idx].counter_acc) {
- *packet_count =
- p_pdb->parent_flow_tbl[idx].pkt_count;
- *byte_count =
- p_pdb->parent_flow_tbl[idx].byte_count;
- if (count_reset) {
- p_pdb->parent_flow_tbl[idx].pkt_count = 0;
- p_pdb->parent_flow_tbl[idx].byte_count = 0;
- }
- }
- return 0;
+ if (pc_entry->counter_acc) {
+ *packet_count = pc_entry->pkt_count;
+ *byte_count = pc_entry->byte_count;
+ if (count_reset) {
+ pc_entry->pkt_count = 0;
+ pc_entry->byte_count = 0;
}
}
- return -ENOENT;
+ return 0;
}
/*
uint32_t idx;
/* validate the arguments */
- flow_db = ulp_flow_db_parent_arg_validation(ulp_ctxt, 1);
+ flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
if (!flow_db) {
BNXT_TF_DBG(ERR, "parent child db validation failed\n");
return;
p_pdb = &flow_db->parent_child_db;
for (idx = 0; idx < p_pdb->entries_count; idx++) {
- if (p_pdb->parent_flow_tbl[idx].parent_fid &&
+ if (p_pdb->parent_flow_tbl[idx].valid &&
p_pdb->parent_flow_tbl[idx].counter_acc) {
p_pdb->parent_flow_tbl[idx].pkt_count = 0;
p_pdb->parent_flow_tbl[idx].byte_count = 0;
if (res && (shared & BNXT_ULP_SHARED_SESSION_YES))
res->fdb_flags |= ULP_FDB_FLAG_SHARED_SESSION;
}
+
+#ifdef RTE_LIBRTE_BNXT_TRUFLOW_DEBUG
+/*
+ * Dump the entry details
+ *
+ * ulp_ctxt [in] Ptr to ulp_context
+ *
+ * returns none
+ */
+static void ulp_flow_db_res_dump(struct ulp_fdb_resource_info *r,
+ uint32_t *nxt_res)
+{
+ uint8_t res_func = ulp_flow_db_resource_func_get(r);
+
+ BNXT_TF_DBG(DEBUG, "Resource func = %x, nxt_resource_idx = %x\n",
+ res_func, (ULP_FLOW_DB_RES_NXT_MASK & r->nxt_resource_idx));
+ if (res_func == BNXT_ULP_RESOURCE_FUNC_EM_TABLE)
+ BNXT_TF_DBG(DEBUG, "EM Handle = 0x%016" PRIX64 "\n",
+ r->resource_em_handle);
+ else
+ BNXT_TF_DBG(DEBUG, "Handle = 0x%08x\n", r->resource_hndl);
+
+ *nxt_res = 0;
+ ULP_FLOW_DB_RES_NXT_SET(*nxt_res,
+ r->nxt_resource_idx);
+}
+
+/*
+ * Dump the flow entry details
+ *
+ * flow_db [in] Ptr to flow db
+ * fid [in] flow id
+ *
+ * returns none
+ */
+void
+ulp_flow_db_debug_fid_dump(struct bnxt_ulp_flow_db *flow_db, uint32_t fid)
+{
+ struct ulp_fdb_resource_info *r;
+ struct bnxt_ulp_flow_tbl *flow_tbl;
+ uint32_t nxt_res = 0;
+ uint32_t def_flag = 0, reg_flag = 0;
+
+ flow_tbl = &flow_db->flow_tbl;
+ if (ulp_flow_db_active_flows_bit_is_set(flow_db,
+ BNXT_ULP_FDB_TYPE_REGULAR, fid))
+ reg_flag = 1;
+ if (ulp_flow_db_active_flows_bit_is_set(flow_db,
+ BNXT_ULP_FDB_TYPE_DEFAULT, fid))
+ def_flag = 1;
+
+ if (reg_flag && def_flag)
+ BNXT_TF_DBG(DEBUG, "RID = %u\n", fid);
+ else if (reg_flag)
+ BNXT_TF_DBG(DEBUG, "Regular fid = %u and func id = %u\n",
+ fid, flow_db->func_id_tbl[fid]);
+ else if (def_flag)
+ BNXT_TF_DBG(DEBUG, "Default fid = %u\n", fid);
+ else
+ return;
+ /* iterate the resource */
+ nxt_res = fid;
+ do {
+ r = &flow_tbl->flow_resources[nxt_res];
+ ulp_flow_db_res_dump(r, &nxt_res);
+ } while (nxt_res);
+}
+
+/*
+ * Dump the flow database entry details
+ *
+ * ulp_ctxt [in] Ptr to ulp_context
+ * flow_id [in] if zero then all fids are dumped.
+ *
+ * returns none
+ */
+int32_t ulp_flow_db_debug_dump(struct bnxt_ulp_context *ulp_ctxt,
+ uint32_t flow_id)
+{
+ struct bnxt_ulp_flow_db *flow_db;
+ struct bnxt_ulp_flow_tbl *flow_tbl;
+ uint32_t fid;
+
+ if (!ulp_ctxt || !ulp_ctxt->cfg_data) {
+ BNXT_TF_DBG(ERR, "Invalid Arguments\n");
+ return -EINVAL;
+ }
+ flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
+ if (!flow_db) {
+ BNXT_TF_DBG(ERR, "Invalid Arguments\n");
+ return -EINVAL;
+ }
+
+ flow_tbl = &flow_db->flow_tbl;
+ if (flow_id) {
+ ulp_flow_db_debug_fid_dump(flow_db, flow_id);
+ return 0;
+ }
+
+ BNXT_TF_DBG(DEBUG, "Dump flows = %u:%u\n",
+ flow_tbl->num_flows,
+ flow_tbl->num_resources);
+ BNXT_TF_DBG(DEBUG, "Head_index = %u, Tail_index = %u\n",
+ flow_tbl->head_index, flow_tbl->tail_index);
+ for (fid = 1; fid < flow_tbl->num_flows; fid++)
+ ulp_flow_db_debug_fid_dump(flow_db, fid);
+ BNXT_TF_DBG(DEBUG, "Done.\n");
+ return 0;
+}
+#endif
git.droids-corp.org / dpdk.git / blobdiff