crypto/scheduler: add dynamic logging

Registered new dynamic logtype for driver and
replaced CS_LOG_ERR and RTE_LOG macros with
new CR_SCHED macro, which uses the new logtype.

Signed-off-by: Hari Kumar <hari.kumarx.vemula@intel.com>
Reviewed-by: Reshma Pattan <reshma.pattan@intel.com>
Reviewed-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>

diff --git a/config/common_base b/config/common_base
index 08bb56a..2e83ecb 100644 (file)
--- a/config/common_base
+++ b/config/common_base
@@ -542,7 +542,6 @@ CONFIG_RTE_LIBRTE_PMD_ZUC_DEBUG=n
 # Compile PMD for Crypto Scheduler device
 #
 CONFIG_RTE_LIBRTE_PMD_CRYPTO_SCHEDULER=y
-CONFIG_RTE_LIBRTE_PMD_CRYPTO_SCHEDULER_DEBUG=n
 
 #
 # Compile PMD for NULL Crypto device

diff --git a/drivers/crypto/scheduler/rte_cryptodev_scheduler.c b/drivers/crypto/scheduler/rte_cryptodev_scheduler.c
index ed574cc..4fdb111 100644 (file)
--- a/drivers/crypto/scheduler/rte_cryptodev_scheduler.c
+++ b/drivers/crypto/scheduler/rte_cryptodev_scheduler.c
@@ -9,6 +9,8 @@
 #include "rte_cryptodev_scheduler.h"
 #include "scheduler_pmd_private.h"
 
+int scheduler_logtype_driver;
+
 /** update the scheduler pmd's capability with attaching device's
  *  capability.
  *  For each device to be attached, the scheduler's capability should be
@@ -168,30 +170,30 @@ rte_cryptodev_scheduler_slave_attach(uint8_t scheduler_id, uint8_t slave_id)
        uint32_t i;
 
        if (!dev) {
-               CS_LOG_ERR("Operation not supported");
+               CR_SCHED_LOG(ERR, "Operation not supported");
                return -ENOTSUP;
        }
 
        if (dev->driver_id != cryptodev_driver_id) {
-               CS_LOG_ERR("Operation not supported");
+               CR_SCHED_LOG(ERR, "Operation not supported");
                return -ENOTSUP;
        }
 
        if (dev->data->dev_started) {
-               CS_LOG_ERR("Illegal operation");
+               CR_SCHED_LOG(ERR, "Illegal operation");
                return -EBUSY;
        }
 
        sched_ctx = dev->data->dev_private;
        if (sched_ctx->nb_slaves >=
                        RTE_CRYPTODEV_SCHEDULER_MAX_NB_SLAVES) {
-               CS_LOG_ERR("Too many slaves attached");
+               CR_SCHED_LOG(ERR, "Too many slaves attached");
                return -ENOMEM;
        }
 
        for (i = 0; i < sched_ctx->nb_slaves; i++)
                if (sched_ctx->slaves[i].dev_id == slave_id) {
-                       CS_LOG_ERR("Slave already added");
+                       CR_SCHED_LOG(ERR, "Slave already added");
                        return -ENOTSUP;
                }
 
@@ -208,7 +210,7 @@ rte_cryptodev_scheduler_slave_attach(uint8_t scheduler_id, uint8_t slave_id)
                slave->driver_id = 0;
                sched_ctx->nb_slaves--;
 
-               CS_LOG_ERR("capabilities update failed");
+               CR_SCHED_LOG(ERR, "capabilities update failed");
                return -ENOTSUP;
        }
 
@@ -227,17 +229,17 @@ rte_cryptodev_scheduler_slave_detach(uint8_t scheduler_id, uint8_t slave_id)
        uint32_t i, slave_pos;
 
        if (!dev) {
-               CS_LOG_ERR("Operation not supported");
+               CR_SCHED_LOG(ERR, "Operation not supported");
                return -ENOTSUP;
        }
 
        if (dev->driver_id != cryptodev_driver_id) {
-               CS_LOG_ERR("Operation not supported");
+               CR_SCHED_LOG(ERR, "Operation not supported");
                return -ENOTSUP;
        }
 
        if (dev->data->dev_started) {
-               CS_LOG_ERR("Illegal operation");
+               CR_SCHED_LOG(ERR, "Illegal operation");
                return -EBUSY;
        }
 
@@ -247,12 +249,12 @@ rte_cryptodev_scheduler_slave_detach(uint8_t scheduler_id, uint8_t slave_id)
                if (sched_ctx->slaves[slave_pos].dev_id == slave_id)
                        break;
        if (slave_pos == sched_ctx->nb_slaves) {
-               CS_LOG_ERR("Cannot find slave");
+               CR_SCHED_LOG(ERR, "Cannot find slave");
                return -ENOTSUP;
        }
 
        if (sched_ctx->ops.slave_detach(dev, slave_id) < 0) {
-               CS_LOG_ERR("Failed to detach slave");
+               CR_SCHED_LOG(ERR, "Failed to detach slave");
                return -ENOTSUP;
        }
 
@@ -265,7 +267,7 @@ rte_cryptodev_scheduler_slave_detach(uint8_t scheduler_id, uint8_t slave_id)
        sched_ctx->nb_slaves--;
 
        if (update_scheduler_capability(sched_ctx) < 0) {
-               CS_LOG_ERR("capabilities update failed");
+               CR_SCHED_LOG(ERR, "capabilities update failed");
                return -ENOTSUP;
        }
 
@@ -284,17 +286,17 @@ rte_cryptodev_scheduler_mode_set(uint8_t scheduler_id,
        struct scheduler_ctx *sched_ctx;
 
        if (!dev) {
-               CS_LOG_ERR("Operation not supported");
+               CR_SCHED_LOG(ERR, "Operation not supported");
                return -ENOTSUP;
        }
 
        if (dev->driver_id != cryptodev_driver_id) {
-               CS_LOG_ERR("Operation not supported");
+               CR_SCHED_LOG(ERR, "Operation not supported");
                return -ENOTSUP;
        }
 
        if (dev->data->dev_started) {
-               CS_LOG_ERR("Illegal operation");
+               CR_SCHED_LOG(ERR, "Illegal operation");
                return -EBUSY;
        }
 
@@ -307,33 +309,33 @@ rte_cryptodev_scheduler_mode_set(uint8_t scheduler_id,
        case CDEV_SCHED_MODE_ROUNDROBIN:
                if (rte_cryptodev_scheduler_load_user_scheduler(scheduler_id,
                                roundrobin_scheduler) < 0) {
-                       CS_LOG_ERR("Failed to load scheduler");
+                       CR_SCHED_LOG(ERR, "Failed to load scheduler");
                        return -1;
                }
                break;
        case CDEV_SCHED_MODE_PKT_SIZE_DISTR:
                if (rte_cryptodev_scheduler_load_user_scheduler(scheduler_id,
                                pkt_size_based_distr_scheduler) < 0) {
-                       CS_LOG_ERR("Failed to load scheduler");
+                       CR_SCHED_LOG(ERR, "Failed to load scheduler");
                        return -1;
                }
                break;
        case CDEV_SCHED_MODE_FAILOVER:
                if (rte_cryptodev_scheduler_load_user_scheduler(scheduler_id,
                                failover_scheduler) < 0) {
-                       CS_LOG_ERR("Failed to load scheduler");
+                       CR_SCHED_LOG(ERR, "Failed to load scheduler");
                        return -1;
                }
                break;
        case CDEV_SCHED_MODE_MULTICORE:
                if (rte_cryptodev_scheduler_load_user_scheduler(scheduler_id,
                                multicore_scheduler) < 0) {
-                       CS_LOG_ERR("Failed to load scheduler");
+                       CR_SCHED_LOG(ERR, "Failed to load scheduler");
                        return -1;
                }
                break;
        default:
-               CS_LOG_ERR("Not yet supported");
+               CR_SCHED_LOG(ERR, "Not yet supported");
                return -ENOTSUP;
        }
 
@@ -347,12 +349,12 @@ rte_cryptodev_scheduler_mode_get(uint8_t scheduler_id)
        struct scheduler_ctx *sched_ctx;
 
        if (!dev) {
-               CS_LOG_ERR("Operation not supported");
+               CR_SCHED_LOG(ERR, "Operation not supported");
                return -ENOTSUP;
        }
 
        if (dev->driver_id != cryptodev_driver_id) {
-               CS_LOG_ERR("Operation not supported");
+               CR_SCHED_LOG(ERR, "Operation not supported");
                return -ENOTSUP;
        }
 
@@ -369,17 +371,17 @@ rte_cryptodev_scheduler_ordering_set(uint8_t scheduler_id,
        struct scheduler_ctx *sched_ctx;
 
        if (!dev) {
-               CS_LOG_ERR("Operation not supported");
+               CR_SCHED_LOG(ERR, "Operation not supported");
                return -ENOTSUP;
        }
 
        if (dev->driver_id != cryptodev_driver_id) {
-               CS_LOG_ERR("Operation not supported");
+               CR_SCHED_LOG(ERR, "Operation not supported");
                return -ENOTSUP;
        }
 
        if (dev->data->dev_started) {
-               CS_LOG_ERR("Illegal operation");
+               CR_SCHED_LOG(ERR, "Illegal operation");
                return -EBUSY;
        }
 
@@ -397,12 +399,12 @@ rte_cryptodev_scheduler_ordering_get(uint8_t scheduler_id)
        struct scheduler_ctx *sched_ctx;
 
        if (!dev) {
-               CS_LOG_ERR("Operation not supported");
+               CR_SCHED_LOG(ERR, "Operation not supported");
                return -ENOTSUP;
        }
 
        if (dev->driver_id != cryptodev_driver_id) {
-               CS_LOG_ERR("Operation not supported");
+               CR_SCHED_LOG(ERR, "Operation not supported");
                return -ENOTSUP;
        }
 
@@ -419,25 +421,25 @@ rte_cryptodev_scheduler_load_user_scheduler(uint8_t scheduler_id,
        struct scheduler_ctx *sched_ctx;
 
        if (!dev) {
-               CS_LOG_ERR("Operation not supported");
+               CR_SCHED_LOG(ERR, "Operation not supported");
                return -ENOTSUP;
        }
 
        if (dev->driver_id != cryptodev_driver_id) {
-               CS_LOG_ERR("Operation not supported");
+               CR_SCHED_LOG(ERR, "Operation not supported");
                return -ENOTSUP;
        }
 
        if (dev->data->dev_started) {
-               CS_LOG_ERR("Illegal operation");
+               CR_SCHED_LOG(ERR, "Illegal operation");
                return -EBUSY;
        }
 
        sched_ctx = dev->data->dev_private;
 
        if (strlen(scheduler->name) > RTE_CRYPTODEV_NAME_MAX_LEN - 1) {
-               CS_LOG_ERR("Invalid name %s, should be less than "
-                               "%u bytes.\n", scheduler->name,
+               CR_SCHED_LOG(ERR, "Invalid name %s, should be less than "
+                               "%u bytes.", scheduler->name,
                                RTE_CRYPTODEV_NAME_MAX_LEN);
                return -EINVAL;
        }
@@ -446,8 +448,8 @@ rte_cryptodev_scheduler_load_user_scheduler(uint8_t scheduler_id,
 
        if (strlen(scheduler->description) >
                        RTE_CRYPTODEV_SCHEDULER_DESC_MAX_LEN - 1) {
-               CS_LOG_ERR("Invalid description %s, should be less than "
-                               "%u bytes.\n", scheduler->description,
+               CR_SCHED_LOG(ERR, "Invalid description %s, should be less than "
+                               "%u bytes.", scheduler->description,
                                RTE_CRYPTODEV_SCHEDULER_DESC_MAX_LEN - 1);
                return -EINVAL;
        }
@@ -473,7 +475,7 @@ rte_cryptodev_scheduler_load_user_scheduler(uint8_t scheduler_id,
                int ret = (*sched_ctx->ops.create_private_ctx)(dev);
 
                if (ret < 0) {
-                       CS_LOG_ERR("Unable to create scheduler private "
+                       CR_SCHED_LOG(ERR, "Unable to create scheduler private "
                                        "context");
                        return ret;
                }
@@ -492,12 +494,12 @@ rte_cryptodev_scheduler_slaves_get(uint8_t scheduler_id, uint8_t *slaves)
        uint32_t nb_slaves = 0;
 
        if (!dev) {
-               CS_LOG_ERR("Operation not supported");
+               CR_SCHED_LOG(ERR, "Operation not supported");
                return -ENOTSUP;
        }
 
        if (dev->driver_id != cryptodev_driver_id) {
-               CS_LOG_ERR("Operation not supported");
+               CR_SCHED_LOG(ERR, "Operation not supported");
                return -ENOTSUP;
        }
 
@@ -525,17 +527,17 @@ rte_cryptodev_scheduler_option_set(uint8_t scheduler_id,
 
        if (option_type == CDEV_SCHED_OPTION_NOT_SET ||
                        option_type >= CDEV_SCHED_OPTION_COUNT) {
-               CS_LOG_ERR("Invalid option parameter");
+               CR_SCHED_LOG(ERR, "Invalid option parameter");
                return -EINVAL;
        }
 
        if (!option) {
-               CS_LOG_ERR("Invalid option parameter");
+               CR_SCHED_LOG(ERR, "Invalid option parameter");
                return -EINVAL;
        }
 
        if (dev->data->dev_started) {
-               CS_LOG_ERR("Illegal operation");
+               CR_SCHED_LOG(ERR, "Illegal operation");
                return -EBUSY;
        }
 
@@ -555,17 +557,17 @@ rte_cryptodev_scheduler_option_get(uint8_t scheduler_id,
        struct scheduler_ctx *sched_ctx;
 
        if (!dev) {
-               CS_LOG_ERR("Operation not supported");
+               CR_SCHED_LOG(ERR, "Operation not supported");
                return -ENOTSUP;
        }
 
        if (!option) {
-               CS_LOG_ERR("Invalid option parameter");
+               CR_SCHED_LOG(ERR, "Invalid option parameter");
                return -EINVAL;
        }
 
        if (dev->driver_id != cryptodev_driver_id) {
-               CS_LOG_ERR("Operation not supported");
+               CR_SCHED_LOG(ERR, "Operation not supported");
                return -ENOTSUP;
        }
 
@@ -575,3 +577,11 @@ rte_cryptodev_scheduler_option_get(uint8_t scheduler_id,
 
        return (*sched_ctx->ops.option_get)(dev, option_type, option);
 }
+
+RTE_INIT(scheduler_init_log);
+
+static void
+scheduler_init_log(void)
+{
+       scheduler_logtype_driver = rte_log_register("pmd.crypto.scheduler");
+}

diff --git a/drivers/crypto/scheduler/scheduler_failover.c b/drivers/crypto/scheduler/scheduler_failover.c
index 005b163..ddfb5b8 100644 (file)
--- a/drivers/crypto/scheduler/scheduler_failover.c
+++ b/drivers/crypto/scheduler/scheduler_failover.c
@@ -139,7 +139,7 @@ scheduler_start(struct rte_cryptodev *dev)
        uint16_t i;
 
        if (sched_ctx->nb_slaves < 2) {
-               CS_LOG_ERR("Number of slaves shall no less than 2");
+               CR_SCHED_LOG(ERR, "Number of slaves shall no less than 2");
                return -ENOMEM;
        }
 
@@ -182,7 +182,7 @@ scheduler_config_qp(struct rte_cryptodev *dev, uint16_t qp_id)
        fo_qp_ctx = rte_zmalloc_socket(NULL, sizeof(*fo_qp_ctx), 0,
                        rte_socket_id());
        if (!fo_qp_ctx) {
-               CS_LOG_ERR("failed allocate memory for private queue pair");
+               CR_SCHED_LOG(ERR, "failed allocate memory for private queue pair");
                return -ENOMEM;
        }
 

diff --git a/drivers/crypto/scheduler/scheduler_multicore.c b/drivers/crypto/scheduler/scheduler_multicore.c
index 91fb066..d410e69 100644 (file)
--- a/drivers/crypto/scheduler/scheduler_multicore.c
+++ b/drivers/crypto/scheduler/scheduler_multicore.c
@@ -178,7 +178,8 @@ mc_scheduler_worker(struct rte_cryptodev *dev)
                }
        }
        if (worker_idx == -1) {
-               CS_LOG_ERR("worker on core %u:cannot find worker index!\n", core_id);
+               CR_SCHED_LOG(ERR, "worker on core %u:cannot find worker index!",
+                       core_id);
                return -1;
        }
 
@@ -313,7 +314,7 @@ scheduler_config_qp(struct rte_cryptodev *dev, uint16_t qp_id)
        mc_qp_ctx = rte_zmalloc_socket(NULL, sizeof(*mc_qp_ctx), 0,
                        rte_socket_id());
        if (!mc_qp_ctx) {
-               CS_LOG_ERR("failed allocate memory for private queue pair");
+               CR_SCHED_LOG(ERR, "failed allocate memory for private queue pair");
                return -ENOMEM;
        }
 
@@ -339,7 +340,7 @@ scheduler_create_private_ctx(struct rte_cryptodev *dev)
        mc_ctx = rte_zmalloc_socket(NULL, sizeof(struct mc_scheduler_ctx), 0,
                        rte_socket_id());
        if (!mc_ctx) {
-               CS_LOG_ERR("failed allocate memory");
+               CR_SCHED_LOG(ERR, "failed allocate memory");
                return -ENOMEM;
        }
 
@@ -356,7 +357,7 @@ scheduler_create_private_ctx(struct rte_cryptodev *dev)
                                                rte_socket_id(),
                                                RING_F_SC_DEQ | RING_F_SP_ENQ);
                        if (!mc_ctx->sched_enq_ring[i]) {
-                               CS_LOG_ERR("Cannot create ring for worker %u",
+                               CR_SCHED_LOG(ERR, "Cannot create ring for worker %u",
                                           i);
                                goto exit;
                        }
@@ -370,7 +371,7 @@ scheduler_create_private_ctx(struct rte_cryptodev *dev)
                                                rte_socket_id(),
                                                RING_F_SC_DEQ | RING_F_SP_ENQ);
                        if (!mc_ctx->sched_deq_ring[i]) {
-                               CS_LOG_ERR("Cannot create ring for worker %u",
+                               CR_SCHED_LOG(ERR, "Cannot create ring for worker %u",
                                           i);
                                goto exit;
                        }

diff --git a/drivers/crypto/scheduler/scheduler_pkt_size_distr.c b/drivers/crypto/scheduler/scheduler_pkt_size_distr.c
index d09e849..74129b6 100644 (file)
--- a/drivers/crypto/scheduler/scheduler_pkt_size_distr.c
+++ b/drivers/crypto/scheduler/scheduler_pkt_size_distr.c
@@ -258,7 +258,7 @@ scheduler_start(struct rte_cryptodev *dev)
 
        /* for packet size based scheduler, nb_slaves have to >= 2 */
        if (sched_ctx->nb_slaves < NB_PKT_SIZE_SLAVES) {
-               CS_LOG_ERR("not enough slaves to start");
+               CR_SCHED_LOG(ERR, "not enough slaves to start");
                return -1;
        }
 
@@ -302,7 +302,7 @@ scheduler_stop(struct rte_cryptodev *dev)
 
                if (ps_qp_ctx->primary_slave.nb_inflight_cops +
                                ps_qp_ctx->secondary_slave.nb_inflight_cops) {
-                       CS_LOG_ERR("Some crypto ops left in slave queue");
+                       CR_SCHED_LOG(ERR, "Some crypto ops left in slave queue");
                        return -1;
                }
        }
@@ -319,7 +319,7 @@ scheduler_config_qp(struct rte_cryptodev *dev, uint16_t qp_id)
        ps_qp_ctx = rte_zmalloc_socket(NULL, sizeof(*ps_qp_ctx), 0,
                        rte_socket_id());
        if (!ps_qp_ctx) {
-               CS_LOG_ERR("failed allocate memory for private queue pair");
+               CR_SCHED_LOG(ERR, "failed allocate memory for private queue pair");
                return -ENOMEM;
        }
 
@@ -342,7 +342,7 @@ scheduler_create_private_ctx(struct rte_cryptodev *dev)
        psd_ctx = rte_zmalloc_socket(NULL, sizeof(struct psd_scheduler_ctx), 0,
                        rte_socket_id());
        if (!psd_ctx) {
-               CS_LOG_ERR("failed allocate memory");
+               CR_SCHED_LOG(ERR, "failed allocate memory");
                return -ENOMEM;
        }
 
@@ -362,14 +362,14 @@ scheduler_option_set(struct rte_cryptodev *dev, uint32_t option_type,
 
        if ((enum rte_cryptodev_schedule_option_type)option_type !=
                        CDEV_SCHED_OPTION_THRESHOLD) {
-               CS_LOG_ERR("Option not supported");
+               CR_SCHED_LOG(ERR, "Option not supported");
                return -EINVAL;
        }
 
        threshold = ((struct rte_cryptodev_scheduler_threshold_option *)
                        option)->threshold;
        if (!rte_is_power_of_2(threshold)) {
-               CS_LOG_ERR("Threshold is not power of 2");
+               CR_SCHED_LOG(ERR, "Threshold is not power of 2");
                return -EINVAL;
        }
 
@@ -388,7 +388,7 @@ scheduler_option_get(struct rte_cryptodev *dev, uint32_t option_type,
 
        if ((enum rte_cryptodev_schedule_option_type)option_type !=
                        CDEV_SCHED_OPTION_THRESHOLD) {
-               CS_LOG_ERR("Option not supported");
+               CR_SCHED_LOG(ERR, "Option not supported");
                return -EINVAL;
        }
 

diff --git a/drivers/crypto/scheduler/scheduler_pmd.c b/drivers/crypto/scheduler/scheduler_pmd.c
index 25d6409..5489e9e 100644 (file)
--- a/drivers/crypto/scheduler/scheduler_pmd.c
+++ b/drivers/crypto/scheduler/scheduler_pmd.c
@@ -82,7 +82,7 @@ cryptodev_scheduler_create(const char *name,
        dev = rte_cryptodev_pmd_create(name, &vdev->device,
                        &init_params->def_p);
        if (dev == NULL) {
-               CS_LOG_ERR("driver %s: failed to create cryptodev vdev",
+               CR_SCHED_LOG(ERR, "driver %s: failed to create cryptodev vdev",
                        name);
                return -EFAULT;
        }
@@ -101,7 +101,7 @@ cryptodev_scheduler_create(const char *name,
 
                for (i = 0; i < sched_ctx->nb_wc; i++) {
                        sched_ctx->wc_pool[i] = init_params->wc_pool[i];
-                       RTE_LOG(INFO, PMD, "  Worker core[%u]=%u added\n",
+                       CR_SCHED_LOG(INFO, "  Worker core[%u]=%u added",
                                i, sched_ctx->wc_pool[i]);
                }
        }
@@ -119,7 +119,7 @@ cryptodev_scheduler_create(const char *name,
                        if (scheduler_mode_map[i].val != sched_ctx->mode)
                                continue;
 
-                       RTE_LOG(INFO, PMD, "  Scheduling mode = %s\n",
+                       CR_SCHED_LOG(INFO, "  Scheduling mode = %s",
                                        scheduler_mode_map[i].name);
                        break;
                }
@@ -132,7 +132,7 @@ cryptodev_scheduler_create(const char *name,
                                sched_ctx->reordering_enabled)
                        continue;
 
-               RTE_LOG(INFO, PMD, "  Packet ordering = %s\n",
+               CR_SCHED_LOG(INFO, "  Packet ordering = %s",
                                scheduler_ordering_map[i].name);
 
                break;
@@ -147,7 +147,7 @@ cryptodev_scheduler_create(const char *name,
 
                if (!sched_ctx->init_slave_names[
                                sched_ctx->nb_init_slaves]) {
-                       CS_LOG_ERR("driver %s: Insufficient memory",
+                       CR_SCHED_LOG(ERR, "driver %s: Insufficient memory",
                                        name);
                        return -ENOMEM;
                }
@@ -169,8 +169,8 @@ cryptodev_scheduler_create(const char *name,
                        0, SOCKET_ID_ANY);
 
        if (!sched_ctx->capabilities) {
-               RTE_LOG(ERR, PMD, "Not enough memory for capability "
-                               "information\n");
+               CR_SCHED_LOG(ERR, "Not enough memory for capability "
+                               "information");
                return -ENOMEM;
        }
 
@@ -214,7 +214,7 @@ parse_integer_arg(const char *key __rte_unused,
 
        *i = atoi(value);
        if (*i < 0) {
-               CS_LOG_ERR("Argument has to be positive.\n");
+               CR_SCHED_LOG(ERR, "Argument has to be positive.");
                return -EINVAL;
        }
 
@@ -287,8 +287,8 @@ parse_corelist_arg(const char *key __rte_unused,
                unsigned int core = strtoul(token, &rval, 10);
 
                if (core >= RTE_MAX_LCORE) {
-                       CS_LOG_ERR("Invalid worker core %u, should be smaller "
-                                  "than %u.\n", core, RTE_MAX_LCORE);
+                       CR_SCHED_LOG(ERR, "Invalid worker core %u, should be smaller "
+                                  "than %u.", core, RTE_MAX_LCORE);
                }
                params->wc_pool[params->nb_wc++] = (uint16_t)core;
                token = (const char *)rval;
@@ -308,8 +308,8 @@ parse_name_arg(const char *key __rte_unused,
        struct rte_cryptodev_pmd_init_params *params = extra_args;
 
        if (strlen(value) >= RTE_CRYPTODEV_NAME_MAX_LEN - 1) {
-               CS_LOG_ERR("Invalid name %s, should be less than "
-                               "%u bytes.\n", value,
+               CR_SCHED_LOG(ERR, "Invalid name %s, should be less than "
+                               "%u bytes.", value,
                                RTE_CRYPTODEV_NAME_MAX_LEN - 1);
                return -EINVAL;
        }
@@ -327,7 +327,7 @@ parse_slave_arg(const char *key __rte_unused,
        struct scheduler_init_params *param = extra_args;
 
        if (param->nb_slaves >= RTE_CRYPTODEV_SCHEDULER_MAX_NB_SLAVES) {
-               CS_LOG_ERR("Too many slaves.\n");
+               CR_SCHED_LOG(ERR, "Too many slaves.");
                return -ENOMEM;
        }
 
@@ -353,7 +353,7 @@ parse_mode_arg(const char *key __rte_unused,
        }
 
        if (i == RTE_DIM(scheduler_mode_map)) {
-               CS_LOG_ERR("Unrecognized input.\n");
+               CR_SCHED_LOG(ERR, "Unrecognized input.");
                return -EINVAL;
        }
 
@@ -376,7 +376,7 @@ parse_ordering_arg(const char *key __rte_unused,
        }
 
        if (i == RTE_DIM(scheduler_ordering_map)) {
-               CS_LOG_ERR("Unrecognized input.\n");
+               CR_SCHED_LOG(ERR, "Unrecognized input.");
                return -EINVAL;
        }
 

diff --git a/drivers/crypto/scheduler/scheduler_pmd_ops.c b/drivers/crypto/scheduler/scheduler_pmd_ops.c
index 147dc51..8742058 100644 (file)
--- a/drivers/crypto/scheduler/scheduler_pmd_ops.c
+++ b/drivers/crypto/scheduler/scheduler_pmd_ops.c
@@ -27,7 +27,7 @@ scheduler_attach_init_slave(struct rte_cryptodev *dev)
                int status;
 
                if (!slave_dev) {
-                       CS_LOG_ERR("Failed to locate slave dev %s",
+                       CR_SCHED_LOG(ERR, "Failed to locate slave dev %s",
                                        dev_name);
                        return -EINVAL;
                }
@@ -36,12 +36,12 @@ scheduler_attach_init_slave(struct rte_cryptodev *dev)
                                scheduler_id, slave_dev->data->dev_id);
 
                if (status < 0) {
-                       CS_LOG_ERR("Failed to attach slave cryptodev %u",
+                       CR_SCHED_LOG(ERR, "Failed to attach slave cryptodev %u",
                                        slave_dev->data->dev_id);
                        return status;
                }
 
-               CS_LOG_INFO("Scheduler %s attached slave %s\n",
+               CR_SCHED_LOG(INFO, "Scheduler %s attached slave %s",
                                dev->data->name,
                                sched_ctx->init_slave_names[i]);
 
@@ -102,7 +102,7 @@ update_order_ring(struct rte_cryptodev *dev, uint16_t qp_id)
                if (snprintf(order_ring_name, RTE_CRYPTODEV_NAME_MAX_LEN,
                        "%s_rb_%u_%u", RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),
                        dev->data->dev_id, qp_id) < 0) {
-                       CS_LOG_ERR("failed to create unique reorder buffer "
+                       CR_SCHED_LOG(ERR, "failed to create unique reorder buffer"
                                        "name");
                        return -ENOMEM;
                }
@@ -111,7 +111,7 @@ update_order_ring(struct rte_cryptodev *dev, uint16_t qp_id)
                                buff_size, rte_socket_id(),
                                RING_F_SP_ENQ | RING_F_SC_DEQ);
                if (!qp_ctx->order_ring) {
-                       CS_LOG_ERR("failed to create order ring");
+                       CR_SCHED_LOG(ERR, "failed to create order ring");
                        return -ENOMEM;
                }
        } else {
@@ -145,18 +145,18 @@ scheduler_pmd_start(struct rte_cryptodev *dev)
        for (i = 0; i < dev->data->nb_queue_pairs; i++) {
                ret = update_order_ring(dev, i);
                if (ret < 0) {
-                       CS_LOG_ERR("Failed to update reorder buffer");
+                       CR_SCHED_LOG(ERR, "Failed to update reorder buffer");
                        return ret;
                }
        }
 
        if (sched_ctx->mode == CDEV_SCHED_MODE_NOT_SET) {
-               CS_LOG_ERR("Scheduler mode is not set");
+               CR_SCHED_LOG(ERR, "Scheduler mode is not set");
                return -1;
        }
 
        if (!sched_ctx->nb_slaves) {
-               CS_LOG_ERR("No slave in the scheduler");
+               CR_SCHED_LOG(ERR, "No slave in the scheduler");
                return -1;
        }
 
@@ -166,7 +166,7 @@ scheduler_pmd_start(struct rte_cryptodev *dev)
                uint8_t slave_dev_id = sched_ctx->slaves[i].dev_id;
 
                if ((*sched_ctx->ops.slave_attach)(dev, slave_dev_id) < 0) {
-                       CS_LOG_ERR("Failed to attach slave");
+                       CR_SCHED_LOG(ERR, "Failed to attach slave");
                        return -ENOTSUP;
                }
        }
@@ -174,7 +174,7 @@ scheduler_pmd_start(struct rte_cryptodev *dev)
        RTE_FUNC_PTR_OR_ERR_RET(*sched_ctx->ops.scheduler_start, -ENOTSUP);
 
        if ((*sched_ctx->ops.scheduler_start)(dev) < 0) {
-               CS_LOG_ERR("Scheduler start failed");
+               CR_SCHED_LOG(ERR, "Scheduler start failed");
                return -1;
        }
 
@@ -186,7 +186,7 @@ scheduler_pmd_start(struct rte_cryptodev *dev)
 
                ret = (*slave_dev->dev_ops->dev_start)(slave_dev);
                if (ret < 0) {
-                       CS_LOG_ERR("Failed to start slave dev %u",
+                       CR_SCHED_LOG(ERR, "Failed to start slave dev %u",
                                        slave_dev_id);
                        return ret;
                }
@@ -386,7 +386,7 @@ scheduler_pmd_qp_setup(struct rte_cryptodev *dev, uint16_t qp_id,
        if (snprintf(name, RTE_CRYPTODEV_NAME_MAX_LEN,
                        "CRYTO_SCHE PMD %u QP %u",
                        dev->data->dev_id, qp_id) < 0) {
-               CS_LOG_ERR("Failed to create unique queue pair name");
+               CR_SCHED_LOG(ERR, "Failed to create unique queue pair name");
                return -EFAULT;
        }
 
@@ -424,14 +424,14 @@ scheduler_pmd_qp_setup(struct rte_cryptodev *dev, uint16_t qp_id,
         */
        ret = scheduler_attach_init_slave(dev);
        if (ret < 0) {
-               CS_LOG_ERR("Failed to attach slave");
+               CR_SCHED_LOG(ERR, "Failed to attach slave");
                scheduler_pmd_qp_release(dev, qp_id);
                return ret;
        }
 
        if (*sched_ctx->ops.config_queue_pair) {
                if ((*sched_ctx->ops.config_queue_pair)(dev, qp_id) < 0) {
-                       CS_LOG_ERR("Unable to configure queue pair");
+                       CR_SCHED_LOG(ERR, "Unable to configure queue pair");
                        return -1;
                }
        }
@@ -498,7 +498,7 @@ scheduler_pmd_session_configure(struct rte_cryptodev *dev,
                ret = rte_cryptodev_sym_session_init(slave->dev_id, sess,
                                        xform, mempool);
                if (ret < 0) {
-                       CS_LOG_ERR("unabled to config sym session");
+                       CR_SCHED_LOG(ERR, "unable to config sym session");
                        return ret;
                }
        }

diff --git a/drivers/crypto/scheduler/scheduler_pmd_private.h b/drivers/crypto/scheduler/scheduler_pmd_private.h
index 12410b4..d5e602a 100644 (file)
--- a/drivers/crypto/scheduler/scheduler_pmd_private.h
+++ b/drivers/crypto/scheduler/scheduler_pmd_private.h
@@ -12,25 +12,11 @@
 
 #define PER_SLAVE_BUFF_SIZE                    (256)
 
-#define CS_LOG_ERR(fmt, args...)                                       \
-       RTE_LOG(ERR, CRYPTODEV, "[%s] %s() line %u: " fmt "\n",         \
-               RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),                  \
-               __func__, __LINE__, ## args)
-
-#ifdef RTE_LIBRTE_CRYPTO_SCHEDULER_DEBUG
-#define CS_LOG_INFO(fmt, args...)                                      \
-       RTE_LOG(INFO, CRYPTODEV, "[%s] %s() line %u: " fmt "\n",        \
-               RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),                  \
-               __func__, __LINE__, ## args)
-
-#define CS_LOG_DBG(fmt, args...)                                       \
-       RTE_LOG(DEBUG, CRYPTODEV, "[%s] %s() line %u: " fmt "\n",       \
-               RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),                  \
-               __func__, __LINE__, ## args)
-#else
-#define CS_LOG_INFO(fmt, args...)
-#define CS_LOG_DBG(fmt, args...)
-#endif
+extern int scheduler_logtype_driver;
+
+#define CR_SCHED_LOG(level, fmt, args...) \
+       rte_log(RTE_LOG_ ## level, scheduler_logtype_driver,            \
+                       "%s() line %u: "fmt "\n", __func__, __LINE__, ##args)
 
 struct scheduler_slave {
        uint8_t dev_id;

diff --git a/drivers/crypto/scheduler/scheduler_roundrobin.c b/drivers/crypto/scheduler/scheduler_roundrobin.c
index c6e03e2..c7082a6 100644 (file)
--- a/drivers/crypto/scheduler/scheduler_roundrobin.c
+++ b/drivers/crypto/scheduler/scheduler_roundrobin.c
@@ -175,7 +175,7 @@ scheduler_config_qp(struct rte_cryptodev *dev, uint16_t qp_id)
        rr_qp_ctx = rte_zmalloc_socket(NULL, sizeof(*rr_qp_ctx), 0,
                        rte_socket_id());
        if (!rr_qp_ctx) {
-               CS_LOG_ERR("failed allocate memory for private queue pair");
+               CR_SCHED_LOG(ERR, "failed allocate memory for private queue pair");
                return -ENOMEM;
        }