From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 7EF30A059F; Fri, 10 Apr 2020 16:40:33 +0200 (CEST) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id DD44F1D57E; Fri, 10 Apr 2020 16:40:29 +0200 (CEST) Received: from mga02.intel.com (mga02.intel.com [134.134.136.20]) by dpdk.org (Postfix) with ESMTP id A9F451D578 for ; Fri, 10 Apr 2020 16:40:27 +0200 (CEST) IronPort-SDR: RfgLJtp9R4NC1NuDkoW7hgxV9KS7Y6x5LAO/Qbm3APPB0oBS+OgV+Trm8xEnWGnLissoBxQSZ0 mM0XP4/i7BiQ== X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from fmsmga007.fm.intel.com ([10.253.24.52]) by orsmga101.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 10 Apr 2020 07:40:27 -0700 IronPort-SDR: FXcSZfpgH6dGK/ti46qTcyQ5euvjHeRXE2HmDLhZdyqXjhkPhturPZ0s4zWLkvGY2brz7KSyIF Wrp0oD/w+5mQ== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.72,367,1580803200"; d="scan'208";a="242938903" Received: from silpixa00399912.ir.intel.com (HELO silpixa00399912.ger.corp.intel.com) ([10.237.223.64]) by fmsmga007.fm.intel.com with ESMTP; 10 Apr 2020 07:40:24 -0700 From: David Coyle To: dev@dpdk.org Cc: declan.doherty@intel.com, fiona.trahe@intel.com, pablo.de.lara.guarch@intel.com, brendan.ryan@intel.com, shreyansh.jain@nxp.com, hemant.agrawal@nxp.com, akhil.goyal@nxp.com, ferruh.yigit@intel.com, David Coyle , Mairtin o Loingsigh Date: Fri, 10 Apr 2020 15:27:54 +0100 Message-Id: <20200410142757.31508-2-david.coyle@intel.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20200410142757.31508-1-david.coyle@intel.com> References: <20200410142757.31508-1-david.coyle@intel.com> Subject: [dpdk-dev] [PATCH v3 1/4] raw/common: add multi-function interface 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" The multi-function interface provides a way of combining one or more different types of packet processing functions into a single operation. The interface can be used by applications to send the combined operations to a optimized software or hardware accelerator via a raw device. Signed-off-by: David Coyle Signed-off-by: Mairtin o Loingsigh --- config/common_base | 5 + drivers/meson.build | 5 + drivers/raw/Makefile | 1 + drivers/raw/common/Makefile | 8 + drivers/raw/common/meson.build | 7 + drivers/raw/common/multi_fn/Makefile | 27 ++ drivers/raw/common/multi_fn/meson.build | 9 + .../multi_fn/rte_common_multi_fn_version.map | 12 + drivers/raw/common/multi_fn/rte_multi_fn.c | 148 ++++++ drivers/raw/common/multi_fn/rte_multi_fn.h | 438 ++++++++++++++++++ .../raw/common/multi_fn/rte_multi_fn_driver.h | 97 ++++ meson.build | 4 + mk/rte.app.mk | 1 + 13 files changed, 762 insertions(+) create mode 100644 drivers/raw/common/Makefile create mode 100644 drivers/raw/common/meson.build create mode 100644 drivers/raw/common/multi_fn/Makefile create mode 100644 drivers/raw/common/multi_fn/meson.build create mode 100644 drivers/raw/common/multi_fn/rte_common_multi_fn_version.map create mode 100644 drivers/raw/common/multi_fn/rte_multi_fn.c create mode 100644 drivers/raw/common/multi_fn/rte_multi_fn.h create mode 100644 drivers/raw/common/multi_fn/rte_multi_fn_driver.h diff --git a/config/common_base b/config/common_base index c31175f9d..27111c24c 100644 --- a/config/common_base +++ b/config/common_base @@ -818,6 +818,11 @@ CONFIG_RTE_LIBRTE_PMD_OCTEONTX2_EP_RAWDEV=y # CONFIG_RTE_LIBRTE_PMD_NTB_RAWDEV=y +# +# Compile multi-fn raw device interface +# +CONFIG_RTE_LIBRTE_MULTI_FN_COMMON=y + # # Compile librte_ring # diff --git a/drivers/meson.build b/drivers/meson.build index 5502bf992..4e0caeff3 100644 --- a/drivers/meson.build +++ b/drivers/meson.build @@ -10,6 +10,7 @@ dpdk_driver_classes = ['common', 'bus', 'mempool', # depends on common and bus. 'net', # depends on common, bus, mempool + 'raw/common', 'raw', # depends on common, bus and net. 'crypto', # depends on common, bus and mempool (net in future). 'compress', # depends on common, bus, mempool. @@ -212,5 +213,9 @@ foreach class:dpdk_driver_classes endif # build endforeach + if class.contains('/') + class_split = class.split('/') + class = '_'.join(class_split) + endif set_variable(class + '_drivers', class_drivers) endforeach diff --git a/drivers/raw/Makefile b/drivers/raw/Makefile index 80b043eb1..e16da8d95 100644 --- a/drivers/raw/Makefile +++ b/drivers/raw/Makefile @@ -14,5 +14,6 @@ DIRS-$(CONFIG_RTE_LIBRTE_PMD_IOAT_RAWDEV) += ioat DIRS-$(CONFIG_RTE_LIBRTE_PMD_NTB_RAWDEV) += ntb DIRS-$(CONFIG_RTE_LIBRTE_PMD_OCTEONTX2_DMA_RAWDEV) += octeontx2_dma DIRS-$(CONFIG_RTE_LIBRTE_PMD_OCTEONTX2_EP_RAWDEV) += octeontx2_ep +DIRS-y += common include $(RTE_SDK)/mk/rte.subdir.mk diff --git a/drivers/raw/common/Makefile b/drivers/raw/common/Makefile new file mode 100644 index 000000000..5c9ad399f --- /dev/null +++ b/drivers/raw/common/Makefile @@ -0,0 +1,8 @@ +# SPDX-License-Identifier: BSD-3-Clause +# Copyright(c) 2020 Intel Corporation. + +include $(RTE_SDK)/mk/rte.vars.mk + +DIRS-$(CONFIG_RTE_LIBRTE_MULTI_FN_COMMON) += multi_fn + +include $(RTE_SDK)/mk/rte.subdir.mk diff --git a/drivers/raw/common/meson.build b/drivers/raw/common/meson.build new file mode 100644 index 000000000..1a8334348 --- /dev/null +++ b/drivers/raw/common/meson.build @@ -0,0 +1,7 @@ +# SPDX-License-Identifier: BSD-3-Clause +# Copyright(c) 2020 Intel Corporation. + +drivers = ['multi_fn'] +std_deps = ['rawdev'] +config_flag_fmt = 'RTE_LIBRTE_@0@_COMMON' +driver_name_fmt = 'rte_common_@0@' diff --git a/drivers/raw/common/multi_fn/Makefile b/drivers/raw/common/multi_fn/Makefile new file mode 100644 index 000000000..7ffbc6bb6 --- /dev/null +++ b/drivers/raw/common/multi_fn/Makefile @@ -0,0 +1,27 @@ +# SPDX-License-Identifier: BSD-3-Clause +# Copyright(c) 2020 Intel Corporation. + +include $(RTE_SDK)/mk/rte.vars.mk + +# library name +LIB = librte_multi_fn.a + +# build flags +CFLAGS += -O3 +CFLAGS += $(WERROR_FLAGS) +CFLAGS += -DALLOW_EXPERIMENTAL_API + +# versioning export map +EXPORT_MAP := rte_common_multi_fn_version.map + +# external library dependencies +LDLIBS += -lrte_eal +LDLIBS += -lrte_mempool +LDLIBS += -lrte_rawdev + +SRCS-y += rte_multi_fn.c + +SYMLINK-y-include += rte_multi_fn.h +SYMLINK-y-include += rte_multi_fn_driver.h + +include $(RTE_SDK)/mk/rte.lib.mk diff --git a/drivers/raw/common/multi_fn/meson.build b/drivers/raw/common/multi_fn/meson.build new file mode 100644 index 000000000..587168a0b --- /dev/null +++ b/drivers/raw/common/multi_fn/meson.build @@ -0,0 +1,9 @@ +# SPDX-License-Identifier: BSD-3-Clause +# Copyright(c) 2020 Intel Corporation. + +sources = files('rte_multi_fn.c') + +deps = ['rawdev', 'cryptodev'] +allow_experimental_apis = true + +install_headers('rte_multi_fn.h') diff --git a/drivers/raw/common/multi_fn/rte_common_multi_fn_version.map b/drivers/raw/common/multi_fn/rte_common_multi_fn_version.map new file mode 100644 index 000000000..e52af15e5 --- /dev/null +++ b/drivers/raw/common/multi_fn/rte_common_multi_fn_version.map @@ -0,0 +1,12 @@ +EXPERIMENTAL { + global: + + rte_multi_fn_op_bulk_alloc; + rte_multi_fn_op_free; + rte_multi_fn_op_pool_create; + rte_multi_fn_session_create; + rte_multi_fn_session_destroy; + rte_multi_fn_xstat_names; + + local: *; +}; diff --git a/drivers/raw/common/multi_fn/rte_multi_fn.c b/drivers/raw/common/multi_fn/rte_multi_fn.c new file mode 100644 index 000000000..07e6edecf --- /dev/null +++ b/drivers/raw/common/multi_fn/rte_multi_fn.c @@ -0,0 +1,148 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2020 Intel Corporation. + */ + +#include + +#include "rte_multi_fn_driver.h" +#include "rte_multi_fn.h" + +/* Dynamic log identifier */ +static int multi_fn_logtype; + +/* Logging Macros */ +#define MF_LOG(level, fmt, args...) \ + rte_log(RTE_LOG_ ## level, multi_fn_logtype, \ + "%s() line %u: " fmt "\n", \ + __func__, __LINE__, ##args) +#define MF_DEBUG(fmt, args...) \ + MF_LOG(DEBUG, fmt, ## args) +#define MF_INFO(fmt, args...) \ + MF_LOG(INFO, fmt, ## args) +#define MF_ERR(fmt, args...) \ + MF_LOG(ERR, fmt, ## args) +#define MF_WARN(fmt, args...) \ + MF_LOG(WARNING, fmt, ## args) + +/* Multi-function xstat names */ +const char * +rte_multi_fn_xstat_names[] = { + [RTE_MULTI_FN_XSTAT_ID_SUCCESSFUL_ENQUEUES] = "mfn_successful_enqueues", + [RTE_MULTI_FN_XSTAT_ID_SUCCESSFUL_DEQUEUES] = "mfn_successful_dequeues", + [RTE_MULTI_FN_XSTAT_ID_FAILED_ENQUEUES] = "mfn_failed_enqueues", + [RTE_MULTI_FN_XSTAT_ID_FAILED_DEQUEUES] = "mfn_failed_dequeues" +}; + +static void +multi_fn_op_init(struct rte_mempool *mempool, + __rte_unused void *opaque_arg, + void *op_data, + __rte_unused unsigned int i) +{ + struct rte_multi_fn_op *op = op_data; + + memset(op_data, 0, mempool->elt_size); + + op->overall_status = RTE_MULTI_FN_OP_STATUS_NOT_PROCESSED; + op->mempool = mempool; +} + +struct rte_multi_fn_session * +rte_multi_fn_session_create(uint16_t dev_id, + struct rte_multi_fn_xform *xform, + int socket_id) +{ + struct rte_rawdev *rawdev; + struct rte_rawdev_info info = {0}; + struct rte_multi_fn_ops *mf_ops; + + if (xform == NULL) { + MF_ERR("NULL xform for multi-function session create"); + return NULL; + } + + if (rte_rawdev_info_get(dev_id, &info) < 0) { + MF_ERR("Invalid dev_id=%d", dev_id); + return NULL; + } + + rawdev = &rte_rawdevs[dev_id]; + + mf_ops = *((struct rte_multi_fn_ops **)(rawdev->dev_private)); + + RTE_FUNC_PTR_OR_ERR_RET(*mf_ops->session_create, NULL); + return (*mf_ops->session_create)(rawdev, xform, socket_id); +} + +int +rte_multi_fn_session_destroy(uint16_t dev_id, struct rte_multi_fn_session *sess) +{ + struct rte_rawdev *rawdev; + struct rte_rawdev_info info = {0}; + struct rte_multi_fn_ops *mf_ops; + + if (rte_rawdev_info_get(dev_id, &info) < 0) { + MF_ERR("Invalid dev_id=%d", dev_id); + return -EINVAL; + } + + rawdev = &rte_rawdevs[dev_id]; + + mf_ops = *((struct rte_multi_fn_ops **)(rawdev->dev_private)); + + RTE_FUNC_PTR_OR_ERR_RET(*mf_ops->session_destroy, -ENOTSUP); + return (*mf_ops->session_destroy)(rawdev, sess); +} + +struct rte_mempool * +rte_multi_fn_op_pool_create(const char *name, + uint32_t nb_elts, + uint32_t cache_size, + uint16_t priv_size, + int socket_id) +{ + uint32_t elt_size = sizeof(struct rte_multi_fn_op) + priv_size; + + /* Lookup mempool in case already allocated */ + struct rte_mempool *mp = rte_mempool_lookup(name); + + if (mp != NULL) { + if (mp->elt_size != elt_size || + mp->cache_size < cache_size || + mp->size < nb_elts) { + mp = NULL; + MF_ERR("Mempool %s already exists but with " + "incompatible parameters", + name); + return NULL; + } + + return mp; + } + + mp = rte_mempool_create(name, + nb_elts, + elt_size, + cache_size, + 0, + NULL, + NULL, + multi_fn_op_init, + NULL, + socket_id, + 0); + + if (mp == NULL) { + MF_ERR("Failed to create mempool %s", name); + return NULL; + } + + return mp; +} + +RTE_INIT(rte_multi_fn_log_init) +{ + multi_fn_logtype = rte_log_register("pmd.raw.common.multi_fn"); + if (multi_fn_logtype >= 0) + rte_log_set_level(multi_fn_logtype, RTE_LOG_INFO); +} diff --git a/drivers/raw/common/multi_fn/rte_multi_fn.h b/drivers/raw/common/multi_fn/rte_multi_fn.h new file mode 100644 index 000000000..5aa16b0d5 --- /dev/null +++ b/drivers/raw/common/multi_fn/rte_multi_fn.h @@ -0,0 +1,438 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2020 Intel Corporation. + */ + +#ifndef _RTE_MULTI_FN_H_ +#define _RTE_MULTI_FN_H_ + +/** + * @file rte_multi_fn.h + * + * RTE Multi Function APIs + * + * Defines Multi Function APIs for providing multi-function support to Rawdev + * PMDs + * + * @warning + * @b EXPERIMENTAL: this API may change without prior notice + */ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include +#include + +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice + * + * Error Detection Algorithms + */ +enum rte_multi_fn_err_detect_algorithm { + RTE_MULTI_FN_ERR_DETECT_CRC32_ETH, + /**< CRC32 Ethernet */ + RTE_MULTI_FN_ERR_DETECT_BIP32 + /**< BIP32 */ +}; + +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice + * + * Error Detection Operation Types + */ +enum rte_multi_fn_err_detect_operation { + RTE_MULTI_FN_ERR_DETECT_OP_VERIFY, + /**< Verify error detection result */ + RTE_MULTI_FN_ERR_DETECT_OP_GENERATE + /**< Generate error detection result */ +}; + +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice + * + * Error Detection Status + */ +enum rte_multi_fn_err_detect_op_status { + RTE_MULTI_FN_ERR_DETECT_OP_STATUS_SUCCESS, + /**< Operation completed successfully */ + RTE_MULTI_FN_ERR_DETECT_OP_STATUS_NOT_PROCESSED, + /**< Operation has not yet been processed by a device */ + RTE_MULTI_FN_ERR_DETECT_OP_STATUS_VERIFY_FAILED, + /**< Verification failed */ + RTE_MULTI_FN_ERR_DETECT_OP_STATUS_ERROR + /**< Error handling operation */ +}; + +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice + * + * Error Detection Transform Data + * + * This structure contains data relating to an error detection transform. The + * fields *op* and *algo* are common to all error detection transforms and + * MUST be set + */ +struct rte_multi_fn_err_detect_xform { + enum rte_multi_fn_err_detect_operation op; + /**< Error detection operation type */ + enum rte_multi_fn_err_detect_algorithm algo; + /**< Error detection algorithm */ +}; + +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice + * + * Error Detection Operation + */ +struct rte_multi_fn_err_detect_op { + struct { + uint16_t offset; + /**< + * Starting point for error detection processing, specified + * as the number of bytes from start of the packet in the + * source mbuf + */ + uint16_t length; + /**< + * The length, in bytes, of the source mbuf on which the error + * detection operation will be computed + */ + } data; /**< Data offset and length for error detection */ + + struct { + uint8_t *data; + /**< + * This points to the location where the error detection + * result should be written (in the case of generation) or + * where the purported result exists (in the case of + * verification) + * + * The caller must ensure the required length of physically + * contiguous memory is available at this address + * + * For a CRC, this may point into the mbuf packet data. For + * an operation such as a BIP, this may point to a memory + * location after the op + * + * For generation, the result will overwrite any data at this + * location + */ + rte_iova_t phys_addr; + /**< Physical address of output data */ + } output; /**< Output location */ +}; + +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice + * + * Multi-Function Transform Types + */ +enum rte_multi_fn_xform_type { + RTE_MULTI_FN_XFORM_TYPE_UNDEFINED, + /**< Undefined transform type */ + RTE_MULTI_FN_XFORM_TYPE_CRYPTO_SYM, + /**< Symmetric crypto transform type */ + RTE_MULTI_FN_XFORM_TYPE_ERR_DETECT + /**< Error detection transform type */ +}; + +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice + * + * Multi-Function Transform Data + * + * This structure is used to specify the multi-function transforms required. + * Multiple transforms can be chained together to specify a chain of transforms + * such as symmetric crypto followed by error detection, or vice versa. Each + * transform structure holds a single transform, with the type field specifying + * which transform is contained within the union. + */ +struct rte_multi_fn_xform { + struct rte_multi_fn_xform *next; + /**< + * Next transform in the chain + * - the last transform in the chain MUST set this to NULL + */ + enum rte_multi_fn_xform_type type; + /**< Transform type */ + + RTE_STD_C11 + union { + struct rte_crypto_sym_xform crypto_sym; + /**< Symmetric crypto transform */ + struct rte_multi_fn_err_detect_xform err_detect; + /**< Error detection transform */ + }; +}; + +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice + * + * Multi-Function operation status + */ +enum rte_multi_fn_op_status { + RTE_MULTI_FN_OP_STATUS_SUCCESS, + /**< Operation completed successfully */ + RTE_MULTI_FN_OP_STATUS_NOT_PROCESSED, + /**< Operation has not yet been processed by a device */ + RTE_MULTI_FN_OP_STATUS_FAILURE, + /**< Operation completed with failure */ + RTE_MULTI_FN_STATUS_INVALID_SESSION, + /**< Operation failed due to invalid session arguments */ +}; + +/** + * @internal + * + * Multi-Function session data + */ +struct rte_multi_fn_session; + +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice + * + * Multi-Function operation data + * + * This structure is used to specify the operations for a particular session. + * This includes specifying the source and, if required, destination mbufs and + * the lengths and offsets of the data within these mbufs on which the + * operations should be done. Multiple operations are chained together to + * specify the full set of operations to be performed. + * + * @note The order of the rte_multi_fn_op chain MUST match the order of the + * associated session's xform chain exactly + * @note The first rte_multi_fn_op element in the chain is the parent operation. + * The following fields MUST be set in this first operation before enqueuing and + * are ignored in the inner operations of the union and any subsequent + * rte_multi_fn_op chain elements: + * - *sess* + * - *m_src* + * - *m_dst* (if required) + * @note If *sess* or *m_src* is not set in the first rte_multi_fn_op, this + * operation is invalid and will cause an error when attempting to enqueue. + * @note The following fields MUST be set in ALL rte_multi_fn_op chain elements: + * - *next* + * - *mempool* + * - *type* + * @note After the operation has been dequeued, only the FIRST (i.e. the parent) + * rte_multi_fn_op in the chain will contain the *overall_status*. Each chain + * element will contain it's individual *op_status*, the value of which is + * relevant to the operation type (i.e. an ::rte_crypto_op_status or + * ::rte_multi_fn_err_detect_op_status) + * + */ +struct rte_multi_fn_op { + struct rte_multi_fn_op *next; + /**< + * Next operation in the chain + * - the last operation in the chain MUST set this to NULL + */ + struct rte_multi_fn_session *sess; + /**< Handle for the associated multi fn session */ + + struct rte_mempool *mempool; + /**< Mempool from which the operation is allocated */ + + struct rte_mbuf *m_src; /**< Source mbuf */ + struct rte_mbuf *m_dst; /**< Destination mbuf */ + + enum rte_multi_fn_op_status overall_status; + /**< + * Overall operation status + * - indicates if all the operations in the chain succeeded or if any + * one of them failed + */ + + uint8_t op_status; + /**< + * Individual operation status + * - indicates the status of the individual operation in the chain + */ + + RTE_STD_C11 + union { + struct rte_crypto_sym_op crypto_sym; + /**< Symmetric crypto operation */ + struct rte_multi_fn_err_detect_op err_detect; + /**< Error detection operation */ + }; +}; + +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice + * + * Device information structure + * + * This structure is returned from rte_rawdev_info_get() with information + * about the device + */ +struct rte_multi_fn_dev_info { + uint16_t max_nb_queues; + /**< + * Maximum number of queue pairs that can be configured on the + * device + */ +}; + +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice + * + * Device configuration structure + * + * This structure should be passed to rte_rawdev_configure() to configure + * a device + */ +struct rte_multi_fn_dev_config { + uint16_t nb_queues; /**< Number of queue pairs to configure */ + unsigned int socket_id; /**< Socket to allocate queues on */ +}; + +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice + * + * Queue pair configuration structure + * + * This should be passed to rte_rawdev_queue_setup() to configure a queue pair + */ +struct rte_multi_fn_qp_config { + uint32_t nb_descriptors; /**< Number of descriptors per queue pair */ +}; + +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice + * + * Create multi-function session as specified by the transform chain + * + * @param dev_id The identifier of the device + * @param xform Pointer to the first element of the session transform + * chain + * @param socket_id Socket to allocate the session on + * + * @return + * - Pointer to session, if successful + * - NULL, on failure + */ +__rte_experimental +struct rte_multi_fn_session * +rte_multi_fn_session_create(uint16_t dev_id, + struct rte_multi_fn_xform *xform, + int socket_id); + +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice + * + * Free memory associated with a multi-function session + * + * @param dev_id The identifier of the device + * @param sess Multi-function session to be freed + * + * @return + * - 0, if successful + * - -EINVAL, if session is NULL + * - -EBUSY, if not all session data has been freed + */ +__rte_experimental +int +rte_multi_fn_session_destroy(uint16_t dev_id, + struct rte_multi_fn_session *sess); + +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice + * + * Create a multi-function operation pool + * + * @param name Pool name + * @param nb_elts Number of elements in pool + * @param cache_size Number of elements to cache on lcore, see + * *rte_mempool_create* for further details about + * cache size + * @param priv_size Size of private data to allocate with each + * operation + * @param socket_id Socket to allocate memory on + * + * @return + * - Pointer to mempool, if successful + * - NULL, on failure + */ +__rte_experimental +struct rte_mempool * +rte_multi_fn_op_pool_create(const char *name, + uint32_t nb_elts, + uint32_t cache_size, + uint16_t priv_size, + int socket_id); + +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice + * + * Bulk allocate multi-function operations from a mempool with default + * parameters set + * + * @param mempool Multi-function operation mempool + * @param ops Array to place allocated multi-function operations + * @param nb_ops Number of multi-function operations to allocate + * + * @returns + * - nb_ops, if the number of operations requested were allocated + * - 0, if the requested number of ops are not available. None are allocated in + * this case + */ +__rte_experimental +static inline unsigned +rte_multi_fn_op_bulk_alloc(struct rte_mempool *mempool, + struct rte_multi_fn_op **ops, + uint16_t nb_ops) +{ + int i; + + if (rte_mempool_get_bulk(mempool, (void **)ops, nb_ops) == 0) { + for (i = 0; i < nb_ops; i++) + ops[i]->overall_status = + RTE_MULTI_FN_OP_STATUS_NOT_PROCESSED; + + return nb_ops; + } + + return 0; +} + +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice + * + * Free multi-function operation back to it's mempool + * + * @param op Multi-function operation + */ +__rte_experimental +static inline void +rte_multi_fn_op_free(struct rte_multi_fn_op *op) +{ + if (op != NULL && op->mempool != NULL) + rte_mempool_put(op->mempool, op); +} + +#ifdef __cplusplus +} +#endif + +#endif /* _RTE_MULTI_FN_H_ */ diff --git a/drivers/raw/common/multi_fn/rte_multi_fn_driver.h b/drivers/raw/common/multi_fn/rte_multi_fn_driver.h new file mode 100644 index 000000000..9000f4e00 --- /dev/null +++ b/drivers/raw/common/multi_fn/rte_multi_fn_driver.h @@ -0,0 +1,97 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2020 Intel Corporation. + */ + +#ifndef _RTE_MULTI_FN_DRIVER_H_ +#define _RTE_MULTI_FN_DRIVER_H_ + +/** + * @file rte_multi_fn_driver.h + * + * RTE Multi Function PMD APIs + * + * @note + * These APIs are for rawdev PMDs only which support the multi-function + * interface and user applications should not call them directly. + */ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +#include "rte_multi_fn.h" + +/** Multi-function device name prefix */ +#define RTE_MULTI_FN_DEV_NAME_PREFIX rawdev_mfn_ +/** Multi-function device name prefix string */ +#define RTE_MULTI_FN_DEV_NAME_PREFIX_STR RTE_STR(RTE_MULTI_FN_DEV_NAME_PREFIX) + +#define _CONCAT(x, y) x ## y +#define CONCAT(x, y) _CONCAT(x, y) + +/** Create a full multi-function device name */ +#define RTE_MULTI_FN_DEV_NAME(x) CONCAT(RTE_MULTI_FN_DEV_NAME_PREFIX, x) + +/** + * Multi-function xstat IDs + */ +enum rte_multi_fn_xtsat_id { + RTE_MULTI_FN_XSTAT_ID_SUCCESSFUL_ENQUEUES = 0, + /**< Successful enqueues */ + RTE_MULTI_FN_XSTAT_ID_SUCCESSFUL_DEQUEUES, + /**< Successful dequeues */ + RTE_MULTI_FN_XSTAT_ID_FAILED_ENQUEUES, + /**< Failed enqueues */ + RTE_MULTI_FN_XSTAT_ID_FAILED_DEQUEUES, + /**< Failed dequeues */ + RTE_MULTI_FN_XSTAT_ID_NB + /**< Number of stats */ +}; + +/** + * Multi-function xstat names + */ +extern const char * +rte_multi_fn_xstat_names[]; + +/** + * Multi-function session data + */ +struct rte_multi_fn_session { + void *sess_private_data; +}; + +/** + * Session create function pointer type + */ +typedef struct rte_multi_fn_session *(*multi_fn_session_create_t)( + struct rte_rawdev *, + struct rte_multi_fn_xform *, + int); + +/** + * Session destroy function pointer type + */ +typedef int (*multi_fn_session_destroy_t)(struct rte_rawdev *, + struct rte_multi_fn_session *); + +/** + * Structure containing multi-function ops to create and destroy a session. + * + * This structure MUST be the first element of the device's private data + * structure pointed to by rte_rawdev->dev_private + */ +struct rte_multi_fn_ops { + multi_fn_session_create_t session_create; + /**< Create session function pointer */ + multi_fn_session_destroy_t session_destroy; + /**< Destroy session function pointer */ +}; + +#ifdef __cplusplus +} +#endif + +#endif /* _RTE_MULTI_FN_DRIVER_H_ */ diff --git a/meson.build b/meson.build index d36580438..de952fa98 100644 --- a/meson.build +++ b/meson.build @@ -102,6 +102,10 @@ message(output_message + '\n') output_message = '\n===============\nDrivers Enabled\n===============\n' foreach class:dpdk_driver_classes + if class.contains('/') + class_split = class.split('/') + class = '_'.join(class_split) + endif class_drivers = get_variable(class + '_drivers') output_message += '\n' + class + ':\n\t' output_count = 0 diff --git a/mk/rte.app.mk b/mk/rte.app.mk index d295ca0a5..b836d220d 100644 --- a/mk/rte.app.mk +++ b/mk/rte.app.mk @@ -347,6 +347,7 @@ _LDLIBS-$(CONFIG_RTE_LIBRTE_PMD_IOAT_RAWDEV) += -lrte_rawdev_ioat _LDLIBS-$(CONFIG_RTE_LIBRTE_PMD_NTB_RAWDEV) += -lrte_rawdev_ntb _LDLIBS-$(CONFIG_RTE_LIBRTE_PMD_OCTEONTX2_DMA_RAWDEV) += -lrte_rawdev_octeontx2_dma _LDLIBS-$(CONFIG_RTE_LIBRTE_PMD_OCTEONTX2_EP_RAWDEV) += -lrte_rawdev_octeontx2_ep +_LDLIBS-$(CONFIG_RTE_LIBRTE_MULTI_FN_COMMON) += -lrte_multi_fn endif # CONFIG_RTE_LIBRTE_RAWDEV endif # !CONFIG_RTE_BUILD_SHARED_LIBS -- 2.17.1