From patchwork Wed Jul 15 13:50:29 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Somnath Kotur X-Patchwork-Id: 74101 X-Patchwork-Delegate: ajit.khaparde@broadcom.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 23BC2A0527; Wed, 15 Jul 2020 15:56:01 +0200 (CEST) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id DAD3D1BEA5; Wed, 15 Jul 2020 15:55:54 +0200 (CEST) Received: from relay.smtp.broadcom.com (relay.smtp.broadcom.com [192.19.211.62]) by dpdk.org (Postfix) with ESMTP id 351611B3BB for ; Wed, 15 Jul 2020 15:55:51 +0200 (CEST) Received: from dhcp-10-123-153-55.dhcp.broadcom.net (dhcp-10-123-153-55.dhcp.broadcom.net [10.123.153.55]) by relay.smtp.broadcom.com (Postfix) with ESMTP id 63FE9299DAA; Wed, 15 Jul 2020 06:55:50 -0700 (PDT) DKIM-Filter: OpenDKIM Filter v2.10.3 relay.smtp.broadcom.com 63FE9299DAA DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=broadcom.com; s=dkimrelay; t=1594821350; bh=OOfg8U3yjbnu5M9LV4C+tPUPcaVOxmx8v3DRB5/CDRM=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=B/GFzOPKbBRzxTp9wKSP1h76+gt/GoxL65StR8gfNbnM2gnzGUKPwNuqLxgwOby6U CrWuqjPPlPMbLZ01HpIYesDdFxOKW5C1UwmqE2QhSD2CthI1C5JqBI4oo0G0BwwBdG mPUBmra2+u3dZ3GaU0k+jkYmhS6xZNcy/7BtebU4= From: Somnath Kotur To: dev@dpdk.org Cc: ferruh.yigit@intel.com Date: Wed, 15 Jul 2020 19:20:29 +0530 Message-Id: <20200715135038.16662-2-somnath.kotur@broadcom.com> X-Mailer: git-send-email 2.10.1.613.g2cc2e70 In-Reply-To: <20200715135038.16662-1-somnath.kotur@broadcom.com> References: <20200713061600.19456-1-somnath.kotur@broadcom.com> <20200715135038.16662-1-somnath.kotur@broadcom.com> Subject: [dpdk-dev] [PATCH 01/10] net/bnxt: add option to delay EEM sysmem mapping X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" From: Peter Spreadborough - The mapping of kernel pages for EEM sysmem operation takes a significant amount of time. This change give the build option to delay the sysmem mapping until the first write to EEM Signed-off-by: Peter Spreadborough Reviewed-by: Randy Schacher Signed-off-by: Somnath Kotur --- drivers/net/bnxt/tf_core/tf_core.c | 17 +++++++++++-- drivers/net/bnxt/tf_core/tf_em.h | 11 +++++++++ drivers/net/bnxt/tf_core/tf_em_common.c | 41 +++++++++++++++++++++++++++++++ drivers/net/bnxt/tf_core/tf_em_internal.c | 2 +- drivers/net/bnxt/tf_core/tf_em_system.c | 6 +++-- 5 files changed, 72 insertions(+), 5 deletions(-) diff --git a/drivers/net/bnxt/tf_core/tf_core.c b/drivers/net/bnxt/tf_core/tf_core.c index 00b2775..a404cb8 100644 --- a/drivers/net/bnxt/tf_core/tf_core.c +++ b/drivers/net/bnxt/tf_core/tf_core.c @@ -49,9 +49,22 @@ tf_open_session(struct tf *tfp, &slot, &device); if (rc != 4) { - TFP_DRV_LOG(ERR, + /* PCI Domain not provided (optional in DPDK), thus we + * force domain to 0 and recheck. + */ + domain = 0; + + /* Check parsing of bus/slot/device */ + rc = sscanf(parms->ctrl_chan_name, + "%x:%x.%d", + &bus, + &slot, + &device); + if (rc != 3) { + TFP_DRV_LOG(ERR, "Failed to scan device ctrl_chan_name\n"); - return -EINVAL; + return -EINVAL; + } } parms->session_id.internal.domain = domain; diff --git a/drivers/net/bnxt/tf_core/tf_em.h b/drivers/net/bnxt/tf_core/tf_em.h index 0890261..ae2e64d 100644 --- a/drivers/net/bnxt/tf_core/tf_em.h +++ b/drivers/net/bnxt/tf_core/tf_em.h @@ -9,6 +9,16 @@ #include "tf_core.h" #include "tf_session.h" +#ifdef TF_USE_SYSTEM_MEM +/** + * Select EEM sysmem mmap export to be done at init + * or on the first write to EEM. + */ +#define TF_EM_SYSMEM_DELAY_EXPORT 1 +#else +#define TF_EM_SYSMEM_DELAY_EXPORT 0 +#endif + #define SUPPORT_CFA_HW_P4 1 #define SUPPORT_CFA_HW_P58 0 #define SUPPORT_CFA_HW_P59 0 @@ -482,4 +492,5 @@ int tf_em_ext_system_bind(struct tf *tfp, struct tf_em_cfg_parms *parms); +int offload_system_mmap(struct tf_tbl_scope_cb *tbl_scope_cb); #endif /* _TF_EM_H_ */ diff --git a/drivers/net/bnxt/tf_core/tf_em_common.c b/drivers/net/bnxt/tf_core/tf_em_common.c index 8b02b8b..65b9abf 100644 --- a/drivers/net/bnxt/tf_core/tf_em_common.c +++ b/drivers/net/bnxt/tf_core/tf_em_common.c @@ -700,6 +700,26 @@ tf_insert_eem_entry(struct tf_tbl_scope_cb *tbl_scope_cb, uint64_t big_hash; int rc; +#if (TF_EM_SYSMEM_DELAY_EXPORT == 1) + if (!tbl_scope_cb->valid) { + rc = offload_system_mmap(tbl_scope_cb); + + if (rc) { + struct tf_rm_free_parms fparms = { 0 }; + + TFP_DRV_LOG(ERR, + "System alloc mmap failed\n"); + /* Free Table control block */ + fparms.rm_db = eem_db[TF_DIR_RX]; + fparms.db_index = TF_EM_TBL_TYPE_TBL_SCOPE; + fparms.index = parms->tbl_scope_id; + tf_rm_free(&fparms); + return -EINVAL; + } + + tbl_scope_cb->valid = true; + } +#endif /* Get mask to use on hash */ mask = tf_em_get_key_mask(tbl_scope_cb->em_ctx_info[parms->dir].em_tables[TF_KEY0_TABLE].num_entries); @@ -1017,6 +1037,27 @@ int tf_tbl_ext_common_set(struct tf *tfp, return -EINVAL; } +#if (TF_EM_SYSMEM_DELAY_EXPORT == 1) + if (!tbl_scope_cb->valid) { + rc = offload_system_mmap(tbl_scope_cb); + + if (rc) { + struct tf_rm_free_parms fparms = { 0 }; + + TFP_DRV_LOG(ERR, + "System alloc mmap failed\n"); + /* Free Table control block */ + fparms.rm_db = eem_db[TF_DIR_RX]; + fparms.db_index = TF_EM_TBL_TYPE_TBL_SCOPE; + fparms.index = parms->tbl_scope_id; + tf_rm_free(&fparms); + return -EINVAL; + } + + tbl_scope_cb->valid = true; + } +#endif + op.opcode = HCAPI_CFA_HWOPS_PUT; key_tbl.base0 = (uint8_t *)&tbl_scope_cb->em_ctx_info[parms->dir].em_tables[TF_RECORD_TABLE]; diff --git a/drivers/net/bnxt/tf_core/tf_em_internal.c b/drivers/net/bnxt/tf_core/tf_em_internal.c index 3129fbe..462d0fa 100644 --- a/drivers/net/bnxt/tf_core/tf_em_internal.c +++ b/drivers/net/bnxt/tf_core/tf_em_internal.c @@ -179,7 +179,7 @@ tf_em_insert_int_entry(struct tf *tfp, return -1; PMD_DRV_LOG - (ERR, + (DEBUG, "%s, Internal entry @ Index:%d rptr_index:0x%x rptr_entry:0x%x num_of_entries:%d\n", tf_dir_2_str(parms->dir), index, diff --git a/drivers/net/bnxt/tf_core/tf_em_system.c b/drivers/net/bnxt/tf_core/tf_em_system.c index 339392c..1c3c702 100644 --- a/drivers/net/bnxt/tf_core/tf_em_system.c +++ b/drivers/net/bnxt/tf_core/tf_em_system.c @@ -272,8 +272,7 @@ tf_prepare_dmabuf_bnxt_lfc_device(struct tf_tbl_scope_cb *tbl_scope_cb) return 0; } -static int -offload_system_mmap(struct tf_tbl_scope_cb *tbl_scope_cb) +int offload_system_mmap(struct tf_tbl_scope_cb *tbl_scope_cb) { int rc; int dmabuf_fd; @@ -455,6 +454,7 @@ tf_em_ext_alloc(struct tf *tfp, } } +#if (TF_EM_SYSMEM_DELAY_EXPORT == 0) rc = offload_system_mmap(tbl_scope_cb); if (rc) { @@ -462,6 +462,7 @@ tf_em_ext_alloc(struct tf *tfp, "System alloc mmap failed\n"); goto cleanup_full; } +#endif return rc; @@ -527,6 +528,7 @@ tf_em_ext_free(struct tf *tfp, } tf_dmabuf_free(tfp, tbl_scope_cb); + tbl_scope_cb->valid = false; return rc; } From patchwork Wed Jul 15 13:50:30 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Somnath Kotur X-Patchwork-Id: 74102 X-Patchwork-Delegate: ajit.khaparde@broadcom.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id BF156A0527; Wed, 15 Jul 2020 15:56:09 +0200 (CEST) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 4C3A41BEB3; Wed, 15 Jul 2020 15:55:57 +0200 (CEST) Received: from relay.smtp.broadcom.com (relay.smtp.broadcom.com [192.19.211.62]) by dpdk.org (Postfix) with ESMTP id 7E26B4C8A for ; Wed, 15 Jul 2020 15:55:51 +0200 (CEST) Received: from dhcp-10-123-153-55.dhcp.broadcom.net (dhcp-10-123-153-55.dhcp.broadcom.net [10.123.153.55]) by relay.smtp.broadcom.com (Postfix) with ESMTP id AEE25299DDF; Wed, 15 Jul 2020 06:55:50 -0700 (PDT) DKIM-Filter: OpenDKIM Filter v2.10.3 relay.smtp.broadcom.com AEE25299DDF DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=broadcom.com; s=dkimrelay; t=1594821350; bh=oz01cxplkzFTnXIdsgKMfs0Ei3gjpP2HZjHTRzrhq1Q=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=wH2o6J/vdvqKU+IA2QayCEH7X1yUqLhyx9U0LNagGyUAynzhzssGhaiTzpudnU26F Md87jTFV/e1Piuo4MafNCOfK0bxUo7DzWPWEJwQuJv9RWr5yU2GOg3CZi23IiNWDQZ +hnRxWE1WwLrD/RRIvJ2OHWNwWzeu5KFb1vC5Oog= From: Somnath Kotur To: dev@dpdk.org Cc: ferruh.yigit@intel.com Date: Wed, 15 Jul 2020 19:20:30 +0530 Message-Id: <20200715135038.16662-3-somnath.kotur@broadcom.com> X-Mailer: git-send-email 2.10.1.613.g2cc2e70 In-Reply-To: <20200715135038.16662-1-somnath.kotur@broadcom.com> References: <20200713061600.19456-1-somnath.kotur@broadcom.com> <20200715135038.16662-1-somnath.kotur@broadcom.com> Subject: [dpdk-dev] [PATCH 02/10] net/bnxt: implement TF Identifier search X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" From: Jay Ding Implement shadow copy DB to hold reference count for each ID in each identifier type. Implement identifier search functionality. Signed-off-by: Jay Ding Reviewed-by: Randy Schacher Signed-off-by: Somnath Kotur --- drivers/net/bnxt/meson.build | 3 +- drivers/net/bnxt/tf_core/Makefile | 1 + drivers/net/bnxt/tf_core/tf_core.c | 61 +++++++ drivers/net/bnxt/tf_core/tf_core.h | 70 +++++++- drivers/net/bnxt/tf_core/tf_device.h | 20 +++ drivers/net/bnxt/tf_core/tf_device_p4.c | 2 + drivers/net/bnxt/tf_core/tf_identifier.c | 148 +++++++++++++++ drivers/net/bnxt/tf_core/tf_identifier.h | 47 +++++ drivers/net/bnxt/tf_core/tf_rm.c | 2 + drivers/net/bnxt/tf_core/tf_rm.h | 8 + drivers/net/bnxt/tf_core/tf_shadow_identifier.c | 190 ++++++++++++++++++++ drivers/net/bnxt/tf_core/tf_shadow_identifier.h | 229 ++++++++++++++++++++++++ 12 files changed, 777 insertions(+), 4 deletions(-) create mode 100644 drivers/net/bnxt/tf_core/tf_shadow_identifier.c create mode 100644 drivers/net/bnxt/tf_core/tf_shadow_identifier.h diff --git a/drivers/net/bnxt/meson.build b/drivers/net/bnxt/meson.build index 0b93c31..8529b33 100644 --- a/drivers/net/bnxt/meson.build +++ b/drivers/net/bnxt/meson.build @@ -46,7 +46,7 @@ sources = files('bnxt_cpr.c', 'tf_core/ll.c', 'tf_core/tf_global_cfg.c', 'tf_core/tf_em_host.c', - 'tf_ulp/ulp_fc_mgr.c', + 'tf_core/tf_shadow_identifier.c', 'hcapi/hcapi_cfa_p4.c', @@ -63,6 +63,7 @@ sources = files('bnxt_cpr.c', 'tf_ulp/bnxt_ulp_flow.c', 'tf_ulp/ulp_port_db.c', 'tf_ulp/ulp_def_rules.c', + 'tf_ulp/ulp_fc_mgr.c', 'rte_pmd_bnxt.c') diff --git a/drivers/net/bnxt/tf_core/Makefile b/drivers/net/bnxt/tf_core/Makefile index 8064714..9c2735d 100644 --- a/drivers/net/bnxt/tf_core/Makefile +++ b/drivers/net/bnxt/tf_core/Makefile @@ -31,3 +31,4 @@ SRCS-$(CONFIG_RTE_LIBRTE_BNXT_PMD) += tf_core/tf_tcam.c SRCS-$(CONFIG_RTE_LIBRTE_BNXT_PMD) += tf_core/tf_util.c SRCS-$(CONFIG_RTE_LIBRTE_BNXT_PMD) += tf_core/tf_if_tbl.c SRCS-$(CONFIG_RTE_LIBRTE_BNXT_PMD) += tf_core/tf_global_cfg.c +SRCS-$(CONFIG_RTE_LIBRTE_BNXT_PMD) += tf_core/tf_shadow_identifier.c diff --git a/drivers/net/bnxt/tf_core/tf_core.c b/drivers/net/bnxt/tf_core/tf_core.c index a404cb8..97e7952 100644 --- a/drivers/net/bnxt/tf_core/tf_core.c +++ b/drivers/net/bnxt/tf_core/tf_core.c @@ -534,6 +534,7 @@ tf_free_identifier(struct tf *tfp, fparms.dir = parms->dir; fparms.type = parms->ident_type; fparms.id = parms->id; + fparms.ref_cnt = &parms->ref_cnt; rc = dev->ops->tf_dev_free_ident(tfp, &fparms); if (rc) { TFP_DRV_LOG(ERR, @@ -547,6 +548,66 @@ tf_free_identifier(struct tf *tfp, } int +tf_search_identifier(struct tf *tfp, + struct tf_search_identifier_parms *parms) +{ + int rc; + struct tf_session *tfs; + struct tf_dev_info *dev; + struct tf_ident_search_parms sparms; + + TF_CHECK_PARMS2(tfp, parms); + + /* Can't do static initialization due to UT enum check */ + memset(&sparms, 0, sizeof(struct tf_ident_search_parms)); + + /* Retrieve the session information */ + rc = tf_session_get_session(tfp, &tfs); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: Failed to lookup session, rc:%s\n", + tf_dir_2_str(parms->dir), + strerror(-rc)); + return rc; + } + + /* Retrieve the device information */ + rc = tf_session_get_device(tfs, &dev); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: Failed to lookup device, rc:%s\n", + tf_dir_2_str(parms->dir), + strerror(-rc)); + return rc; + } + + if (dev->ops->tf_dev_search_ident == NULL) { + rc = -EOPNOTSUPP; + TFP_DRV_LOG(ERR, + "%s: Operation not supported, rc:%s\n", + tf_dir_2_str(parms->dir), + strerror(-rc)); + return rc; + } + + sparms.dir = parms->dir; + sparms.type = parms->ident_type; + sparms.search_id = parms->search_id; + sparms.hit = &parms->hit; + sparms.ref_cnt = &parms->ref_cnt; + rc = dev->ops->tf_dev_search_ident(tfp, &sparms); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: Identifier search failed, rc:%s\n", + tf_dir_2_str(parms->dir), + strerror(-rc)); + return rc; + } + + return 0; +} + +int tf_alloc_tcam_entry(struct tf *tfp, struct tf_alloc_tcam_entry_parms *parms) { diff --git a/drivers/net/bnxt/tf_core/tf_core.h b/drivers/net/bnxt/tf_core/tf_core.h index 9e80426..9a5e816 100644 --- a/drivers/net/bnxt/tf_core/tf_core.h +++ b/drivers/net/bnxt/tf_core/tf_core.h @@ -695,9 +695,9 @@ struct tf_alloc_identifier_parms { */ enum tf_identifier_type ident_type; /** - * [out] Identifier allocated + * [out] Allocated identifier */ - uint16_t id; + uint32_t id; }; /** @@ -715,7 +715,38 @@ struct tf_free_identifier_parms { /** * [in] ID to free */ - uint16_t id; + uint32_t id; + /** + * (experimental) + * [out] Current refcnt after free + */ + uint32_t ref_cnt; +}; + +/** + * tf_search_identifier parameter definition (experimental) + */ +struct tf_search_identifier_parms { + /** + * [in] receive or transmit direction + */ + enum tf_dir dir; + /** + * [in] Identifier type + */ + enum tf_identifier_type ident_type; + /** + * [in] Identifier data to search for + */ + uint32_t search_id; + /** + * [out] Set if matching identifier found + */ + bool hit; + /** + * [out] Current ref count after allocation + */ + uint32_t ref_cnt; }; /** @@ -724,6 +755,9 @@ struct tf_free_identifier_parms { * TruFlow core will allocate a free id from the per identifier resource type * pool reserved for the session during tf_open(). No firmware is involved. * + * If shadow copy is enabled, the internal ref_cnt is set to 1 in the + * shadow table for a newly allocated resource. + * * Returns success or failure code. */ int tf_alloc_identifier(struct tf *tfp, @@ -736,12 +770,42 @@ int tf_alloc_identifier(struct tf *tfp, * reserved for the session. No firmware is involved. During tf_close, the * complete pool is returned to the firmware. * + * additional operation (experimental) + * Decrement reference count. Only release resource once refcnt goes to 0 if + * shadow copy is enabled. + * * Returns success or failure code. */ int tf_free_identifier(struct tf *tfp, struct tf_free_identifier_parms *parms); /** + * Search identifier resource (experimental) + * + * If the shadow copy is enabled search_id is used to search for a matching + * entry in the shadow table. The shadow table consists of an array of + * reference counts indexed by identifier. If a matching entry is found hit is + * set to TRUE, refcnt is increased by 1 and returned. Otherwise, hit is + * set to false and refcnt is set to 0. + * + * TODO: we may need a per table internal shadow copy enable flag to stage + * the shadow table implementation. We do not need the shadow table for other + * tables at this time so we may only want to enable the identifier shadow. + * + * TODO: remove this pseudocode below added to show that if search fails + * we shouldn't allocate a new entry but return. + * + * identifier alloc (search_en=1) + * if (ident is allocated and ref_cnt >=1) + * return ident - hit is set, incr refcnt + * else (not found) + * return + * + */ +int tf_search_identifier(struct tf *tfp, + struct tf_search_identifier_parms *parms); + +/** * @page dram_table DRAM Table Scope Interface * * @ref tf_alloc_tbl_scope diff --git a/drivers/net/bnxt/tf_core/tf_device.h b/drivers/net/bnxt/tf_core/tf_device.h index 0bc7090..fce7f25 100644 --- a/drivers/net/bnxt/tf_core/tf_device.h +++ b/drivers/net/bnxt/tf_core/tf_device.h @@ -199,6 +199,26 @@ struct tf_dev_ops { struct tf_ident_free_parms *parms); /** + * Search of an identifier element. + * + * This API search the specified identifier element from a + * device specific identifier shadow DB. The allocated element + * is returned. + * + * [in] tfp + * Pointer to TF handle + * + * [in] parms + * Pointer to identifier search parameters + * + * Returns + * - (0) if successful. + * - (-EINVAL) on failure. + */ + int (*tf_dev_search_ident)(struct tf *tfp, + struct tf_ident_search_parms *parms); + + /** * Allocation of a table type element. * * This API allocates the specified table type element from a diff --git a/drivers/net/bnxt/tf_core/tf_device_p4.c b/drivers/net/bnxt/tf_core/tf_device_p4.c index dfe626c..f38c38e 100644 --- a/drivers/net/bnxt/tf_core/tf_device_p4.c +++ b/drivers/net/bnxt/tf_core/tf_device_p4.c @@ -86,6 +86,7 @@ const struct tf_dev_ops tf_dev_ops_p4_init = { .tf_dev_get_tcam_slice_info = tf_dev_p4_get_tcam_slice_info, .tf_dev_alloc_ident = NULL, .tf_dev_free_ident = NULL, + .tf_dev_search_ident = NULL, .tf_dev_alloc_ext_tbl = NULL, .tf_dev_alloc_tbl = NULL, .tf_dev_free_ext_tbl = NULL, @@ -120,6 +121,7 @@ const struct tf_dev_ops tf_dev_ops_p4 = { .tf_dev_get_tcam_slice_info = tf_dev_p4_get_tcam_slice_info, .tf_dev_alloc_ident = tf_ident_alloc, .tf_dev_free_ident = tf_ident_free, + .tf_dev_search_ident = tf_ident_search, .tf_dev_alloc_tbl = tf_tbl_alloc, .tf_dev_alloc_ext_tbl = tf_tbl_ext_alloc, .tf_dev_free_tbl = tf_tbl_free, diff --git a/drivers/net/bnxt/tf_core/tf_identifier.c b/drivers/net/bnxt/tf_core/tf_identifier.c index 90aeaa4..273d629 100644 --- a/drivers/net/bnxt/tf_core/tf_identifier.c +++ b/drivers/net/bnxt/tf_core/tf_identifier.c @@ -6,6 +6,7 @@ #include #include "tf_identifier.h" +#include "tf_shadow_identifier.h" #include "tf_common.h" #include "tf_rm.h" #include "tf_util.h" @@ -23,6 +24,16 @@ static void *ident_db[TF_DIR_MAX]; */ static uint8_t init; +/** + * Identifier shadow DBs. + */ +static void *ident_shadow_db[TF_DIR_MAX]; + +/** + * Shadow DB Init flag, set on bind and cleared on unbind + */ +static uint8_t shadow_init; + int tf_ident_bind(struct tf *tfp, struct tf_ident_cfg_parms *parms) @@ -30,6 +41,8 @@ tf_ident_bind(struct tf *tfp, int rc; int i; struct tf_rm_create_db_parms db_cfg = { 0 }; + struct tf_shadow_ident_cfg_parms shadow_cfg = { 0 }; + struct tf_shadow_ident_create_db_parms shadow_cdb = { 0 }; TF_CHECK_PARMS2(tfp, parms); @@ -55,6 +68,23 @@ tf_ident_bind(struct tf *tfp, return rc; } + + if (parms->shadow_copy) { + shadow_cfg.alloc_cnt = + parms->resources->ident_cnt[i].cnt; + shadow_cdb.num_elements = parms->num_elements; + shadow_cdb.tf_shadow_ident_db = &ident_shadow_db[i]; + shadow_cdb.cfg = &shadow_cfg; + rc = tf_shadow_ident_create_db(&shadow_cdb); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: Ident shadow DB creation failed\n", + tf_dir_2_str(i)); + + return rc; + } + shadow_init = 1; + } } init = 1; @@ -71,6 +101,7 @@ tf_ident_unbind(struct tf *tfp) int rc = 0; int i; struct tf_rm_free_db_parms fparms = { 0 }; + struct tf_shadow_ident_free_db_parms sparms = { 0 }; TF_CHECK_PARMS1(tfp); @@ -89,10 +120,22 @@ tf_ident_unbind(struct tf *tfp) TFP_DRV_LOG(ERR, "rm free failed on unbind\n"); } + if (shadow_init) { + sparms.tf_shadow_ident_db = ident_shadow_db[i]; + rc = tf_shadow_ident_free_db(&sparms); + if (rc) { + /* TODO: If there are failures on unbind we + * really just have to try until all DBs are + * attempted to be cleared. + */ + } + ident_shadow_db[i] = NULL; + } ident_db[i] = NULL; } init = 0; + shadow_init = 0; return 0; } @@ -103,7 +146,9 @@ tf_ident_alloc(struct tf *tfp __rte_unused, { int rc; uint32_t id; + uint32_t base_id; struct tf_rm_allocate_parms aparms = { 0 }; + struct tf_shadow_ident_insert_parms iparms = { 0 }; TF_CHECK_PARMS2(tfp, parms); @@ -118,6 +163,7 @@ tf_ident_alloc(struct tf *tfp __rte_unused, aparms.rm_db = ident_db[parms->dir]; aparms.db_index = parms->type; aparms.index = &id; + aparms.base_index = &base_id; rc = tf_rm_allocate(&aparms); if (rc) { TFP_DRV_LOG(ERR, @@ -127,6 +173,21 @@ tf_ident_alloc(struct tf *tfp __rte_unused, return rc; } + if (shadow_init) { + iparms.tf_shadow_ident_db = ident_shadow_db[parms->dir]; + iparms.type = parms->type; + iparms.id = base_id; + + rc = tf_shadow_ident_insert(&iparms); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: Failed insert shadow DB, type:%d\n", + tf_dir_2_str(parms->dir), + parms->type); + return rc; + } + } + *parms->id = id; return 0; @@ -139,7 +200,9 @@ tf_ident_free(struct tf *tfp __rte_unused, int rc; struct tf_rm_is_allocated_parms aparms = { 0 }; struct tf_rm_free_parms fparms = { 0 }; + struct tf_shadow_ident_remove_parms rparms = { 0 }; int allocated = 0; + uint32_t base_id; TF_CHECK_PARMS2(tfp, parms); @@ -154,6 +217,7 @@ tf_ident_free(struct tf *tfp __rte_unused, aparms.rm_db = ident_db[parms->dir]; aparms.db_index = parms->type; aparms.index = parms->id; + aparms.base_index = &base_id; aparms.allocated = &allocated; rc = tf_rm_is_allocated(&aparms); if (rc) @@ -168,6 +232,27 @@ tf_ident_free(struct tf *tfp __rte_unused, return -EINVAL; } + if (shadow_init) { + rparms.tf_shadow_ident_db = ident_shadow_db[parms->dir]; + rparms.type = parms->type; + rparms.id = base_id; + rparms.ref_cnt = parms->ref_cnt; + + rc = tf_shadow_ident_remove(&rparms); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: ref_cnt was 0 in shadow DB," + " type:%d, index:%d\n", + tf_dir_2_str(parms->dir), + parms->type, + parms->id); + return rc; + } + + if (*rparms.ref_cnt > 0) + return 0; + } + /* Free requested element */ fparms.rm_db = ident_db[parms->dir]; fparms.db_index = parms->type; @@ -184,3 +269,66 @@ tf_ident_free(struct tf *tfp __rte_unused, return 0; } + +int +tf_ident_search(struct tf *tfp __rte_unused, + struct tf_ident_search_parms *parms) +{ + int rc; + struct tf_rm_is_allocated_parms aparms = { 0 }; + struct tf_shadow_ident_search_parms sparms = { 0 }; + int allocated = 0; + uint32_t base_id; + + TF_CHECK_PARMS2(tfp, parms); + + if (!init) { + TFP_DRV_LOG(ERR, + "%s: No Identifier DBs created\n", + tf_dir_2_str(parms->dir)); + return -EINVAL; + } + + if (!shadow_init) { + TFP_DRV_LOG(ERR, + "%s: Identifier Shadow copy is not enabled\n", + tf_dir_2_str(parms->dir)); + return -EINVAL; + } + + /* Check if element is in use */ + aparms.rm_db = ident_db[parms->dir]; + aparms.db_index = parms->type; + aparms.index = parms->search_id; + aparms.base_index = &base_id; + aparms.allocated = &allocated; + rc = tf_rm_is_allocated(&aparms); + if (rc) + return rc; + + if (allocated != TF_RM_ALLOCATED_ENTRY_IN_USE) { + TFP_DRV_LOG(ERR, + "%s: Entry not allocated, type:%d, index:%d\n", + tf_dir_2_str(parms->dir), + parms->type, + parms->search_id); + return -EINVAL; + } + + sparms.tf_shadow_ident_db = ident_shadow_db[parms->dir]; + sparms.type = parms->type; + sparms.search_id = base_id; + sparms.hit = parms->hit; + sparms.ref_cnt = parms->ref_cnt; + + rc = tf_shadow_ident_search(&sparms); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: Failed search shadow DB, type:%d\n", + tf_dir_2_str(parms->dir), + parms->type); + return rc; + } + + return 0; +} diff --git a/drivers/net/bnxt/tf_core/tf_identifier.h b/drivers/net/bnxt/tf_core/tf_identifier.h index 6e36c52..6d9fa08 100644 --- a/drivers/net/bnxt/tf_core/tf_identifier.h +++ b/drivers/net/bnxt/tf_core/tf_identifier.h @@ -66,6 +66,37 @@ struct tf_ident_free_parms { * [in] ID to free */ uint16_t id; + /** + * (experimental) + * [out] Current refcnt after free + */ + uint32_t *ref_cnt; +}; + +/** + * Identifier search parameter definition + */ +struct tf_ident_search_parms { + /** + * [in] receive or transmit direction + */ + enum tf_dir dir; + /** + * [in] Identifier type + */ + enum tf_identifier_type type; + /** + * [in] Identifier data to search for + */ + uint16_t search_id; + /** + * [out] Set if matching identifier found + */ + bool *hit; + /** + * [out] Current ref count after allocation + */ + uint32_t *ref_cnt; }; /** @@ -144,4 +175,20 @@ int tf_ident_alloc(struct tf *tfp, int tf_ident_free(struct tf *tfp, struct tf_ident_free_parms *parms); +/** + * Search a single identifier type. + * + * [in] tfp + * Pointer to TF handle, used for HCAPI communication + * + * [in] parms + * Pointer to parameters + * + * Returns + * - (0) if successful. + * - (-EINVAL) on failure. + */ +int tf_ident_search(struct tf *tfp, + struct tf_ident_search_parms *parms); + #endif /* _TF_IDENTIFIER_H_ */ diff --git a/drivers/net/bnxt/tf_core/tf_rm.c b/drivers/net/bnxt/tf_core/tf_rm.c index fdb87ec..78bc231 100644 --- a/drivers/net/bnxt/tf_core/tf_rm.c +++ b/drivers/net/bnxt/tf_core/tf_rm.c @@ -755,6 +755,7 @@ tf_rm_allocate(struct tf_rm_allocate_parms *parms) } *parms->index = index; + *parms->base_index = id; return rc; } @@ -841,6 +842,7 @@ tf_rm_is_allocated(struct tf_rm_is_allocated_parms *parms) if (rc) return rc; + *parms->base_index = adj_index; *parms->allocated = ba_inuse(rm_db->db[parms->db_index].pool, adj_index); diff --git a/drivers/net/bnxt/tf_core/tf_rm.h b/drivers/net/bnxt/tf_core/tf_rm.h index 775f0aa..971120a 100644 --- a/drivers/net/bnxt/tf_core/tf_rm.h +++ b/drivers/net/bnxt/tf_core/tf_rm.h @@ -204,6 +204,10 @@ struct tf_rm_allocate_parms { * available index) */ uint32_t priority; + /** + * [in] Pointer to the allocated index before adjusted. + */ + uint32_t *base_index; }; /** @@ -246,6 +250,10 @@ struct tf_rm_is_allocated_parms { * [in] Pointer to flag that indicates the state of the query */ int *allocated; + /** + * [in] Pointer to the allocated index before adjusted. + */ + uint32_t *base_index; }; /** diff --git a/drivers/net/bnxt/tf_core/tf_shadow_identifier.c b/drivers/net/bnxt/tf_core/tf_shadow_identifier.c new file mode 100644 index 0000000..390d22f --- /dev/null +++ b/drivers/net/bnxt/tf_core/tf_shadow_identifier.c @@ -0,0 +1,190 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2019-2020 Broadcom + * All rights reserved. + */ + +#include + +#include "tf_shadow_identifier.h" +#include "tf_common.h" +#include "tf_util.h" +#include "tfp.h" + +/** + * Shadow identifier DB element + */ +struct tf_shadow_ident_element { + /** + * Identifier + */ + uint32_t *id; + + /** + * Reference count, array of number of identifier type entries + */ + uint32_t *ref_count; +}; + +/** + * Shadow identifier DB definition + */ +struct tf_shadow_ident_db { + /** + * Number of elements in the DB + */ + uint16_t num_entries; + + /** + * The DB consists of an array of elements + */ + struct tf_shadow_ident_element *db; +}; + +int +tf_shadow_ident_create_db(struct tf_shadow_ident_create_db_parms *parms) +{ + int rc; + int i; + struct tfp_calloc_parms cparms; + struct tf_shadow_ident_db *shadow_db; + struct tf_shadow_ident_element *db; + + TF_CHECK_PARMS1(parms); + + /* Build the shadow DB per the request */ + cparms.nitems = 1; + cparms.size = sizeof(struct tf_shadow_ident_db); + cparms.alignment = 0; + rc = tfp_calloc(&cparms); + if (rc) + return rc; + shadow_db = (void *)cparms.mem_va; + + /* Build the DB within shadow DB */ + cparms.nitems = parms->num_elements; + cparms.size = sizeof(struct tf_shadow_ident_element); + rc = tfp_calloc(&cparms); + if (rc) + return rc; + shadow_db->db = (struct tf_shadow_ident_element *)cparms.mem_va; + shadow_db->num_entries = parms->num_elements; + + db = shadow_db->db; + for (i = 0; i < parms->num_elements; i++) { + /* If the element didn't request an allocation no need + * to create a pool nor verify if we got a reservation. + */ + if (parms->cfg->alloc_cnt[i] == 0) + continue; + + /* Create array */ + cparms.nitems = parms->cfg->alloc_cnt[i]; + cparms.size = sizeof(uint32_t); + rc = tfp_calloc(&cparms); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: Array alloc failed, type:%d\n", + tf_dir_2_str(parms->dir), + i); + goto fail; + } + db[i].ref_count = (uint32_t *)cparms.mem_va; + } + + *parms->tf_shadow_ident_db = (void *)shadow_db; + + return 0; +fail: + tfp_free((void *)db->ref_count); + tfp_free((void *)db); + tfp_free((void *)shadow_db); + parms->tf_shadow_ident_db = NULL; + + return -EINVAL; +} + +int +tf_shadow_ident_free_db(struct tf_shadow_ident_free_db_parms *parms) +{ + int i; + struct tf_shadow_ident_db *shadow_db; + + TF_CHECK_PARMS1(parms); + + shadow_db = (struct tf_shadow_ident_db *)parms->tf_shadow_ident_db; + for (i = 0; i < shadow_db->num_entries; i++) + tfp_free((void *)shadow_db->db[i].ref_count); + + tfp_free((void *)shadow_db->db); + tfp_free((void *)parms->tf_shadow_ident_db); + + return 0; +} + +int +tf_shadow_ident_search(struct tf_shadow_ident_search_parms *parms) +{ + struct tf_shadow_ident_db *shadow_db; + uint32_t ref_cnt = 0; + + TF_CHECK_PARMS1(parms); + + shadow_db = (struct tf_shadow_ident_db *)parms->tf_shadow_ident_db; + ref_cnt = shadow_db->db[parms->type].ref_count[parms->search_id]; + if (ref_cnt > 0) { + *parms->hit = 1; + *parms->ref_cnt = ++ref_cnt; + shadow_db->db[parms->type].ref_count[parms->search_id] = + ref_cnt; + } else { + *parms->hit = 0; + *parms->ref_cnt = 0; + } + + + return 0; +} + +#define ID_REF_CNT_MAX 0xffffffff +int +tf_shadow_ident_insert(struct tf_shadow_ident_insert_parms *parms) +{ + struct tf_shadow_ident_db *shadow_db; + + TF_CHECK_PARMS1(parms); + + shadow_db = (struct tf_shadow_ident_db *)parms->tf_shadow_ident_db; + + /* In case of overflow, ref count keeps the max value */ + if (shadow_db->db[parms->type].ref_count[parms->id] < ID_REF_CNT_MAX) + shadow_db->db[parms->type].ref_count[parms->id]++; + else + TFP_DRV_LOG(ERR, + "Identifier %d in type %d reaches the max ref_cnt\n", + parms->type, + parms->id); + + parms->ref_cnt = shadow_db->db[parms->type].ref_count[parms->id]; + + return 0; +} + +int +tf_shadow_ident_remove(struct tf_shadow_ident_remove_parms *parms) +{ + struct tf_shadow_ident_db *shadow_db; + uint32_t ref_cnt = 0; + + TF_CHECK_PARMS1(parms); + + shadow_db = (struct tf_shadow_ident_db *)parms->tf_shadow_ident_db; + ref_cnt = shadow_db->db[parms->type].ref_count[parms->id]; + if (ref_cnt > 0) + shadow_db->db[parms->type].ref_count[parms->id]--; + else + return -EINVAL; + + *parms->ref_cnt = shadow_db->db[parms->type].ref_count[parms->id]; + + return 0; +} diff --git a/drivers/net/bnxt/tf_core/tf_shadow_identifier.h b/drivers/net/bnxt/tf_core/tf_shadow_identifier.h new file mode 100644 index 0000000..dd633af --- /dev/null +++ b/drivers/net/bnxt/tf_core/tf_shadow_identifier.h @@ -0,0 +1,229 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2019-2020 Broadcom + * All rights reserved. + */ + +#ifndef _TF_SHADOW_IDENTIFIER_H_ +#define _TF_SHADOW_IDENTIFIER_H_ + +#include "tf_core.h" + +struct tf; + +/** + * The Shadow Identifier module provides shadow DB handling for identifier based + * TF types. A shadow DB provides the capability that allows for reuse + * of TF resources. + * + * A Shadow identifier DB is intended to be used by the Identifier Type module + * only. + */ + +/** + * Shadow DB configuration information for a single identifier type. + * + * It is used in an array of identifier types. The array must be ordered + * by the TF type is represents. + */ +struct tf_shadow_ident_cfg_parms { + /** + * TF Identifier type + */ + enum tf_identifier_type type; + + /** + * Number of entries the Shadow DB needs to hold + */ + int num_entries; + + /** + * Resource allocation count array. This array content + * originates from the tf_session_resources that is passed in + * on session open. + * Array size is num_elements. + */ + uint16_t *alloc_cnt; +}; + +/** + * Shadow identifier DB creation parameters + */ +struct tf_shadow_ident_create_db_parms { + /** + * [in] Receive or transmit direction. + */ + enum tf_dir dir; + /** + * [in] Configuration information for the shadow db + */ + struct tf_shadow_ident_cfg_parms *cfg; + /** + * [in] Number of elements in the parms structure + */ + uint16_t num_elements; + /** + * [out] Shadow identifier DB handle + */ + void **tf_shadow_ident_db; +}; + +/** + * Shadow identifier DB free parameters + */ +struct tf_shadow_ident_free_db_parms { + /** + * Shadow identifier DB handle + */ + void *tf_shadow_ident_db; +}; + +/** + * Shadow identifier search parameters + */ +struct tf_shadow_ident_search_parms { + /** + * [in] Shadow identifier DB handle + */ + void *tf_shadow_ident_db; + /** + * [in] Identifier type + */ + enum tf_identifier_type type; + /** + * [in] id to search + */ + uint16_t search_id; + /** + * [out] Index of the found element returned if hit + */ + bool *hit; + /** + * [out] Reference count incremented if hit + */ + uint32_t *ref_cnt; +}; + +/** + * Shadow identifier insert parameters + */ +struct tf_shadow_ident_insert_parms { + /** + * [in] Shadow identifier DB handle + */ + void *tf_shadow_ident_db; + /** + * [in] Tbl type + */ + enum tf_identifier_type type; + /** + * [in] Entry to update + */ + uint16_t id; + /** + * [out] Reference count after insert + */ + uint32_t ref_cnt; +}; + +/** + * Shadow identifier remove parameters + */ +struct tf_shadow_ident_remove_parms { + /** + * [in] Shadow identifier DB handle + */ + void *tf_shadow_ident_db; + /** + * [in] Tbl type + */ + enum tf_identifier_type type; + /** + * [in] Entry to update + */ + uint16_t id; + /** + * [out] Reference count after removal + */ + uint32_t *ref_cnt; +}; + +/** + * @page shadow_ident Shadow identifier DB + * + * @ref tf_shadow_ident_create_db + * + * @ref tf_shadow_ident_free_db + * + * @reg tf_shadow_ident_search + * + * @reg tf_shadow_ident_insert + * + * @reg tf_shadow_ident_remove + */ + +/** + * Creates and fills a Shadow identifier DB. The DB is indexed per the + * parms structure. + * + * [in] parms + * Pointer to create db parameters + * + * Returns + * - (0) if successful. + * - (-EINVAL) on failure. + */ +int tf_shadow_ident_create_db(struct tf_shadow_ident_create_db_parms *parms); + +/** + * Closes the Shadow identifier DB and frees all allocated + * resources per the associated database. + * + * [in] parms + * Pointer to the free DB parameters + * + * Returns + * - (0) if successful. + * - (-EINVAL) on failure. + */ +int tf_shadow_ident_free_db(struct tf_shadow_ident_free_db_parms *parms); + +/** + * Search Shadow identifier db for matching result + * + * [in] parms + * Pointer to the search parameters + * + * Returns + * - (0) if successful, element was found. + * - (-EINVAL) on failure. + */ +int tf_shadow_ident_search(struct tf_shadow_ident_search_parms *parms); + +/** + * Inserts an element into the Shadow identifier DB. Ref_count after insert + * will be incremented. + * + * [in] parms + * Pointer to insert parameters + * + * Returns + * - (0) if successful. + * - (-EINVAL) on failure. + */ +int tf_shadow_ident_insert(struct tf_shadow_ident_insert_parms *parms); + +/** + * Removes an element from the Shadow identifier DB. Will fail if the + * elements ref_count is 0. Ref_count after removal will be + * decremented. + * + * [in] parms + * Pointer to remove parameter + * + * Returns + * - (0) if successful. + * - (-EINVAL) on failure. + */ +int tf_shadow_ident_remove(struct tf_shadow_ident_remove_parms *parms); + +#endif /* _TF_SHADOW_IDENTIFIER_H_ */ From patchwork Wed Jul 15 13:50:31 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Somnath Kotur X-Patchwork-Id: 74103 X-Patchwork-Delegate: ajit.khaparde@broadcom.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id BBB27A0527; Wed, 15 Jul 2020 15:56:18 +0200 (CEST) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id AEAD61BED3; Wed, 15 Jul 2020 15:55:58 +0200 (CEST) Received: from relay.smtp.broadcom.com (relay.smtp.broadcom.com [192.19.211.62]) by dpdk.org (Postfix) with ESMTP id C03611B3BB for ; Wed, 15 Jul 2020 15:55:51 +0200 (CEST) Received: from dhcp-10-123-153-55.dhcp.broadcom.net (dhcp-10-123-153-55.dhcp.broadcom.net [10.123.153.55]) by relay.smtp.broadcom.com (Postfix) with ESMTP id 0720E299DE3; Wed, 15 Jul 2020 06:55:50 -0700 (PDT) DKIM-Filter: OpenDKIM Filter v2.10.3 relay.smtp.broadcom.com 0720E299DE3 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=broadcom.com; s=dkimrelay; t=1594821351; bh=7ehpsW9rPrpGb0pAwGhwROerYlxmN3oCob1gSD/4Tq4=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=mfVqoi1LKHJCeZu2voImvnKze2d0+cUVJ46oLOK4MAN0u/xSqSQDbS3FnnqudFbRy 30/Covi10vFbSiF3DHGrunTsW6g2HYnORbXt3dCsZuDbO2Ri/i+BwA8L0sKZK72HBF 9Lzsl8EXG/IVC9Oixr8D5X51+hElkf3QGNRVJRG4= From: Somnath Kotur To: dev@dpdk.org Cc: ferruh.yigit@intel.com Date: Wed, 15 Jul 2020 19:20:31 +0530 Message-Id: <20200715135038.16662-4-somnath.kotur@broadcom.com> X-Mailer: git-send-email 2.10.1.613.g2cc2e70 In-Reply-To: <20200715135038.16662-1-somnath.kotur@broadcom.com> References: <20200713061600.19456-1-somnath.kotur@broadcom.com> <20200715135038.16662-1-somnath.kotur@broadcom.com> Subject: [dpdk-dev] [PATCH 03/10] net/bnxt: check index range in bulk get X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" From: Jay Ding In tf_tbl_bulk_get, check if the indexes are in the range of reserved tbl id instead of checking the allocation of each id. Signed-off-by: Jay Ding Reviewed-by: Somnath Kotur Reviewed-by: Randy Schacher Reviewed-by: Ajit Kumar Khaparde Signed-off-by: Somnath Kotur --- drivers/net/bnxt/tf_core/tf_core.h | 8 ++++--- drivers/net/bnxt/tf_core/tf_msg.c | 3 ++- drivers/net/bnxt/tf_core/tf_rm.c | 45 ++++++++++++++++++++++++++++++++++++-- drivers/net/bnxt/tf_core/tf_rm.h | 37 +++++++++++++++++++++++++++++++ drivers/net/bnxt/tf_core/tf_tbl.c | 40 ++++++++++++++------------------- 5 files changed, 104 insertions(+), 29 deletions(-) diff --git a/drivers/net/bnxt/tf_core/tf_core.h b/drivers/net/bnxt/tf_core/tf_core.h index 9a5e816..758685e 100644 --- a/drivers/net/bnxt/tf_core/tf_core.h +++ b/drivers/net/bnxt/tf_core/tf_core.h @@ -1426,10 +1426,12 @@ struct tf_bulk_get_tbl_entry_parms { /** * Bulk get index table entry * - * Used to retrieve a previous set index table entry. + * Used to retrieve a set of index table entries. * - * Reads and compares with the shadow table copy (if enabled) (only - * for internal objects). + * Entries within the range may not have been allocated using + * tf_alloc_tbl_entry() at the time of access. But the range must + * be within the bounds determined from tf_open_session() for the + * given table type. Currently, this is only used for collecting statistics. * * Returns success or failure code. Failure will be returned if the * provided data buffer is too small for the data type requested. diff --git a/drivers/net/bnxt/tf_core/tf_msg.c b/drivers/net/bnxt/tf_core/tf_msg.c index 1e14d92..53515ad 100644 --- a/drivers/net/bnxt/tf_core/tf_msg.c +++ b/drivers/net/bnxt/tf_core/tf_msg.c @@ -143,7 +143,8 @@ tf_msg_session_open(struct tf *tfp, return rc; *fw_session_id = (uint8_t)tfp_le_to_cpu_32(resp.fw_session_id); - *fw_session_client_id = (uint8_t)tfp_le_to_cpu_32(resp.fw_session_id); + *fw_session_client_id = + (uint8_t)tfp_le_to_cpu_32(resp.fw_session_client_id); return rc; } diff --git a/drivers/net/bnxt/tf_core/tf_rm.c b/drivers/net/bnxt/tf_core/tf_rm.c index 78bc231..9aec954 100644 --- a/drivers/net/bnxt/tf_core/tf_rm.c +++ b/drivers/net/bnxt/tf_core/tf_rm.c @@ -755,7 +755,8 @@ tf_rm_allocate(struct tf_rm_allocate_parms *parms) } *parms->index = index; - *parms->base_index = id; + if (parms->base_index) + *parms->base_index = id; return rc; } @@ -842,7 +843,8 @@ tf_rm_is_allocated(struct tf_rm_is_allocated_parms *parms) if (rc) return rc; - *parms->base_index = adj_index; + if (parms->base_index) + *parms->base_index = adj_index; *parms->allocated = ba_inuse(rm_db->db[parms->db_index].pool, adj_index); @@ -922,3 +924,42 @@ tf_rm_get_inuse_count(struct tf_rm_get_inuse_count_parms *parms) return rc; } + +int +tf_rm_check_indexes_in_range(struct tf_rm_check_indexes_in_range_parms *parms) +{ + struct tf_rm_new_db *rm_db; + enum tf_rm_elem_cfg_type cfg_type; + uint32_t base_index; + uint32_t stride; + int rc = 0; + + TF_CHECK_PARMS2(parms, parms->rm_db); + + rm_db = (struct tf_rm_new_db *)parms->rm_db; + cfg_type = rm_db->db[parms->db_index].cfg_type; + + /* Bail out if not controlled by RM */ + if (cfg_type != TF_RM_ELEM_CFG_HCAPI_BA) + return -ENOTSUP; + + /* Bail out if the pool is not valid, should never happen */ + if (rm_db->db[parms->db_index].pool == NULL) { + rc = -ENOTSUP; + TFP_DRV_LOG(ERR, + "%s: Invalid pool for this type:%d, rc:%s\n", + tf_dir_2_str(rm_db->dir), + parms->db_index, + strerror(-rc)); + return rc; + } + + base_index = rm_db->db[parms->db_index].alloc.entry.start; + stride = rm_db->db[parms->db_index].alloc.entry.stride; + + if (parms->starting_index < base_index || + parms->starting_index + parms->num_entries > base_index + stride) + return -EINVAL; + + return rc; +} diff --git a/drivers/net/bnxt/tf_core/tf_rm.h b/drivers/net/bnxt/tf_core/tf_rm.h index 971120a..97692db 100644 --- a/drivers/net/bnxt/tf_core/tf_rm.h +++ b/drivers/net/bnxt/tf_core/tf_rm.h @@ -315,6 +315,29 @@ struct tf_rm_get_inuse_count_parms { }; /** + * Check if the indexes are in the range of reserved resource + */ +struct tf_rm_check_indexes_in_range_parms { + /** + * [in] RM DB Handle + */ + void *rm_db; + /** + * [in] DB Index, indicates which DB entry to perform the + * action on. + */ + uint16_t db_index; + /** + * [in] Starting index + */ + uint16_t starting_index; + /** + * [in] number of entries + */ + uint16_t num_entries; +}; + +/** * @page rm Resource Manager * * @ref tf_rm_create_db @@ -462,4 +485,18 @@ int tf_rm_get_hcapi_type(struct tf_rm_get_hcapi_parms *parms); */ int tf_rm_get_inuse_count(struct tf_rm_get_inuse_count_parms *parms); +/** + * Check if the requested indexes are in the range of reserved resource. + * + * [in] parms + * Pointer to get inuse parameters + * + * Returns + * - (0) if successful. + * - (-EINVAL) on failure. + */ +int +tf_rm_check_indexes_in_range(struct tf_rm_check_indexes_in_range_parms *parms); + + #endif /* TF_RM_NEW_H_ */ diff --git a/drivers/net/bnxt/tf_core/tf_tbl.c b/drivers/net/bnxt/tf_core/tf_tbl.c index 2b4a7c5..9ebaa34 100644 --- a/drivers/net/bnxt/tf_core/tf_tbl.c +++ b/drivers/net/bnxt/tf_core/tf_tbl.c @@ -350,12 +350,9 @@ tf_tbl_bulk_get(struct tf *tfp, struct tf_tbl_get_bulk_parms *parms) { int rc; - int i; uint16_t hcapi_type; - uint32_t idx; - int allocated = 0; - struct tf_rm_is_allocated_parms aparms = { 0 }; struct tf_rm_get_hcapi_parms hparms = { 0 }; + struct tf_rm_check_indexes_in_range_parms cparms = { 0 }; TF_CHECK_PARMS2(tfp, parms); @@ -366,26 +363,23 @@ tf_tbl_bulk_get(struct tf *tfp, return -EINVAL; } - /* Verify that the entries has been previously allocated */ - aparms.rm_db = tbl_db[parms->dir]; - aparms.db_index = parms->type; - aparms.allocated = &allocated; - idx = parms->starting_idx; - for (i = 0; i < parms->num_entries; i++) { - aparms.index = idx; - rc = tf_rm_is_allocated(&aparms); - if (rc) - return rc; - if (allocated != TF_RM_ALLOCATED_ENTRY_IN_USE) { - TFP_DRV_LOG(ERR, - "%s, Invalid or not allocated index, type:%d, idx:%d\n", - tf_dir_2_str(parms->dir), - parms->type, - idx); - return -EINVAL; - } - idx++; + /* Verify that the entries are in the range of reserved resources. */ + cparms.rm_db = tbl_db[parms->dir]; + cparms.db_index = parms->type; + cparms.starting_index = parms->starting_idx; + cparms.num_entries = parms->num_entries; + + rc = tf_rm_check_indexes_in_range(&cparms); + if (rc) { + TFP_DRV_LOG(ERR, + "%s, Invalid or %d index starting from %d" + " not in range, type:%d", + tf_dir_2_str(parms->dir), + parms->starting_idx, + parms->num_entries, + parms->type); + return rc; } hparms.rm_db = tbl_db[parms->dir]; From patchwork Wed Jul 15 13:50:32 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Somnath Kotur X-Patchwork-Id: 74104 X-Patchwork-Delegate: ajit.khaparde@broadcom.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 9A6C7A0527; Wed, 15 Jul 2020 15:56:28 +0200 (CEST) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 0D3F61BEDD; Wed, 15 Jul 2020 15:56:00 +0200 (CEST) Received: from relay.smtp.broadcom.com (unknown [192.19.211.62]) by dpdk.org (Postfix) with ESMTP id 161091B75C for ; Wed, 15 Jul 2020 15:55:52 +0200 (CEST) Received: from dhcp-10-123-153-55.dhcp.broadcom.net (dhcp-10-123-153-55.dhcp.broadcom.net [10.123.153.55]) by relay.smtp.broadcom.com (Postfix) with ESMTP id 50B43299E0E; Wed, 15 Jul 2020 06:55:51 -0700 (PDT) DKIM-Filter: OpenDKIM Filter v2.10.3 relay.smtp.broadcom.com 50B43299E0E DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=broadcom.com; s=dkimrelay; t=1594821351; bh=qr8L6Iiq/3WxCiH2os6GPKEklM8Fuy+MmoloD8MA4Vo=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=LQ10wNfsFOEofeSCCg9M9umEI6TU+cbf3s3azwE7t2KDsGUjlsSQEuYYm4owZzPer KeJl9WEaEJ0LhIts/rOox2ppiQnFX/jbRh6+wHr9dvBgDvMAnLnO9zFAx1M2tMJXjZ CEvymyru19H+eRfQCELKMfNxojpYwdx7wQz2a090= From: Somnath Kotur To: dev@dpdk.org Cc: ferruh.yigit@intel.com Date: Wed, 15 Jul 2020 19:20:32 +0530 Message-Id: <20200715135038.16662-5-somnath.kotur@broadcom.com> X-Mailer: git-send-email 2.10.1.613.g2cc2e70 In-Reply-To: <20200715135038.16662-1-somnath.kotur@broadcom.com> References: <20200713061600.19456-1-somnath.kotur@broadcom.com> <20200715135038.16662-1-somnath.kotur@broadcom.com> Subject: [dpdk-dev] [PATCH 04/10] net/bnxt: add changes to support 2 table scopes X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" From: Farah Smith Need to remap the table scope ids allocated from HCAPI RM from high to low value because for legacy devices a table scope is a set of base addresses. The PCIe addresses must map to a PCIe PF which exists in the hardware. Signed-off-by: Farah Smith Reviewed-by: Somnath Kotur Reviewed-by: Randy Schacher Reviewed-by: Ajit Kumar Khaparde Signed-off-by: Somnath Kotur --- drivers/net/bnxt/tf_core/tf_em_common.c | 106 +++++++++++++++++++++++++++++++- drivers/net/bnxt/tf_core/tf_em_common.h | 27 +++++++- drivers/net/bnxt/tf_core/tf_em_host.c | 23 ++----- drivers/net/bnxt/tf_core/tf_em_system.c | 19 +----- 4 files changed, 137 insertions(+), 38 deletions(-) diff --git a/drivers/net/bnxt/tf_core/tf_em_common.c b/drivers/net/bnxt/tf_core/tf_em_common.c index 65b9abf..10c3f16 100644 --- a/drivers/net/bnxt/tf_core/tf_em_common.c +++ b/drivers/net/bnxt/tf_core/tf_em_common.c @@ -44,6 +44,28 @@ static enum tf_mem_type mem_type; /** Table scope array */ struct tf_tbl_scope_cb tbl_scopes[TF_NUM_TBL_SCOPE]; +/** Table scope reversal table + * + * Table scope are allocated from 15 to 0 within HCAPI RM. Because of the + * association between PFs and legacy table scopes, reverse table scope ids. + * 15 indicates 0, 14 indicates 1, etc... The application will only see the 0 + * based number. The firmware will only use the 0 based number. Only HCAPI RM + * and Truflow RM believe the number is 15. When HCAPI RM support allocation + * from low to high is supported, this adjust function can be removed. + */ +const uint32_t tbl_scope_reverse[TF_NUM_TBL_SCOPE] = { + 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 }; + +static uint32_t +tf_tbl_scope_adjust(uint32_t tbl_scope_id) +{ + if (tbl_scope_id < TF_NUM_TBL_SCOPE) + return tbl_scope_reverse[tbl_scope_id]; + else + return TF_TBL_SCOPE_INVALID; +}; + + /* API defined in tf_em.h */ struct tf_tbl_scope_cb * tbl_scope_cb_find(uint32_t tbl_scope_id) @@ -51,11 +73,17 @@ tbl_scope_cb_find(uint32_t tbl_scope_id) int i; struct tf_rm_is_allocated_parms parms; int allocated; + uint32_t rm_tbl_scope_id; + + rm_tbl_scope_id = tf_tbl_scope_adjust(tbl_scope_id); + + if (rm_tbl_scope_id == TF_TBL_SCOPE_INVALID) + return NULL; /* Check that id is valid */ parms.rm_db = eem_db[TF_DIR_RX]; parms.db_index = TF_EM_TBL_TYPE_TBL_SCOPE; - parms.index = tbl_scope_id; + parms.index = rm_tbl_scope_id; parms.allocated = &allocated; i = tf_rm_is_allocated(&parms); @@ -71,6 +99,61 @@ tbl_scope_cb_find(uint32_t tbl_scope_id) return NULL; } +int tf_tbl_scope_alloc(uint32_t *tbl_scope_id) +{ + int rc; + struct tf_rm_allocate_parms parms = { 0 }; + uint32_t rm_tbl_scope_id; + uint32_t usr_tbl_scope_id = TF_TBL_SCOPE_INVALID; + + /* Get Table Scope control block from the session pool */ + parms.rm_db = eem_db[TF_DIR_RX]; + parms.db_index = TF_EM_TBL_TYPE_TBL_SCOPE; + parms.index = &rm_tbl_scope_id; + + rc = tf_rm_allocate(&parms); + if (rc) { + TFP_DRV_LOG(ERR, + "Failed to allocate table scope rc:%s\n", + strerror(-rc)); + return rc; + } + + usr_tbl_scope_id = tf_tbl_scope_adjust(rm_tbl_scope_id); + + if (usr_tbl_scope_id == TF_TBL_SCOPE_INVALID) { + TFP_DRV_LOG(ERR, + "Invalid table scope allocated id:%d\n", + (int)rm_tbl_scope_id); + return -EINVAL; + } + *tbl_scope_id = usr_tbl_scope_id; + return 0; +}; + +int tf_tbl_scope_free(uint32_t tbl_scope_id) +{ + struct tf_rm_free_parms parms = { 0 }; + uint32_t rm_tbl_scope_id; + uint32_t rc; + + rm_tbl_scope_id = tf_tbl_scope_adjust(tbl_scope_id); + + if (rm_tbl_scope_id == TF_TBL_SCOPE_INVALID) { + TFP_DRV_LOG(ERR, + "Invalid table scope allocated id:%d\n", + (int)tbl_scope_id); + return -EINVAL; + } + + parms.rm_db = eem_db[TF_DIR_RX]; + parms.db_index = TF_EM_TBL_TYPE_TBL_SCOPE; + parms.index = rm_tbl_scope_id; + + rc = tf_rm_free(&parms); + return rc; +}; + int tf_create_tbl_pool_external(enum tf_dir dir, struct tf_tbl_scope_cb *tbl_scope_cb, @@ -706,9 +789,17 @@ tf_insert_eem_entry(struct tf_tbl_scope_cb *tbl_scope_cb, if (rc) { struct tf_rm_free_parms fparms = { 0 }; + uint32_t rm_tbl_scope_id; TFP_DRV_LOG(ERR, "System alloc mmap failed\n"); + + rm_tbl_scope_id = + tf_tbl_scope_adjust(parms->tbl_scope_id); + + if (rm_tbl_scope_id == TF_TBL_SCOPE_INVALID) + return -EINVAL; + /* Free Table control block */ fparms.rm_db = eem_db[TF_DIR_RX]; fparms.db_index = TF_EM_TBL_TYPE_TBL_SCOPE; @@ -1043,13 +1134,24 @@ int tf_tbl_ext_common_set(struct tf *tfp, if (rc) { struct tf_rm_free_parms fparms = { 0 }; + uint32_t rm_tbl_scope_id; + + /* TODO: support allocation of table scope from + * min in HCAPI RM. For now call adjust function + * on value obtained from RM. + */ + rm_tbl_scope_id = + tf_tbl_scope_adjust(parms->tbl_scope_id); + + if (rm_tbl_scope_id == TF_TBL_SCOPE_INVALID) + return -EINVAL; TFP_DRV_LOG(ERR, "System alloc mmap failed\n"); /* Free Table control block */ fparms.rm_db = eem_db[TF_DIR_RX]; fparms.db_index = TF_EM_TBL_TYPE_TBL_SCOPE; - fparms.index = parms->tbl_scope_id; + fparms.index = rm_tbl_scope_id; tf_rm_free(&fparms); return -EINVAL; } diff --git a/drivers/net/bnxt/tf_core/tf_em_common.h b/drivers/net/bnxt/tf_core/tf_em_common.h index fa313c4..f71a487 100644 --- a/drivers/net/bnxt/tf_core/tf_em_common.h +++ b/drivers/net/bnxt/tf_core/tf_em_common.h @@ -9,7 +9,6 @@ #include "tf_core.h" #include "tf_session.h" - /** * Function to search for table scope control block structure * with specified table scope ID. @@ -24,6 +23,32 @@ struct tf_tbl_scope_cb *tbl_scope_cb_find(uint32_t tbl_scope_id); /** + * Table Scope Allocate + * + * Allocate a table scope + * + * [in/out] pointer to tbl_scope_id + * + * Returns: + * 0 - success + * -EINVAL - error + */ +int tf_tbl_scope_alloc(uint32_t *tbl_scope_id); + +/** + * Table Scope Free + * + * Free a table scope + * + * [in] tbl_scope_id to free + * + * Returns: + * 0 - success + * -EINVAL - error + */ +int tf_tbl_scope_free(uint32_t tbl_scope_id); + +/** * Create and initialize a stack to use for action entries * * [in] dir diff --git a/drivers/net/bnxt/tf_core/tf_em_host.c b/drivers/net/bnxt/tf_core/tf_em_host.c index b5db94f..cfcb12f 100644 --- a/drivers/net/bnxt/tf_core/tf_em_host.c +++ b/drivers/net/bnxt/tf_core/tf_em_host.c @@ -374,14 +374,8 @@ tf_em_ext_alloc(struct tf *tfp, struct tf_alloc_tbl_scope_parms *parms) struct tf_tbl_scope_cb *tbl_scope_cb; struct hcapi_cfa_em_table *em_tables; struct tf_free_tbl_scope_parms free_parms; - struct tf_rm_allocate_parms aparms = { 0 }; - struct tf_rm_free_parms fparms = { 0 }; - - /* Get Table Scope control block from the session pool */ - aparms.rm_db = eem_db[TF_DIR_RX]; - aparms.db_index = TF_EM_TBL_TYPE_TBL_SCOPE; - aparms.index = (uint32_t *)&parms->tbl_scope_id; - rc = tf_rm_allocate(&aparms); + + rc = tf_tbl_scope_alloc(&parms->tbl_scope_id); if (rc) { TFP_DRV_LOG(ERR, "Failed to allocate table scope\n"); @@ -478,11 +472,7 @@ tf_em_ext_alloc(struct tf *tfp, struct tf_alloc_tbl_scope_parms *parms) return -EINVAL; cleanup: - /* Free Table control block */ - fparms.rm_db = eem_db[TF_DIR_RX]; - fparms.db_index = TF_EM_TBL_TYPE_TBL_SCOPE; - fparms.index = parms->tbl_scope_id; - tf_rm_free(&fparms); + tf_tbl_scope_free(parms->tbl_scope_id); return -EINVAL; } @@ -493,7 +483,6 @@ tf_em_ext_free(struct tf *tfp, int rc = 0; enum tf_dir dir; struct tf_tbl_scope_cb *tbl_scope_cb; - struct tf_rm_free_parms aparms = { 0 }; tbl_scope_cb = tbl_scope_cb_find(parms->tbl_scope_id); @@ -502,11 +491,7 @@ tf_em_ext_free(struct tf *tfp, return -EINVAL; } - /* Free Table control block */ - aparms.rm_db = eem_db[TF_DIR_RX]; - aparms.db_index = TF_EM_TBL_TYPE_TBL_SCOPE; - aparms.index = parms->tbl_scope_id; - rc = tf_rm_free(&aparms); + rc = tf_tbl_scope_free(parms->tbl_scope_id); if (rc) { TFP_DRV_LOG(ERR, "Failed to free table scope\n"); diff --git a/drivers/net/bnxt/tf_core/tf_em_system.c b/drivers/net/bnxt/tf_core/tf_em_system.c index 1c3c702..32ee1ee 100644 --- a/drivers/net/bnxt/tf_core/tf_em_system.c +++ b/drivers/net/bnxt/tf_core/tf_em_system.c @@ -364,9 +364,7 @@ tf_em_ext_alloc(struct tf *tfp, int rc; struct tf_session *tfs; struct tf_tbl_scope_cb *tbl_scope_cb; - struct tf_rm_allocate_parms aparms = { 0 }; struct tf_free_tbl_scope_parms free_parms; - struct tf_rm_free_parms fparms = { 0 }; int dir; int i; struct hcapi_cfa_em_table *em_tables; @@ -382,10 +380,7 @@ tf_em_ext_alloc(struct tf *tfp, return rc; } - aparms.rm_db = eem_db[TF_DIR_RX]; - aparms.db_index = TF_EM_TBL_TYPE_TBL_SCOPE; - aparms.index = (uint32_t *)&parms->tbl_scope_id; - rc = tf_rm_allocate(&aparms); + rc = tf_tbl_scope_alloc(&parms->tbl_scope_id); if (rc) { TFP_DRV_LOG(ERR, "Failed to allocate table scope\n"); @@ -473,10 +468,7 @@ tf_em_ext_alloc(struct tf *tfp, cleanup: /* Free Table control block */ - fparms.rm_db = eem_db[TF_DIR_RX]; - fparms.db_index = TF_EM_TBL_TYPE_TBL_SCOPE; - fparms.index = parms->tbl_scope_id; - tf_rm_free(&fparms); + tf_tbl_scope_free(parms->tbl_scope_id); return -EINVAL; } @@ -488,7 +480,6 @@ tf_em_ext_free(struct tf *tfp, struct tf_session *tfs; struct tf_tbl_scope_cb *tbl_scope_cb; int dir; - struct tf_rm_free_parms aparms = { 0 }; TF_CHECK_PARMS2(tfp, parms); @@ -503,11 +494,7 @@ tf_em_ext_free(struct tf *tfp, tbl_scope_cb = &tbl_scopes[parms->tbl_scope_id]; - /* Free Table control block */ - aparms.rm_db = eem_db[TF_DIR_RX]; - aparms.db_index = TF_EM_TBL_TYPE_TBL_SCOPE; - aparms.index = parms->tbl_scope_id; - rc = tf_rm_free(&aparms); + rc = tf_tbl_scope_free(parms->tbl_scope_id); if (rc) { TFP_DRV_LOG(ERR, "Failed to free table scope\n"); From patchwork Wed Jul 15 13:50:33 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Somnath Kotur X-Patchwork-Id: 74105 X-Patchwork-Delegate: ajit.khaparde@broadcom.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 8238FA0527; Wed, 15 Jul 2020 15:56:39 +0200 (CEST) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 688921BEE4; Wed, 15 Jul 2020 15:56:01 +0200 (CEST) Received: from relay.smtp.broadcom.com (relay.smtp.broadcom.com [192.19.211.62]) by dpdk.org (Postfix) with ESMTP id 611294C8A for ; Wed, 15 Jul 2020 15:55:52 +0200 (CEST) Received: from dhcp-10-123-153-55.dhcp.broadcom.net (dhcp-10-123-153-55.dhcp.broadcom.net [10.123.153.55]) by relay.smtp.broadcom.com (Postfix) with ESMTP id 9A17F299E18; Wed, 15 Jul 2020 06:55:51 -0700 (PDT) DKIM-Filter: OpenDKIM Filter v2.10.3 relay.smtp.broadcom.com 9A17F299E18 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=broadcom.com; s=dkimrelay; t=1594821351; bh=8dxShUVk0C5pAAsJVQcu9rI0ANnBp0inpXHNwh5rhwY=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=G5y5ktMfQ1tCfYShHli2bia/uu0EV9JoNfiFhXPx9vAHyZLg6C8ge0mQdxnCTIx98 c6hc+Ux0P8llbMIc//n2Ri7tFEYBpd7d1IXCQIrhtSQgOdCeFWdNlZO0HqG9HXv1QS OTFqcfOpWStAsl0IMIYJadT6YiV7M+cTtgLUpGkE= From: Somnath Kotur To: dev@dpdk.org Cc: ferruh.yigit@intel.com Date: Wed, 15 Jul 2020 19:20:33 +0530 Message-Id: <20200715135038.16662-6-somnath.kotur@broadcom.com> X-Mailer: git-send-email 2.10.1.613.g2cc2e70 In-Reply-To: <20200715135038.16662-1-somnath.kotur@broadcom.com> References: <20200713061600.19456-1-somnath.kotur@broadcom.com> <20200715135038.16662-1-somnath.kotur@broadcom.com> Subject: [dpdk-dev] [PATCH 05/10] net/bnxt: add support to extract data from the ulp blob X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" From: Kishore Padmanabha Extended the ulp blob to extract data from the blob for a given offset and length. The support is added only for little endian format. Signed-off-by: Kishore Padmanabha Reviewed-by: Randy Schacher Signed-off-by: Somnath Kotur --- drivers/net/bnxt/tf_ulp/ulp_utils.c | 76 +++++++++++++++++++++++++++++++++++++ drivers/net/bnxt/tf_ulp/ulp_utils.h | 17 +++++++++ 2 files changed, 93 insertions(+) diff --git a/drivers/net/bnxt/tf_ulp/ulp_utils.c b/drivers/net/bnxt/tf_ulp/ulp_utils.c index 3afaac6..a923da8 100644 --- a/drivers/net/bnxt/tf_ulp/ulp_utils.c +++ b/drivers/net/bnxt/tf_ulp/ulp_utils.c @@ -418,6 +418,82 @@ ulp_blob_pad_push(struct ulp_blob *blob, return datalen; } +/* Get data from src and put into dst using little-endian format */ +static void +ulp_bs_get_lsb(uint8_t *src, uint16_t bitpos, uint8_t bitlen, uint8_t *dst) +{ + uint8_t bitoffs = bitpos % ULP_BLOB_BYTE; + uint16_t index = ULP_BITS_2_BYTE_NR(bitpos); + uint8_t mask, partial, shift; + + shift = bitoffs; + partial = ULP_BLOB_BYTE - bitoffs; + if (bitoffs + bitlen <= ULP_BLOB_BYTE) { + mask = ((1 << bitlen) - 1) << shift; + *dst = (src[index] & mask) >> shift; + } else { + mask = ((1 << partial) - 1) << shift; + *dst = (src[index] & mask) >> shift; + index++; + partial = bitlen - partial; + mask = ((1 << partial) - 1); + *dst |= (src[index] & mask) << (ULP_BLOB_BYTE - bitoffs); + } +} + +/* Assuming that src is in little-Endian Format */ +static void +ulp_bs_pull_lsb(uint8_t *src, uint8_t *dst, uint32_t size, + uint32_t offset, uint32_t len) +{ + uint32_t idx; + uint32_t cnt = ULP_BITS_2_BYTE_NR(len); + + /* iterate bytewise to get data */ + for (idx = 0; idx < cnt; idx++) { + ulp_bs_get_lsb(src, offset, ULP_BLOB_BYTE, + &dst[size - 1 - idx]); + offset += ULP_BLOB_BYTE; + len -= ULP_BLOB_BYTE; + } + + /* Extract the last reminder data that is not 8 byte boundary */ + if (len) + ulp_bs_get_lsb(src, offset, len, &dst[size - 1 - idx]); +} + +/* + * Extract data from the binary blob using given offset. + * + * blob [in] The blob that data is extracted from. The blob must + * be initialized prior to pulling data. + * + * data [in] A pointer to put the data. + * data_size [in] size of the data buffer in bytes. + *offset [in] - Offset in the blob to extract the data in bits format. + * len [in] The number of bits to be pulled from the blob. + * + * Output: zero on success, -1 on failure + */ +int32_t +ulp_blob_pull(struct ulp_blob *blob, uint8_t *data, uint32_t data_size, + uint16_t offset, uint16_t len) +{ + /* validate the arguments */ + if (!blob || (offset + len) > blob->bitlen || + ULP_BYTE_2_BITS(data_size) < len) { + BNXT_TF_DBG(ERR, "invalid argument\n"); + return -1; /* failure */ + } + + if (blob->byte_order == BNXT_ULP_BYTE_ORDER_BE) { + BNXT_TF_DBG(ERR, "Big endian pull not implemented\n"); + return -1; /* failure */ + } + ulp_bs_pull_lsb(blob->data, data, data_size, offset, len); + return 0; +} + /* * Get the data portion of the binary blob. * diff --git a/drivers/net/bnxt/tf_ulp/ulp_utils.h b/drivers/net/bnxt/tf_ulp/ulp_utils.h index 97c7750..22dfb17 100644 --- a/drivers/net/bnxt/tf_ulp/ulp_utils.h +++ b/drivers/net/bnxt/tf_ulp/ulp_utils.h @@ -229,6 +229,23 @@ ulp_blob_data_get(struct ulp_blob *blob, uint16_t *datalen); /* + * Extract data from the binary blob using given offset. + * + * blob [in] The blob that data is extracted from. The blob must + * be initialized prior to pulling data. + * + * data [in] A pointer to put the data. + * data_size [in] size of the data buffer in bytes. + *offset [in] - Offset in the blob to extract the data in bits format. + * len [in] The number of bits to be pulled from the blob. + * + * Output: zero on success, -1 on failure + */ +int32_t +ulp_blob_pull(struct ulp_blob *blob, uint8_t *data, uint32_t data_size, + uint16_t offset, uint16_t len); + +/* * Adds pad to an initialized blob at the current offset * * blob [in] The blob that data is added to. The blob must From patchwork Wed Jul 15 13:50:34 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Somnath Kotur X-Patchwork-Id: 74106 X-Patchwork-Delegate: ajit.khaparde@broadcom.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 36A55A0527; Wed, 15 Jul 2020 15:56:48 +0200 (CEST) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id C74881BF46; Wed, 15 Jul 2020 15:56:02 +0200 (CEST) Received: from relay.smtp.broadcom.com (relay.smtp.broadcom.com [192.19.211.62]) by dpdk.org (Postfix) with ESMTP id B81151B952 for ; Wed, 15 Jul 2020 15:55:52 +0200 (CEST) Received: from dhcp-10-123-153-55.dhcp.broadcom.net (dhcp-10-123-153-55.dhcp.broadcom.net [10.123.153.55]) by relay.smtp.broadcom.com (Postfix) with ESMTP id E3EEA299E1E; Wed, 15 Jul 2020 06:55:51 -0700 (PDT) DKIM-Filter: OpenDKIM Filter v2.10.3 relay.smtp.broadcom.com E3EEA299E1E DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=broadcom.com; s=dkimrelay; t=1594821352; bh=nH+XDLYQKQyAzRFaFY591fMA7PLhJCKmqLelOl8NZHA=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=ekkrTsOZP7qiK3maHJp5n9O/vogX1M+pX+mEcz9gC48cAxVgvJrsHCZ/qiRRTKIYC kQ0ZKtTG5i4VhO6NCHwx+e8FWU0hA01CPRD34fCvlw6CN0WSdOzJFWL8V0SW03iU8c eSLYCb6luMER3WrBhoQEECNsrxeX6LwlaYrMi7RA= From: Somnath Kotur To: dev@dpdk.org Cc: ferruh.yigit@intel.com Date: Wed, 15 Jul 2020 19:20:34 +0530 Message-Id: <20200715135038.16662-7-somnath.kotur@broadcom.com> X-Mailer: git-send-email 2.10.1.613.g2cc2e70 In-Reply-To: <20200715135038.16662-1-somnath.kotur@broadcom.com> References: <20200713061600.19456-1-somnath.kotur@broadcom.com> <20200715135038.16662-1-somnath.kotur@broadcom.com> Subject: [dpdk-dev] [PATCH 06/10] net/bnxt: ignore ipv4 TOS mask X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" From: Kishore Padmanabha This is a work around for the OVS setting offload rules that are passing ipv4 tos mask as wild card and currently we do not support. Signed-off-by: Kishore Padmanabha Reviewed-by: Somnath Kotur Signed-off-by: Somnath Kotur --- drivers/net/bnxt/tf_ulp/ulp_rte_parser.c | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/drivers/net/bnxt/tf_ulp/ulp_rte_parser.c b/drivers/net/bnxt/tf_ulp/ulp_rte_parser.c index b943465..63f4c17 100644 --- a/drivers/net/bnxt/tf_ulp/ulp_rte_parser.c +++ b/drivers/net/bnxt/tf_ulp/ulp_rte_parser.c @@ -704,9 +704,19 @@ ulp_rte_ipv4_hdr_handler(const struct rte_flow_item *item, ulp_rte_prsr_mask_copy(params, &idx, &ipv4_mask->hdr.version_ihl, sizeof(ipv4_mask->hdr.version_ihl)); +#ifdef ULP_DONT_IGNORE_TOS ulp_rte_prsr_mask_copy(params, &idx, &ipv4_mask->hdr.type_of_service, sizeof(ipv4_mask->hdr.type_of_service)); +#else + /* + * 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. + */ + idx += 1; +#endif + ulp_rte_prsr_mask_copy(params, &idx, &ipv4_mask->hdr.total_length, sizeof(ipv4_mask->hdr.total_length)); From patchwork Wed Jul 15 13:50:35 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Somnath Kotur X-Patchwork-Id: 74108 X-Patchwork-Delegate: ajit.khaparde@broadcom.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 20A72A0527; Wed, 15 Jul 2020 15:57:10 +0200 (CEST) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id EB5E31BF70; Wed, 15 Jul 2020 15:56:05 +0200 (CEST) Received: from relay.smtp.broadcom.com (relay.smtp.broadcom.com [192.19.211.62]) by dpdk.org (Postfix) with ESMTP id 183981BEA5 for ; Wed, 15 Jul 2020 15:55:53 +0200 (CEST) Received: from dhcp-10-123-153-55.dhcp.broadcom.net (dhcp-10-123-153-55.dhcp.broadcom.net [10.123.153.55]) by relay.smtp.broadcom.com (Postfix) with ESMTP id 3A1AF299E20; Wed, 15 Jul 2020 06:55:52 -0700 (PDT) DKIM-Filter: OpenDKIM Filter v2.10.3 relay.smtp.broadcom.com 3A1AF299E20 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=broadcom.com; s=dkimrelay; t=1594821352; bh=vvYmaqEQnajmiW4EOZHU3Df561iVn/mrEay/dmGKIoQ=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=FkCsbJ6EP6EbYcL9X5GXVeIrlwwOoWUldvjctffaD2EVqWIdHUhee40qIpQxxHzC9 hpXuf9LonS7MJF0Oy0e/i9glkM5tbB1f+OfJiY89psQLSZ5HQVO9IDSqa37gYLFhOs +8yw9d4xqmJGRQESr+q2BJ81NfYQOHf35NnlcfdY= From: Somnath Kotur To: dev@dpdk.org Cc: ferruh.yigit@intel.com Date: Wed, 15 Jul 2020 19:20:35 +0530 Message-Id: <20200715135038.16662-8-somnath.kotur@broadcom.com> X-Mailer: git-send-email 2.10.1.613.g2cc2e70 In-Reply-To: <20200715135038.16662-1-somnath.kotur@broadcom.com> References: <20200713061600.19456-1-somnath.kotur@broadcom.com> <20200715135038.16662-1-somnath.kotur@broadcom.com> Subject: [dpdk-dev] [PATCH 07/10] net/bnxt: add support for identifier search and ref count X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" From: Kishore Padmanabha Add support to search for identifiers and increase the reference count for identifiers that are already allocated. Signed-off-by: Kishore Padmanabha Reviewed-by: Michael Baucom Signed-off-by: Somnath Kotur --- drivers/net/bnxt/tf_ulp/ulp_mapper.c | 117 ++++++++++++++++++++++++++++++++++- 1 file changed, 114 insertions(+), 3 deletions(-) diff --git a/drivers/net/bnxt/tf_ulp/ulp_mapper.c b/drivers/net/bnxt/tf_ulp/ulp_mapper.c index 86858b8..051a095 100644 --- a/drivers/net/bnxt/tf_ulp/ulp_mapper.c +++ b/drivers/net/bnxt/tf_ulp/ulp_mapper.c @@ -16,6 +16,7 @@ #include "ulp_mark_mgr.h" #include "ulp_flow_db.h" #include "ulp_mapper.h" +#include "tf_util.h" static struct bnxt_ulp_glb_resource_info * ulp_mapper_glb_resource_info_list_get(uint32_t *num_entries) @@ -677,6 +678,101 @@ ulp_mapper_ident_process(struct bnxt_ulp_mapper_parms *parms, return rc; } +/* + * Process the identifier instruction and extract it from result blob. + * Increment the identifier reference count and store it in the flow database. + */ +static int32_t +ulp_mapper_ident_extract(struct bnxt_ulp_mapper_parms *parms, + struct bnxt_ulp_mapper_tbl_info *tbl, + struct bnxt_ulp_mapper_ident_info *ident, + struct ulp_blob *res_blob) +{ + struct ulp_flow_db_res_params fid_parms; + uint64_t id = 0; + uint32_t idx; + struct tf_search_identifier_parms sparms = { 0 }; + struct tf_free_identifier_parms free_parms = { 0 }; + struct tf *tfp; + int rc; + + /* Get the tfp from ulp context */ + tfp = bnxt_ulp_cntxt_tfp_get(parms->ulp_ctx); + if (!tfp) { + BNXT_TF_DBG(ERR, "Failed to get tf pointer\n"); + return -EINVAL; + } + + /* Extract the index from the result blob */ + rc = ulp_blob_pull(res_blob, (uint8_t *)&idx, sizeof(idx), + ident->ident_bit_pos, ident->ident_bit_size); + if (rc) { + BNXT_TF_DBG(ERR, "Failed to extract identifier from blob\n"); + return -EIO; + } + + /* populate the search params and search identifier shadow table */ + sparms.ident_type = ident->ident_type; + sparms.dir = tbl->direction; + /* convert the idx into cpu format */ + sparms.search_id = tfp_be_to_cpu_32(idx); + + /* Search identifier also increase the reference count */ + rc = tf_search_identifier(tfp, &sparms); + if (rc) { + BNXT_TF_DBG(ERR, "Search ident %s:%x failed.\n", + tf_dir_2_str(sparms.dir), + sparms.search_id); + return rc; + } + BNXT_TF_DBG(INFO, "Search ident %s:%x.success.\n", + tf_dir_2_str(sparms.dir), + sparms.search_id); + + /* Write it to the regfile */ + id = (uint64_t)tfp_cpu_to_be_64(sparms.search_id); + if (!ulp_regfile_write(parms->regfile, ident->regfile_idx, id)) { + BNXT_TF_DBG(ERR, "Regfile[%d] write failed.\n", idx); + rc = -EINVAL; + /* Need to free the identifier, so goto error */ + goto error; + } + + /* Link the resource to the flow in the flow db */ + memset(&fid_parms, 0, sizeof(fid_parms)); + fid_parms.direction = tbl->direction; + fid_parms.resource_func = ident->resource_func; + fid_parms.resource_type = ident->ident_type; + fid_parms.resource_hndl = sparms.search_id; + fid_parms.critical_resource = BNXT_ULP_CRITICAL_RESOURCE_NO; + rc = ulp_flow_db_resource_add(parms->ulp_ctx, + parms->tbl_idx, + parms->fid, + &fid_parms); + if (rc) { + BNXT_TF_DBG(ERR, "Failed to link res to flow rc = %d\n", + rc); + /* Need to free the identifier, so goto error */ + goto error; + } + +#ifdef RTE_LIBRTE_BNXT_TRUFLOW_DEBUG + ulp_mapper_ident_field_dump("Ident", ident, tbl, sparms.search_id); +#endif + return 0; + +error: + /* Need to free the identifier */ + free_parms.dir = tbl->direction; + free_parms.ident_type = ident->ident_type; + free_parms.id = sparms.search_id; + (void)tf_free_identifier(tfp, &free_parms); + BNXT_TF_DBG(ERR, "Ident extract failed for %s:%s:%x\n", + ident->description, + tf_dir_2_str(tbl->direction), sparms.search_id); + return rc; +} + static int32_t ulp_mapper_result_field_process(struct bnxt_ulp_mapper_parms *parms, enum tf_dir dir, @@ -1204,6 +1300,7 @@ ulp_mapper_tcam_tbl_process(struct bnxt_ulp_mapper_parms *parms, struct tf_free_tcam_entry_parms free_parms = { 0 }; uint32_t hit = 0; uint16_t tmplen = 0; + struct ulp_blob res_blob; /* Skip this if was handled by the cache. */ if (parms->tcam_tbl_opc == BNXT_ULP_MAPPER_TCAM_TBL_OPC_CACHE_SKIP) { @@ -1379,9 +1476,23 @@ ulp_mapper_tcam_tbl_process(struct bnxt_ulp_mapper_parms *parms, goto error; } else { - BNXT_TF_DBG(ERR, "Not supporting search before alloc now\n"); - rc = -EINVAL; - goto error; + struct bnxt_ulp_mapper_ident_info *idents; + uint32_t num_idents; + + /* + * Extract the listed identifiers from the result field, + * no need to allocate them. + */ + idents = ulp_mapper_ident_fields_get(tbl, &num_idents); + for (i = 0; i < num_idents; i++) { + rc = ulp_mapper_ident_extract(parms, tbl, + &idents[i], &res_blob); + if (rc) { + BNXT_TF_DBG(ERR, + "Error in ident extraction\n"); + goto error; + } + } } /* From patchwork Wed Jul 15 13:50:36 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Somnath Kotur X-Patchwork-Id: 74107 X-Patchwork-Delegate: ajit.khaparde@broadcom.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 6FC75A0527; Wed, 15 Jul 2020 15:56:58 +0200 (CEST) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 8223C1BF67; Wed, 15 Jul 2020 15:56:04 +0200 (CEST) Received: from relay.smtp.broadcom.com (unknown [192.19.211.62]) by dpdk.org (Postfix) with ESMTP id ED1011BE9C for ; Wed, 15 Jul 2020 15:55:52 +0200 (CEST) Received: from dhcp-10-123-153-55.dhcp.broadcom.net (dhcp-10-123-153-55.dhcp.broadcom.net [10.123.153.55]) by relay.smtp.broadcom.com (Postfix) with ESMTP id 84832299E2F; Wed, 15 Jul 2020 06:55:52 -0700 (PDT) DKIM-Filter: OpenDKIM Filter v2.10.3 relay.smtp.broadcom.com 84832299E2F DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=broadcom.com; s=dkimrelay; t=1594821352; bh=9akbn+tHx0680mECp41iDU9rLag1k8nKDjiwxDqsJTM=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=qE7y9SgrBL8LwMAI03isPyXW2itMGpNnzsqsqGsdEJHj9B9P5UpNKIPQNphfowi8j Q3Xa0QpOsnT2xSoUutdEMidfnMal0946Ke0vt9ZvxytlCVYHRVd0kQpjUaMSb91Zuy BD+CqvATtnXTZNaZz2mSPTIaaQRvKDftHyJTSePM= From: Somnath Kotur To: dev@dpdk.org Cc: ferruh.yigit@intel.com Date: Wed, 15 Jul 2020 19:20:36 +0530 Message-Id: <20200715135038.16662-9-somnath.kotur@broadcom.com> X-Mailer: git-send-email 2.10.1.613.g2cc2e70 In-Reply-To: <20200715135038.16662-1-somnath.kotur@broadcom.com> References: <20200713061600.19456-1-somnath.kotur@broadcom.com> <20200715135038.16662-1-somnath.kotur@broadcom.com> Subject: [dpdk-dev] [PATCH 08/10] net/bnxt: consider VLAN fields for template match criteria X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" From: Kishore Padmanabha The vlan mask fields were not setting the field bitmap causing the template match process to ignore vlan fields. This change fixes this bug. Signed-off-by: Kishore Padmanabha Reviewed-by: Michael Baucom Signed-off-by: Somnath Kotur --- drivers/net/bnxt/tf_ulp/ulp_rte_parser.c | 34 +++++++++++++++++++++++--------- 1 file changed, 25 insertions(+), 9 deletions(-) diff --git a/drivers/net/bnxt/tf_ulp/ulp_rte_parser.c b/drivers/net/bnxt/tf_ulp/ulp_rte_parser.c index 63f4c17..68e59c4 100644 --- a/drivers/net/bnxt/tf_ulp/ulp_rte_parser.c +++ b/drivers/net/bnxt/tf_ulp/ulp_rte_parser.c @@ -12,6 +12,11 @@ #include "tfp.h" #include "ulp_port_db.h" +/* Local defines for the parsing functions */ +#define ULP_VLAN_PRIORITY_SHIFT 13 /* First 3 bits */ +#define ULP_VLAN_PRIORITY_MASK 0x700 +#define ULP_VLAN_TAG_MASK 0xFFF /* Last 12 bits*/ + /* Utility function to skip the void items. */ static inline int32_t ulp_rte_item_skip_void(const struct rte_flow_item **item, uint32_t increment) @@ -545,8 +550,8 @@ ulp_rte_vlan_hdr_handler(const struct rte_flow_item *item, */ if (vlan_spec) { vlan_tag = ntohs(vlan_spec->tci); - priority = htons(vlan_tag >> 13); - vlan_tag &= 0xfff; + 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], @@ -562,16 +567,27 @@ ulp_rte_vlan_hdr_handler(const struct rte_flow_item *item, if (vlan_mask) { vlan_tag = ntohs(vlan_mask->tci); - priority = htons(vlan_tag >> 13); + priority = htons(vlan_tag >> ULP_VLAN_PRIORITY_SHIFT); vlan_tag &= 0xfff; + + /* + * the storage for priority and vlan tag is 2 bytes + * The mask of priority which is 3 bits if it is all 1's + * 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); - field = ¶ms->hdr_field[idx]; - memcpy(field->mask, &priority, field->size); - field++; - memcpy(field->mask, &vlan_tag, field->size); - field++; - memcpy(field->mask, &vlan_mask->inner_type, field->size); + ulp_rte_prsr_mask_copy(params, &idx, &priority, + sizeof(priority)); + 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)); } /* Set the vlan index to new incremented value */ params->vlan_idx += BNXT_ULP_PROTO_HDR_S_VLAN_NUM; From patchwork Wed Jul 15 13:50:37 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Somnath Kotur X-Patchwork-Id: 74109 X-Patchwork-Delegate: ajit.khaparde@broadcom.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 0C659A0527; Wed, 15 Jul 2020 15:57:21 +0200 (CEST) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id B81881BF75; Wed, 15 Jul 2020 15:56:07 +0200 (CEST) Received: from relay.smtp.broadcom.com (relay.smtp.broadcom.com [192.19.211.62]) by dpdk.org (Postfix) with ESMTP id 4B67C4C8A for ; Wed, 15 Jul 2020 15:55:53 +0200 (CEST) Received: from dhcp-10-123-153-55.dhcp.broadcom.net (dhcp-10-123-153-55.dhcp.broadcom.net [10.123.153.55]) by relay.smtp.broadcom.com (Postfix) with ESMTP id CF8FE299E3E; Wed, 15 Jul 2020 06:55:52 -0700 (PDT) DKIM-Filter: OpenDKIM Filter v2.10.3 relay.smtp.broadcom.com CF8FE299E3E DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=broadcom.com; s=dkimrelay; t=1594821353; bh=ny2KK8kTkrq2Q0Fh0xl/rruesZ+2RrQvOBNSfJ8+Jcs=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=l+VIUs6U/TPWHQYztwhr8HtLKkIi3e3q2zizcnOpCsXWCmRt+SOjw1wsTnQAI31bx MdPdgCaRujiso9cL57CvVoJjF0BQPpbCLmYLJxc8rdW2IXDFmQ9oMvPJ2drYZABwkd z+WKaReEWGF+1Si0pE1/um/T7X9u/q0j3s5d9mHc= From: Somnath Kotur To: dev@dpdk.org Cc: ferruh.yigit@intel.com Date: Wed, 15 Jul 2020 19:20:37 +0530 Message-Id: <20200715135038.16662-10-somnath.kotur@broadcom.com> X-Mailer: git-send-email 2.10.1.613.g2cc2e70 In-Reply-To: <20200715135038.16662-1-somnath.kotur@broadcom.com> References: <20200713061600.19456-1-somnath.kotur@broadcom.com> <20200715135038.16662-1-somnath.kotur@broadcom.com> Subject: [dpdk-dev] [PATCH 09/10] net/bnxt: increase the number of egress flow entries X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" From: Kishore Padmanabha Increase the number of egress flow entries. Signed-off-by: Kishore Padmanabha Reviewed-by: Michael Baucom Reviewed-by: Ajit Kumar Khaparde Signed-off-by: Somnath Kotur --- drivers/net/bnxt/tf_ulp/bnxt_ulp.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/drivers/net/bnxt/tf_ulp/bnxt_ulp.c b/drivers/net/bnxt/tf_ulp/bnxt_ulp.c index 397d0a9..6b0a403 100644 --- a/drivers/net/bnxt/tf_ulp/bnxt_ulp.c +++ b/drivers/net/bnxt/tf_ulp/bnxt_ulp.c @@ -127,7 +127,7 @@ ulp_ctx_session_open(struct bnxt *bp, resources->tcam_cnt[TF_DIR_TX].cnt[TF_TCAM_TBL_TYPE_WC_TCAM] = 8; /* EM */ - resources->em_cnt[TF_DIR_TX].cnt[TF_EM_TBL_TYPE_EM_RECORD] = 8; + resources->em_cnt[TF_DIR_TX].cnt[TF_EM_TBL_TYPE_EM_RECORD] = 2048; /* EEM */ resources->em_cnt[TF_DIR_TX].cnt[TF_EM_TBL_TYPE_TBL_SCOPE] = 1; From patchwork Wed Jul 15 13:50:38 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Somnath Kotur X-Patchwork-Id: 74110 X-Patchwork-Delegate: ajit.khaparde@broadcom.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 36F4CA0527; Wed, 15 Jul 2020 15:57:31 +0200 (CEST) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 3D3BF1BF7D; Wed, 15 Jul 2020 15:56:10 +0200 (CEST) Received: from relay.smtp.broadcom.com (relay.smtp.broadcom.com [192.19.211.62]) by dpdk.org (Postfix) with ESMTP id 960981B952 for ; Wed, 15 Jul 2020 15:55:53 +0200 (CEST) Received: from dhcp-10-123-153-55.dhcp.broadcom.net (dhcp-10-123-153-55.dhcp.broadcom.net [10.123.153.55]) by relay.smtp.broadcom.com (Postfix) with ESMTP id 2F166299E4A; Wed, 15 Jul 2020 06:55:53 -0700 (PDT) DKIM-Filter: OpenDKIM Filter v2.10.3 relay.smtp.broadcom.com 2F166299E4A DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=broadcom.com; s=dkimrelay; t=1594821353; bh=jm8p+sLFEJcddlNx25Aa4hwhdKIVw3jTiwCg2EjLepM=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=ftv4JPy8dBDUYnlZr7/3vpMeKWjFPyUstULw3BbvcZdO4vi8URi5ENoO1aW1yz5OK A+CRiHEDg7n759yf3KBsGLpbBdI9r1Q7vXZ6k0fltSOPp+esn4VoDnLwqlpmAFRxrZ mN356t86aN+OGG10NZtqE9oO4ufRlRm4ergfQm3A= From: Somnath Kotur To: dev@dpdk.org Cc: ferruh.yigit@intel.com Date: Wed, 15 Jul 2020 19:20:38 +0530 Message-Id: <20200715135038.16662-11-somnath.kotur@broadcom.com> X-Mailer: git-send-email 2.10.1.613.g2cc2e70 In-Reply-To: <20200715135038.16662-1-somnath.kotur@broadcom.com> References: <20200713061600.19456-1-somnath.kotur@broadcom.com> <20200715135038.16662-1-somnath.kotur@broadcom.com> Subject: [dpdk-dev] [PATCH 10/10] net/bnxt: add support for decrement TTL action X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" From: Kishore Padmanabha Added support for decrement TTL action. Signed-off-by: Kishore Padmanabha Reviewed-by: Michael Baucom Signed-off-by: Somnath Kotur --- drivers/net/bnxt/tf_ulp/ulp_rte_parser.c | 30 +++++++++++++++++++++++++++ drivers/net/bnxt/tf_ulp/ulp_rte_parser.h | 5 +++++ drivers/net/bnxt/tf_ulp/ulp_template_db_tbl.c | 4 ++-- 3 files changed, 37 insertions(+), 2 deletions(-) diff --git a/drivers/net/bnxt/tf_ulp/ulp_rte_parser.c b/drivers/net/bnxt/tf_ulp/ulp_rte_parser.c index 68e59c4..4c1221a 100644 --- a/drivers/net/bnxt/tf_ulp/ulp_rte_parser.c +++ b/drivers/net/bnxt/tf_ulp/ulp_rte_parser.c @@ -189,6 +189,26 @@ bnxt_ulp_rte_parser_post_process(struct ulp_rte_parser_params *params) match_port_type == BNXT_ULP_INTF_TYPE_VF_REP) ULP_COMP_FLD_IDX_WR(params, BNXT_ULP_CF_IDX_VF_TO_VF, 1); + /* Update the decrement ttl computational fields */ + if (ULP_BITMAP_ISSET(params->act_bitmap.bits, + BNXT_ULP_ACTION_BIT_DEC_TTL)) { + /* + * Check that vxlan proto is included and vxlan decap + * action is not set then decrement tunnel ttl. + * Similarly add GRE and NVGRE in future. + */ + 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))) { + ULP_COMP_FLD_IDX_WR(params, + BNXT_ULP_CF_IDX_ACT_T_DEC_TTL, 1); + } else { + ULP_COMP_FLD_IDX_WR(params, + BNXT_ULP_CF_IDX_ACT_DEC_TTL, 1); + } + } + /* TBD: Handle the flow rejection scenarios */ return 0; } @@ -1814,3 +1834,13 @@ ulp_rte_set_tp_dst_act_handler(const struct rte_flow_action *action_item, BNXT_TF_DBG(ERR, "Parse Error: set tp src arg is invalid\n"); return BNXT_TF_RC_ERROR; } + +/* Function to handle the parsing of RTE Flow action dec ttl.*/ +int32_t +ulp_rte_dec_ttl_act_handler(const struct rte_flow_action *act __rte_unused, + 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); + return BNXT_TF_RC_SUCCESS; +} diff --git a/drivers/net/bnxt/tf_ulp/ulp_rte_parser.h b/drivers/net/bnxt/tf_ulp/ulp_rte_parser.h index e155250..7b6b57e 100644 --- a/drivers/net/bnxt/tf_ulp/ulp_rte_parser.h +++ b/drivers/net/bnxt/tf_ulp/ulp_rte_parser.h @@ -216,4 +216,9 @@ int32_t ulp_rte_set_tp_dst_act_handler(const struct rte_flow_action *action_item, struct ulp_rte_parser_params *params); +/* Function to handle the parsing of RTE Flow action dec ttl.*/ +int32_t +ulp_rte_dec_ttl_act_handler(const struct rte_flow_action *action_item, + struct ulp_rte_parser_params *params); + #endif /* _ULP_RTE_PARSER_H_ */ diff --git a/drivers/net/bnxt/tf_ulp/ulp_template_db_tbl.c b/drivers/net/bnxt/tf_ulp/ulp_template_db_tbl.c index 5847e58..9a27cbf 100644 --- a/drivers/net/bnxt/tf_ulp/ulp_template_db_tbl.c +++ b/drivers/net/bnxt/tf_ulp/ulp_template_db_tbl.c @@ -259,8 +259,8 @@ struct bnxt_ulp_rte_act_info ulp_act_info[] = { .proto_act_func = NULL }, [RTE_FLOW_ACTION_TYPE_DEC_TTL] = { - .act_type = BNXT_ULP_ACT_TYPE_NOT_SUPPORTED, - .proto_act_func = NULL + .act_type = BNXT_ULP_ACT_TYPE_SUPPORTED, + .proto_act_func = ulp_rte_dec_ttl_act_handler }, [RTE_FLOW_ACTION_TYPE_SET_TTL] = { .act_type = BNXT_ULP_ACT_TYPE_NOT_SUPPORTED,