[PATCH v26 24/26] drivers: improve DPAA crypto fq resource handling

[Hemant Agrawal]

From: Jun Yang <jun.yang at nxp.com>

Release resources on probe failure and on uninit, and allocate the FQID
range for a queue pair with a single ioctl instead of one per FQID to
cut boot and quit time.

Export qman_release_fqid_range() from the bus, which dpaa_sec_uninit()
needs to return the queue FQIDs in ranges.

qman_shutdown_fq() falls back to get_affine_portal() when fq->qp is
NULL, so affine a portal first in dpaa_sec_uninit() as probe does;
rte_dev_remove() can run on a thread that never did. Release an FQID
only once its queue actually shut down, in both uninit and the probe
error paths: one that did not is still live in QMan, and handing its
FQID back would let qman_alloc_fqid() give it to another user.

Signed-off-by: Jun Yang <jun.yang at nxp.com>
---
 drivers/bus/dpaa/dpaa_bus_base_symbols.c |   1 +
 drivers/bus/dpaa/include/fsl_qman.h      |   1 +
 drivers/crypto/dpaa_sec/dpaa_sec.c       | 176 ++++++++++++++++++++---
 3 files changed, 160 insertions(+), 18 deletions(-)

diff --git a/drivers/bus/dpaa/dpaa_bus_base_symbols.c b/drivers/bus/dpaa/dpaa_bus_base_symbols.c
index 0927e5fe2c..aaa9f9bec2 100644
--- a/drivers/bus/dpaa/dpaa_bus_base_symbols.c
+++ b/drivers/bus/dpaa/dpaa_bus_base_symbols.c
@@ -52,6 +52,7 @@ RTE_EXPORT_INTERNAL_SYMBOL(bman_acquire)
 RTE_EXPORT_INTERNAL_SYMBOL(bman_query_free_buffers)
 RTE_EXPORT_INTERNAL_SYMBOL(bman_thread_irq)
 RTE_EXPORT_INTERNAL_SYMBOL(qman_alloc_fqid_range)
+RTE_EXPORT_INTERNAL_SYMBOL(qman_release_fqid_range)
 RTE_EXPORT_INTERNAL_SYMBOL(qman_reserve_fqid_range)
 RTE_EXPORT_INTERNAL_SYMBOL(qman_alloc_pool_range)
 RTE_EXPORT_INTERNAL_SYMBOL(qman_alloc_cgrid_range)
diff --git a/drivers/bus/dpaa/include/fsl_qman.h b/drivers/bus/dpaa/include/fsl_qman.h
index 59b41e17f0..b2674ce5d0 100644
--- a/drivers/bus/dpaa/include/fsl_qman.h
+++ b/drivers/bus/dpaa/include/fsl_qman.h
@@ -1895,6 +1895,7 @@ static inline int qman_alloc_fqid(u32 *result)
  * This function can also be used to seed the allocator with ranges of FQIDs
  * that it can subsequently allocate from.
  */
+__rte_internal
 void qman_release_fqid_range(u32 fqid, unsigned int count);
 static inline void qman_release_fqid(u32 fqid)
 {
diff --git a/drivers/crypto/dpaa_sec/dpaa_sec.c b/drivers/crypto/dpaa_sec/dpaa_sec.c
index c53ee70853..6972699c51 100644
--- a/drivers/crypto/dpaa_sec/dpaa_sec.c
+++ b/drivers/crypto/dpaa_sec/dpaa_sec.c
@@ -188,16 +188,15 @@ dqrr_out_fq_cb_rx(struct qman_portal *qm __always_unused,
 
 /* caam result is put into this queue */
 static int
-dpaa_sec_init_tx(struct qman_fq *fq)
+dpaa_sec_init_tx(struct qman_fq *fq, uint32_t fqid)
 {
 	int ret;
 	struct qm_mcc_initfq opts;
 	uint32_t flags;
 
-	flags = QMAN_FQ_FLAG_NO_ENQUEUE | QMAN_FQ_FLAG_LOCKED |
-		QMAN_FQ_FLAG_DYNAMIC_FQID;
+	flags = QMAN_FQ_FLAG_NO_ENQUEUE | QMAN_FQ_FLAG_LOCKED;
 
-	ret = qman_create_fq(0, flags, fq);
+	ret = qman_create_fq(fqid, flags, fq);
 	if (unlikely(ret)) {
 		DPAA_SEC_ERR("qman_create_fq failed");
 		return ret;
@@ -3614,12 +3613,73 @@ static const struct rte_security_ops dpaa_sec_security_ops = {
 static int
 dpaa_sec_uninit(struct rte_cryptodev *dev)
 {
-	if (dev == NULL)
+	struct dpaa_sec_dev_private *internals;
+	uint32_t i, fqid, base, run;
+	int ret;
+
+	if (!dev)
 		return -ENODEV;
 
+	/* FQs and FQIDs are owned by the primary process. */
+	if (rte_eal_process_type() != RTE_PROC_PRIMARY)
+		return 0;
+
+	/* qman_shutdown_fq() needs an affine portal for fq->qp == NULL. */
+	if (unlikely(!DPAA_PER_LCORE_PORTAL)) {
+		ret = rte_dpaa_portal_init((void *)0);
+		if (ret) {
+			DPAA_SEC_ERR("Failure in affining portal");
+			return ret;
+		}
+	}
+
+	internals = dev->data->dev_private;
+	/* Only release the FQID of a queue that actually shut down: one that
+	 * did not is still live in QMan. Free in runs of adjacent FQIDs.
+	 */
+	base = 0;
+	run = 0;
+	for (i = 0; i < internals->max_nb_queue_pairs; i++) {
+		fqid = internals->qps[i].outq.fqid;
+		ret = qman_shutdown_fq(&internals->qps[i].outq);
+		if (ret)
+			DPAA_SEC_ERR("%s: Failed(%d) to shutdown TXQ(0x%08x), fqid not released",
+				dev->data->name, ret, fqid);
+		if (run && (ret || fqid != base + run)) {
+			qman_release_fqid_range(base, run);
+			run = 0;
+		}
+		if (ret || !fqid)
+			continue;
+		if (run++ == 0)
+			base = fqid;
+	}
+	if (run)
+		qman_release_fqid_range(base, run);
+
+	base = 0;
+	run = 0;
+	for (i = 0; i < RTE_DPAA_MAX_RX_QUEUE; i++) {
+		fqid = internals->inq[i].fqid;
+		ret = qman_shutdown_fq(&internals->inq[i]);
+		if (ret)
+			DPAA_SEC_ERR("%s: Failed(%d) to shutdown RXQ[%d](0x%08x), fqid not released",
+				dev->data->name, ret, i, fqid);
+		if (run && (ret || fqid != base + run)) {
+			qman_release_fqid_range(base, run);
+			run = 0;
+		}
+		if (ret || !fqid)
+			continue;
+		if (run++ == 0)
+			base = fqid;
+	}
+	if (run)
+		qman_release_fqid_range(base, run);
+
 	rte_free(dev->security_ctx);
 	DPAA_SEC_INFO("Closing DPAA_SEC device %s on numa socket %u",
-		      dev->data->name, rte_socket_id());
+		dev->data->name, rte_socket_id());
 
 	return 0;
 }
@@ -3666,10 +3726,10 @@ dpaa_sec_dev_init(struct rte_cryptodev *cryptodev)
 	struct dpaa_sec_dev_private *internals;
 	struct rte_security_ctx *security_instance;
 	struct dpaa_sec_qp *qp;
-	uint32_t i, flags;
-	int ret;
+	uint32_t i, j, flags, fqids[RTE_DPAA_MAX_RX_QUEUE];
+	uint32_t fqid, base, run;
+	int ret, num = 0, map_fd = -1;
 	void *cmd_map;
-	int map_fd = -1;
 
 	PMD_INIT_FUNC_TRACE();
 
@@ -3735,24 +3795,47 @@ dpaa_sec_dev_init(struct rte_cryptodev *cryptodev)
 	security_instance->sess_cnt = 0;
 	cryptodev->security_ctx = security_instance;
 	rte_spinlock_init(&internals->lock);
+	num = qman_alloc_fqid_range(fqids, internals->max_nb_queue_pairs, 0, 0);
+	if (num < (int)internals->max_nb_queue_pairs) {
+		if (num < 0) {
+			DPAA_SEC_ERR("%s: Failed(%d) to alloc %d TX fqids",
+				cryptodev->data->name, num, internals->max_nb_queue_pairs);
+		} else {
+			DPAA_SEC_ERR("%s: Alloc %d fqids < %d",
+				cryptodev->data->name, num, internals->max_nb_queue_pairs);
+			qman_release_fqid_range(fqids[0], num);
+		}
+		goto init_error;
+	}
 	for (i = 0; i < internals->max_nb_queue_pairs; i++) {
 		/* init qman fq for queue pair */
 		qp = &internals->qps[i];
-		ret = dpaa_sec_init_tx(&qp->outq);
+		ret = dpaa_sec_init_tx(&qp->outq, fqids[i]);
 		if (ret) {
-			DPAA_SEC_ERR("config tx of queue pair  %d", i);
-			goto init_error;
+			DPAA_SEC_ERR("%s: Failed(%d) to init TXQ[%d](0x%08x)",
+				cryptodev->data->name, ret, i, fqids[i]);
+			goto init_error1;
 		}
 	}
 
-	flags = QMAN_FQ_FLAG_LOCKED | QMAN_FQ_FLAG_DYNAMIC_FQID |
-		QMAN_FQ_FLAG_TO_DCPORTAL;
+	flags = QMAN_FQ_FLAG_LOCKED | QMAN_FQ_FLAG_TO_DCPORTAL;
+	num = qman_alloc_fqid_range(fqids, RTE_DPAA_MAX_RX_QUEUE, 0, 0);
+	if (num < RTE_DPAA_MAX_RX_QUEUE) {
+		if (num < 0) {
+			DPAA_SEC_ERR("Failed(%d) to alloc %d fqids", num, RTE_DPAA_MAX_RX_QUEUE);
+		} else {
+			DPAA_SEC_ERR("Alloc %d fqids < %d", num, RTE_DPAA_MAX_RX_QUEUE);
+			qman_release_fqid_range(fqids[0], num);
+		}
+		goto init_error2;
+	}
 	for (i = 0; i < RTE_DPAA_MAX_RX_QUEUE; i++) {
 		/* create rx qman fq for sessions*/
-		ret = qman_create_fq(0, flags, &internals->inq[i]);
-		if (unlikely(ret != 0)) {
-			DPAA_SEC_ERR("sec qman_create_fq failed");
-			goto init_error;
+		ret = qman_create_fq(fqids[i], flags, &internals->inq[i]);
+		if (ret) {
+			DPAA_SEC_ERR("%s: Failed(%d) to create RXQ[%d](0x%08x)",
+				cryptodev->data->name, ret, i, fqids[i]);
+			goto init_error3;
 		}
 	}
 
@@ -3761,6 +3844,63 @@ dpaa_sec_dev_init(struct rte_cryptodev *cryptodev)
 	DPAA_SEC_INFO("%s cryptodev init", cryptodev->data->name);
 	return 0;
 
+init_error3:
+	/* Same rule as in uninit: do not release the FQID of a queue that
+	 * failed to shut down.
+	 */
+	base = 0;
+	run = 0;
+	for (j = 0; j < i; j++) {
+		fqid = internals->inq[j].fqid;
+		ret = qman_shutdown_fq(&internals->inq[j]);
+		if (ret) {
+			DPAA_SEC_ERR("%s: Failed(%d) to shutdown RXQ(0x%08x), fqid not released",
+				cryptodev->data->name, ret, fqid);
+		}
+		if (run && (ret || fqid != base + run)) {
+			qman_release_fqid_range(base, run);
+			run = 0;
+		}
+		if (ret || !fqid)
+			continue;
+		if (run++ == 0)
+			base = fqid;
+	}
+	if (run)
+		qman_release_fqid_range(base, run);
+	/* FQIDs of the queues that were never created */
+	if (i < RTE_DPAA_MAX_RX_QUEUE)
+		qman_release_fqid_range(fqids[i], RTE_DPAA_MAX_RX_QUEUE - i);
+init_error2:
+	i = internals->max_nb_queue_pairs;
+	fqids[0] = internals->qps[0].outq.fqid;
+init_error1:
+	base = 0;
+	run = 0;
+	for (j = 0; j < i; j++) {
+		qp = &internals->qps[j];
+		fqid = qp->outq.fqid;
+		ret = qman_shutdown_fq(&qp->outq);
+		if (ret) {
+			DPAA_SEC_ERR("%s: Failed(%d) to shutdown TXQ(0x%08x), fqid not released",
+				cryptodev->data->name, ret, fqid);
+		}
+		if (run && (ret || fqid != base + run)) {
+			qman_release_fqid_range(base, run);
+			run = 0;
+		}
+		if (ret || !fqid)
+			continue;
+		if (run++ == 0)
+			base = fqid;
+	}
+	if (run)
+		qman_release_fqid_range(base, run);
+	/* FQIDs of the queues that were never created */
+	if (i < internals->max_nb_queue_pairs)
+		qman_release_fqid_range(fqids[i],
+			internals->max_nb_queue_pairs - i);
+
 init_error:
 	DPAA_SEC_ERR("driver %s: create failed", cryptodev->data->name);
 
-- 
2.25.1