>
> As the queue pair used in secondary process needs to be set up by
> the primary process, this patch adds an IPC register function to help
> secondary process to send out queue-pair setup request to primary
> process via IPC request messages. A new "qp_in_used_pid" param stores
> the PID to provide the ownership of the queue-pair so that only the PID
> matched queue-pair can be free'd in the request.
As I can see that patch was already merged, but still:
How we suppose to guarantee synchronization with such approach?
Let say secondary process sends an IPC message to configure
crypto-queue, and at the same moment primary process (for whatever reason)
decides to reconfigure same crypto-dev.
Is there any way to prevent such race-conditions to happen?
>
> Signed-off-by: Kai Ji <kai...@intel.com>
> Acked-by: Arek Kusztal <arkadiuszx.kusz...@intel.com>
> Acked-by: Pablo de Lara <pablo.de.lara.gua...@intel.com>
> ---
> v5:
> - minor updates and typo fix
>
> v4:
> - review comments resolved
>
> v3:
> - remove shared memzone as qp_conf params can be passed directly from
> ipc message.
>
> v2:
> - add in shared memzone for data exchange between multi-process
> ---
> drivers/crypto/ipsec_mb/ipsec_mb_ops.c | 129 ++++++++++++++++++++-
> drivers/crypto/ipsec_mb/ipsec_mb_private.c | 24 +++-
> drivers/crypto/ipsec_mb/ipsec_mb_private.h | 38 +++++-
> 3 files changed, 185 insertions(+), 6 deletions(-)
>
> diff --git a/drivers/crypto/ipsec_mb/ipsec_mb_ops.c
> b/drivers/crypto/ipsec_mb/ipsec_mb_ops.c
> index cedcaa2742..bf18d692bd 100644
> --- a/drivers/crypto/ipsec_mb/ipsec_mb_ops.c
> +++ b/drivers/crypto/ipsec_mb/ipsec_mb_ops.c
> @@ -3,6 +3,7 @@
> */
>
> #include <string.h>
> +#include <unistd.h>
>
> #include <rte_common.h>
> #include <rte_malloc.h>
> @@ -93,6 +94,46 @@ ipsec_mb_info_get(struct rte_cryptodev *dev,
> }
> }
>
> +static int
> +ipsec_mb_secondary_qp_op(int dev_id, int qp_id,
> + const struct rte_cryptodev_qp_conf *qp_conf,
> + int socket_id, enum ipsec_mb_mp_req_type op_type)
> +{
> + int ret;
> + struct rte_mp_msg qp_req_msg;
> + struct rte_mp_msg *qp_resp_msg;
> + struct rte_mp_reply qp_resp;
> + struct ipsec_mb_mp_param *req_param;
> + struct ipsec_mb_mp_param *resp_param;
> + struct timespec ts = {.tv_sec = 1, .tv_nsec = 0};
> +
> + memset(&qp_req_msg, 0, sizeof(IPSEC_MB_MP_MSG));
> + memcpy(qp_req_msg.name, IPSEC_MB_MP_MSG, sizeof(IPSEC_MB_MP_MSG));
> + req_param = (struct ipsec_mb_mp_param *)&qp_req_msg.param;
> +
> + qp_req_msg.len_param = sizeof(struct ipsec_mb_mp_param);
> + req_param->type = op_type;
> + req_param->dev_id = dev_id;
> + req_param->qp_id = qp_id;
> + req_param->socket_id = socket_id;
> + req_param->process_id = getpid();
> + if (qp_conf) {
> + req_param->nb_descriptors = qp_conf->nb_descriptors;
> + req_param->mp_session = (void *)qp_conf->mp_session;
> + }
> +
> + qp_req_msg.num_fds = 0;
> + ret = rte_mp_request_sync(&qp_req_msg, &qp_resp, &ts);
> + if (ret) {
> + RTE_LOG(ERR, USER1, "Create MR request to primary process
> failed.");
> + return -1;
> + }
> + qp_resp_msg = &qp_resp.msgs[0];
> + resp_param = (struct ipsec_mb_mp_param *)qp_resp_msg->param;
> +
> + return resp_param->result;
> +}
> +
> /** Release queue pair */
> int
> ipsec_mb_qp_release(struct rte_cryptodev *dev, uint16_t qp_id)
> @@ -100,7 +141,10 @@ ipsec_mb_qp_release(struct rte_cryptodev *dev, uint16_t
> qp_id)
> struct ipsec_mb_qp *qp = dev->data->queue_pairs[qp_id];
> struct rte_ring *r = NULL;
>
> - if (qp != NULL && rte_eal_process_type() == RTE_PROC_PRIMARY) {
> + if (qp != NULL)
> + return 0;
> +
> + if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
> r = rte_ring_lookup(qp->name);
> rte_ring_free(r);
>
> @@ -115,6 +159,9 @@ ipsec_mb_qp_release(struct rte_cryptodev *dev, uint16_t
> qp_id)
> #endif
> rte_free(qp);
> dev->data->queue_pairs[qp_id] = NULL;
> + } else { /* secondary process */
> + return ipsec_mb_secondary_qp_op(dev->data->dev_id, qp_id,
> + NULL, 0, RTE_IPSEC_MB_MP_REQ_QP_FREE);
> }
> return 0;
> }
> @@ -222,9 +269,13 @@ ipsec_mb_qp_setup(struct rte_cryptodev *dev, uint16_t
> qp_id,
> #endif
> qp = dev->data->queue_pairs[qp_id];
> if (qp == NULL) {
> - IPSEC_MB_LOG(ERR, "Primary process hasn't configured
> device qp.");
> - return -EINVAL;
> + IPSEC_MB_LOG(DEBUG, "Secondary process setting up
> device qp.");
> + return ipsec_mb_secondary_qp_op(dev->data->dev_id,
> qp_id,
> + qp_conf, socket_id,
> RTE_IPSEC_MB_MP_REQ_QP_SET);
> }
> +
> + IPSEC_MB_LOG(ERR, "Queue pair already setup'ed.");
> + return -EINVAL;
> } else {
> /* Free memory prior to re-allocation if needed. */
> if (dev->data->queue_pairs[qp_id] != NULL)
> @@ -296,6 +347,78 @@ ipsec_mb_qp_setup(struct rte_cryptodev *dev, uint16_t
> qp_id,
> return ret;
> }
>
> +int
> +ipsec_mb_ipc_request(const struct rte_mp_msg *mp_msg, const void *peer)
> +{
> + struct rte_mp_msg ipc_resp;
> + struct ipsec_mb_mp_param *resp_param =
> + (struct ipsec_mb_mp_param *)ipc_resp.param;
> + const struct ipsec_mb_mp_param *req_param =
> + (const struct ipsec_mb_mp_param *)mp_msg->param;
> +
> + int ret;
> + struct rte_cryptodev *dev;
> + struct ipsec_mb_qp *qp;
> + struct rte_cryptodev_qp_conf queue_conf;
> + int dev_id = req_param->dev_id;
> + int qp_id = req_param->qp_id;
> +
> + queue_conf.nb_descriptors = req_param->nb_descriptors;
> + queue_conf.mp_session = (struct rte_mempool *)req_param->mp_session;
> + memset(resp_param, 0, sizeof(struct ipsec_mb_mp_param));
> + memcpy(ipc_resp.name, IPSEC_MB_MP_MSG, sizeof(IPSEC_MB_MP_MSG));
> +
> + if (!rte_cryptodev_is_valid_dev(dev_id)) {
> + CDEV_LOG_ERR("Invalid dev_id=%d", dev_id);
> + goto out;
> + }
> +
> + dev = rte_cryptodev_pmd_get_dev(dev_id);
> + switch (req_param->type) {
> + case RTE_IPSEC_MB_MP_REQ_QP_SET:
> + qp = dev->data->queue_pairs[qp_id];
> + if (qp) {
> + CDEV_LOG_DEBUG("qp %d on dev %d is initialised", qp_id,
> dev_id);
> + goto out;
> + }
> +
> + ret = ipsec_mb_qp_setup(dev, qp_id, &queue_conf,
> req_param->socket_id);
> + if (!ret) {
> + qp = dev->data->queue_pairs[qp_id];
> + if (!qp) {
> + CDEV_LOG_DEBUG("qp %d on dev %d is not
> initialised",
> + qp_id, dev_id);
> + goto out;
> + }
> + qp->qp_used_by_pid = req_param->process_id;
> + }
> + resp_param->result = ret;
> + break;
> + case RTE_IPSEC_MB_MP_REQ_QP_FREE:
> + qp = dev->data->queue_pairs[qp_id];
> + if (!qp) {
> + CDEV_LOG_DEBUG("qp %d on dev %d is not initialised",
> + qp_id, dev_id);
> + goto out;
> + }
> +
> + if (qp->qp_used_by_pid != req_param->process_id) {
> + CDEV_LOG_ERR("Unable to release qp_id=%d", qp_id);
> + goto out;
> + }
> +
> + qp->qp_used_by_pid = 0;
> + resp_param->result = ipsec_mb_qp_release(dev, qp_id);
> + break;
> + default:
> + CDEV_LOG_ERR("invalid mp request type\n");
> + }
> +
> +out:
> + ret = rte_mp_reply(&ipc_resp, peer);
> + return ret;
> +}
> +
> /** Return the size of the specific pmd session structure */
> unsigned
> ipsec_mb_sym_session_get_size(struct rte_cryptodev *dev)
> diff --git a/drivers/crypto/ipsec_mb/ipsec_mb_private.c
> b/drivers/crypto/ipsec_mb/ipsec_mb_private.c
> index e56579596f..c5540ac8dc 100644
> --- a/drivers/crypto/ipsec_mb/ipsec_mb_private.c
> +++ b/drivers/crypto/ipsec_mb/ipsec_mb_private.c
> @@ -42,6 +42,22 @@ ipsec_mb_enqueue_burst(void *__qp, struct rte_crypto_op
> **ops,
> return nb_enqueued;
> }
>
> +static int
> +ipsec_mb_mp_request_register(void)
> +{
> + RTE_ASSERT(rte_eal_process_type() == RTE_PROC_PRIMARY);
> + IPSEC_MB_LOG(INFO, "Starting register MP IPC request\n");
> + return rte_mp_action_register(IPSEC_MB_MP_MSG,
> + ipsec_mb_ipc_request);
> +}
> +
> +static void
> +ipsec_mb_mp_request_unregister(void)
> +{
> + RTE_ASSERT(rte_eal_process_type() == RTE_PROC_PRIMARY);
> + rte_mp_action_unregister(IPSEC_MB_MP_MSG);
> +}
> +
> int
> ipsec_mb_create(struct rte_vdev_device *vdev,
> enum ipsec_mb_pmd_types pmd_type)
> @@ -152,7 +168,10 @@ ipsec_mb_create(struct rte_vdev_device *vdev,
> IPSEC_MB_LOG(INFO, "IPSec Multi-buffer library version used: %s\n",
> imb_get_version_str());
>
> - return 0;
> + if (rte_eal_process_type() == RTE_PROC_PRIMARY)
> + retval = ipsec_mb_mp_request_register();
> +
> + return retval;
> }
>
> int
> @@ -187,5 +206,8 @@ ipsec_mb_remove(struct rte_vdev_device *vdev)
> for (qp_id = 0; qp_id < cryptodev->data->nb_queue_pairs; qp_id++)
> ipsec_mb_qp_release(cryptodev, qp_id);
>
> + if (rte_eal_process_type() == RTE_PROC_PRIMARY)
> + ipsec_mb_mp_request_unregister();
> +
> return rte_cryptodev_pmd_destroy(cryptodev);
> }
> diff --git a/drivers/crypto/ipsec_mb/ipsec_mb_private.h
> b/drivers/crypto/ipsec_mb/ipsec_mb_private.h
> index b56eaf061e..ab27214f2c 100644
> --- a/drivers/crypto/ipsec_mb/ipsec_mb_private.h
> +++ b/drivers/crypto/ipsec_mb/ipsec_mb_private.h
> @@ -25,6 +25,9 @@
> /* Maximum length for memzone name */
> #define IPSEC_MB_MAX_MZ_NAME 32
>
> +/* ipsec mb multi-process queue pair config */
> +#define IPSEC_MB_MP_MSG "ipsec_mb_mp_msg"
> +
> enum ipsec_mb_vector_mode {
> IPSEC_MB_NOT_SUPPORTED = 0,
> IPSEC_MB_SSE,
> @@ -146,14 +149,45 @@ struct ipsec_mb_qp {
> * slot to be used in temp_digests,
> * to store the digest for a given operation
> */
> + uint16_t qp_used_by_pid;
> + /**< The process id used for queue pairs **/
> IMB_MGR *mb_mgr;
> - /* Multi buffer manager */
> + /**< Multi buffer manager */
> const struct rte_memzone *mb_mgr_mz;
> - /* Shared memzone for storing mb_mgr */
> + /**< Shared memzone for storing mb_mgr */
> __extension__ uint8_t additional_data[];
> /**< Storing PMD specific additional data */
> };
>
> +/** Request types for IPC. */
> +enum ipsec_mb_mp_req_type {
> + RTE_IPSEC_MB_MP_REQ_NONE, /**< unknown event type */
> + RTE_IPSEC_MB_MP_REQ_QP_SET, /**< Queue pair setup request */
> + RTE_IPSEC_MB_MP_REQ_QP_FREE /**< Queue pair free request */
> +};
> +
> +/** Parameters for IPC. */
> +struct ipsec_mb_mp_param {
> + enum ipsec_mb_mp_req_type type; /**< IPC request type */
> + int dev_id;
> + /**< The identifier of the device */
> + int qp_id;
> + /**< The index of the queue pair to be configured */
> + int socket_id;
> + /**< Socket to allocate resources on */
> + uint16_t process_id;
> + /**< The pid who send out the requested */
> + uint32_t nb_descriptors;
> + /**< Number of descriptors per queue pair */
> + void *mp_session;
> + /**< The mempool for creating session in sessionless mode */
> + int result;
> + /**< The request result for response message */
> +};
> +
> +int
> +ipsec_mb_ipc_request(const struct rte_mp_msg *mp_msg, const void *peer);
> +
> static __rte_always_inline void *
> ipsec_mb_get_qp_private_data(struct ipsec_mb_qp *qp)
> {
> --
> 2.17.1
