[v3,1/4] raw/common: add multi-function interface
diff mbox series

Message ID 20200410142757.31508-2-david.coyle@intel.com
State Superseded
Delegated to: Thomas Monjalon
Headers show
Series
  • add AESNI-MB rawdev for multi-function processing
Related show

Checks

Context Check Description
ci/Intel-compilation success Compilation OK
ci/iol-testing success Testing PASS
ci/iol-mellanox-Performance success Performance Testing PASS
ci/iol-intel-Performance success Performance Testing PASS
ci/checkpatch success coding style OK

Commit Message

David Coyle April 10, 2020, 2:27 p.m. UTC
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 <david.coyle@intel.com>
Signed-off-by: Mairtin o Loingsigh <mairtin.oloingsigh@intel.com>
---
 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

Patch
diff mbox series

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 <rte_log.h>
+
+#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 <rte_common.h>
+#include <rte_mbuf.h>
+#include <rte_mempool.h>
+#include <rte_crypto.h>
+
+/**
+ * @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 <rte_rawdev.h>
+
+#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