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.
* 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
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;