log: introduce logtype register macro

[dpdk.git] / drivers / crypto / scheduler / rte_cryptodev_scheduler.c

diff --git a/drivers/crypto/scheduler/rte_cryptodev_scheduler.c b/drivers/crypto/scheduler/rte_cryptodev_scheduler.c
index 6e4919c..730504d 100644 (file)
--- a/drivers/crypto/scheduler/rte_cryptodev_scheduler.c
+++ b/drivers/crypto/scheduler/rte_cryptodev_scheduler.c
@@ -1,6 +1,7 @@
 /* SPDX-License-Identifier: BSD-3-Clause
  * Copyright(c) 2017 Intel Corporation
  */
+#include <rte_string_fns.h>
 #include <rte_reorder.h>
 #include <rte_cryptodev.h>
 #include <rte_cryptodev_pmd.h>
@@ -9,8 +10,6 @@
 #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
@@ -174,7 +173,7 @@ rte_cryptodev_scheduler_slave_attach(uint8_t scheduler_id, uint8_t slave_id)
                return -ENOTSUP;
        }
 
-       if (dev->driver_id != cryptodev_driver_id) {
+       if (dev->driver_id != cryptodev_scheduler_driver_id) {
                CR_SCHED_LOG(ERR, "Operation not supported");
                return -ENOTSUP;
        }
@@ -233,7 +232,7 @@ rte_cryptodev_scheduler_slave_detach(uint8_t scheduler_id, uint8_t slave_id)
                return -ENOTSUP;
        }
 
-       if (dev->driver_id != cryptodev_driver_id) {
+       if (dev->driver_id != cryptodev_scheduler_driver_id) {
                CR_SCHED_LOG(ERR, "Operation not supported");
                return -ENOTSUP;
        }
@@ -290,7 +289,7 @@ rte_cryptodev_scheduler_mode_set(uint8_t scheduler_id,
                return -ENOTSUP;
        }
 
-       if (dev->driver_id != cryptodev_driver_id) {
+       if (dev->driver_id != cryptodev_scheduler_driver_id) {
                CR_SCHED_LOG(ERR, "Operation not supported");
                return -ENOTSUP;
        }
@@ -308,28 +307,28 @@ rte_cryptodev_scheduler_mode_set(uint8_t scheduler_id,
        switch (mode) {
        case CDEV_SCHED_MODE_ROUNDROBIN:
                if (rte_cryptodev_scheduler_load_user_scheduler(scheduler_id,
-                               roundrobin_scheduler) < 0) {
+                               crypto_scheduler_roundrobin) < 0) {
                        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) {
+                               crypto_scheduler_pkt_size_based_distr) < 0) {
                        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) {
+                               crypto_scheduler_failover) < 0) {
                        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) {
+                               crypto_scheduler_multicore) < 0) {
                        CR_SCHED_LOG(ERR, "Failed to load scheduler");
                        return -1;
                }
@@ -353,7 +352,7 @@ rte_cryptodev_scheduler_mode_get(uint8_t scheduler_id)
                return -ENOTSUP;
        }
 
-       if (dev->driver_id != cryptodev_driver_id) {
+       if (dev->driver_id != cryptodev_scheduler_driver_id) {
                CR_SCHED_LOG(ERR, "Operation not supported");
                return -ENOTSUP;
        }
@@ -375,7 +374,7 @@ rte_cryptodev_scheduler_ordering_set(uint8_t scheduler_id,
                return -ENOTSUP;
        }
 
-       if (dev->driver_id != cryptodev_driver_id) {
+       if (dev->driver_id != cryptodev_scheduler_driver_id) {
                CR_SCHED_LOG(ERR, "Operation not supported");
                return -ENOTSUP;
        }
@@ -403,7 +402,7 @@ rte_cryptodev_scheduler_ordering_get(uint8_t scheduler_id)
                return -ENOTSUP;
        }
 
-       if (dev->driver_id != cryptodev_driver_id) {
+       if (dev->driver_id != cryptodev_scheduler_driver_id) {
                CR_SCHED_LOG(ERR, "Operation not supported");
                return -ENOTSUP;
        }
@@ -425,7 +424,7 @@ rte_cryptodev_scheduler_load_user_scheduler(uint8_t scheduler_id,
                return -ENOTSUP;
        }
 
-       if (dev->driver_id != cryptodev_driver_id) {
+       if (dev->driver_id != cryptodev_scheduler_driver_id) {
                CR_SCHED_LOG(ERR, "Operation not supported");
                return -ENOTSUP;
        }
@@ -443,8 +442,7 @@ rte_cryptodev_scheduler_load_user_scheduler(uint8_t scheduler_id,
                                RTE_CRYPTODEV_NAME_MAX_LEN);
                return -EINVAL;
        }
-       snprintf(sched_ctx->name, sizeof(sched_ctx->name), "%s",
-                       scheduler->name);
+       strlcpy(sched_ctx->name, scheduler->name, sizeof(sched_ctx->name));
 
        if (strlen(scheduler->description) >
                        RTE_CRYPTODEV_SCHEDULER_DESC_MAX_LEN - 1) {
@@ -453,8 +451,8 @@ rte_cryptodev_scheduler_load_user_scheduler(uint8_t scheduler_id,
                                RTE_CRYPTODEV_SCHEDULER_DESC_MAX_LEN - 1);
                return -EINVAL;
        }
-       snprintf(sched_ctx->description, sizeof(sched_ctx->description), "%s",
-                       scheduler->description);
+       strlcpy(sched_ctx->description, scheduler->description,
+               sizeof(sched_ctx->description));
 
        /* load scheduler instance operations functions */
        sched_ctx->ops.config_queue_pair = scheduler->ops->config_queue_pair;
@@ -498,7 +496,7 @@ rte_cryptodev_scheduler_slaves_get(uint8_t scheduler_id, uint8_t *slaves)
                return -ENOTSUP;
        }
 
-       if (dev->driver_id != cryptodev_driver_id) {
+       if (dev->driver_id != cryptodev_scheduler_driver_id) {
                CR_SCHED_LOG(ERR, "Operation not supported");
                return -ENOTSUP;
        }
@@ -566,7 +564,7 @@ rte_cryptodev_scheduler_option_get(uint8_t scheduler_id,
                return -EINVAL;
        }
 
-       if (dev->driver_id != cryptodev_driver_id) {
+       if (dev->driver_id != cryptodev_scheduler_driver_id) {
                CR_SCHED_LOG(ERR, "Operation not supported");
                return -ENOTSUP;
        }
@@ -578,7 +576,5 @@ rte_cryptodev_scheduler_option_get(uint8_t scheduler_id,
        return (*sched_ctx->ops.option_get)(dev, option_type, option);
 }
 
-RTE_INIT(scheduler_init_log)
-{
-       scheduler_logtype_driver = rte_log_register("pmd.crypto.scheduler");
-}
+
+RTE_LOG_REGISTER(scheduler_logtype_driver, pmd.crypto.scheduler, INFO);