packages/libwd
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
libwd/0080-uadk-unify-wd-print-format.patch

993 lines
30 KiB
Diff
Raw Normal View History

libwd backport for uadk from 2.3.29 to 2.3.31 Update some patch for uadk from mainline. To get more infomation, please visit the homepage: https://github.com/Linaro/uadk Signed-off-by: Wenkai Lin <linwenkai6@hisilicon.com>
2022-03-22 11:42:15 +08:00
From 61912fcfdef3b29e22731b38fbb81dff47102568 Mon Sep 17 00:00:00 2001
From: Wenkai Lin <linwenkai6@hisilicon.com>
Date: Thu, 10 Mar 2022 20:03:18 +0800
Subject: [PATCH 088/109] uadk: unify wd print format
Unify print format with following rules:
1. failed to do sth.
2. invalid: sth is NULL.
Signed-off-by: Wenkai Lin <linwenkai6@hisilicon.com>
---
drv/hisi_qm_udrv.c | 63 ++++++++++++++++++------------------
wd.c | 6 ++--
wd_mempool.c | 61 ++++++++++++++++++++--------------
wd_sched.c | 52 ++++++++++++++---------------
wd_util.c | 81 ++++++++++++++++++++--------------------------
5 files changed, 130 insertions(+), 133 deletions(-)
diff --git a/drv/hisi_qm_udrv.c b/drv/hisi_qm_udrv.c
index 906dfa3..be06570 100644
--- a/drv/hisi_qm_udrv.c
+++ b/drv/hisi_qm_udrv.c
@@ -167,14 +167,14 @@ static int hisi_qm_setup_region(handle_t h_ctx,
{
q_info->sq_base = wd_ctx_mmap_qfr(h_ctx, UACCE_QFRT_DUS);
if (!q_info->sq_base) {
- WD_ERR("mmap dus fail\n");
+ WD_ERR("failed to mmap dus!\n");
return -WD_ENOMEM;
}
q_info->mmio_base = wd_ctx_mmap_qfr(h_ctx, UACCE_QFRT_MMIO);
if (!q_info->mmio_base) {
wd_ctx_unmap_qfr(h_ctx, UACCE_QFRT_DUS);
- WD_ERR("mmap mmio fail\n");
+ WD_ERR("failed to mmap mmio!\n");
return -WD_ENOMEM;
}
@@ -197,14 +197,14 @@ static __u32 get_version_id(handle_t h_ctx)
api_name = wd_ctx_get_api(h_ctx);
if (!api_name || strlen(api_name) <= VERSION_ID_SHIFT) {
- WD_ERR("api name error = %s\n", api_name);
+ WD_ERR("invalid: api name is %s!\n", api_name);
return 0;
}
id = api_name + VERSION_ID_SHIFT;
ver = strtoul(id, NULL, 10);
if (!ver || ver == ULONG_MAX) {
- WD_ERR("fail to strtoul, ver = %lu\n", ver);
+ WD_ERR("failed to strtoul, ver = %lu!\n", ver);
return 0;
}
@@ -250,7 +250,7 @@ static int his_qm_set_qp_ctx(handle_t h_ctx, struct hisi_qm_priv *config,
q_info->qc_type = qp_ctx.qc_type;
ret = wd_ctx_set_io_cmd(h_ctx, UACCE_CMD_QM_SET_QP_CTX, &qp_ctx);
if (ret < 0) {
- WD_ERR("HISI QM fail to set qc_type, use default value\n");
+ WD_ERR("failed to set qc_type, use default value!\n");
return ret;
}
@@ -265,13 +265,13 @@ static int hisi_qm_get_qfrs_offs(handle_t h_ctx,
q_info->region_size[UACCE_QFRT_DUS] = wd_ctx_get_region_size(h_ctx,
UACCE_QFRT_DUS);
if (!q_info->region_size[UACCE_QFRT_DUS]) {
- WD_ERR("fail to get DUS qfrs offset.\n");
+ WD_ERR("failed to get DUS qfrs offset!\n");
return -WD_EINVAL;
}
q_info->region_size[UACCE_QFRT_MMIO] = wd_ctx_get_region_size(h_ctx,
UACCE_QFRT_MMIO);
if (!q_info->region_size[UACCE_QFRT_MMIO]) {
- WD_ERR("fail to get MMIO qfrs offset.\n");
+ WD_ERR("failed to get MMIO qfrs offset!\n");
return -WD_EINVAL;
}
@@ -286,25 +286,25 @@ static int hisi_qm_setup_info(struct hisi_qp *qp, struct hisi_qm_priv *config)
q_info = &qp->q_info;
ret = hisi_qm_setup_region(qp->h_ctx, q_info);
if (ret) {
- WD_ERR("setup region fail\n");
+ WD_ERR("failed to setup region!\n");
return ret;
}
ret = hisi_qm_get_qfrs_offs(qp->h_ctx, q_info);
if (ret) {
- WD_ERR("get dev qfrs offset fail.\n");
+ WD_ERR("failed to get dev qfrs offset!\n");
goto err_out;
}
ret = hisi_qm_setup_db(qp->h_ctx, q_info);
if (ret) {
- WD_ERR("setup db fail\n");
+ WD_ERR("failed to setup db!\n");
goto err_out;
}
ret = his_qm_set_qp_ctx(qp->h_ctx, config, q_info);
if (ret) {
- WD_ERR("setup io cmd fail\n");
+ WD_ERR("failed to setup io cmd!\n");
goto err_out;
}
@@ -320,7 +320,7 @@ static int hisi_qm_setup_info(struct hisi_qp *qp, struct hisi_qm_priv *config)
ret = pthread_spin_init(&q_info->lock, PTHREAD_PROCESS_SHARED);
if (ret) {
- WD_ERR("init qinfo lock fail\n");
+ WD_ERR("failed to init qinfo lock!\n");
goto err_out;
}
@@ -352,8 +352,8 @@ handle_t hisi_qm_alloc_qp(struct hisi_qm_priv *config, handle_t ctx)
if (!config)
goto out;
- if (config->sqe_size <= 0) {
- WD_ERR("invalid sqe size (%u)\n", config->sqe_size);
+ if (!config->sqe_size) {
+ WD_ERR("invalid: sqe size is zero!\n");
goto out;
}
@@ -367,7 +367,8 @@ handle_t hisi_qm_alloc_qp(struct hisi_qm_priv *config, handle_t ctx)
if (ret)
goto out_qp;
- qp->h_sgl_pool = hisi_qm_create_sglpool(HISI_SGL_NUM_IN_BD, HISI_SGE_NUM_IN_SGL);
+ qp->h_sgl_pool = hisi_qm_create_sglpool(HISI_SGL_NUM_IN_BD,
+ HISI_SGE_NUM_IN_SGL);
if (!qp->h_sgl_pool)
goto out_qp;
@@ -396,7 +397,7 @@ void hisi_qm_free_qp(handle_t h_qp)
struct hisi_qp *qp = (struct hisi_qp *)h_qp;
if (!qp) {
- WD_ERR("h_qp is NULL.\n");
+ WD_ERR("invalid: h_qp is NULL!\n");
return;
}
@@ -461,7 +462,7 @@ static int hisi_qm_recv_single(struct hisi_qm_queue_info *q_info, void *resp)
j = CQE_SQ_HEAD_INDEX(cqe);
if (j >= QM_Q_DEPTH) {
pthread_spin_unlock(&q_info->lock);
- WD_ERR("CQE_SQ_HEAD_INDEX(%u) error\n", j);
+ WD_ERR("CQE_SQ_HEAD_INDEX(%u) error!\n", j);
return -WD_EIO;
}
memcpy(resp, (void *)((uintptr_t)q_info->sq_base +
@@ -535,7 +536,7 @@ static void *hisi_qm_create_sgl(__u32 sge_num)
sge_num * (sizeof(struct hisi_sge)) + HISI_SGL_ALIGE;
sgl = calloc(1, size);
if (!sgl) {
- WD_ERR("failed to create sgl\n");
+ WD_ERR("failed to create sgl!\n");
return NULL;
}
@@ -562,36 +563,34 @@ handle_t hisi_qm_create_sglpool(__u32 sgl_num, __u32 sge_num)
int i, ret;
if (!sgl_num || !sge_num || sge_num > HISI_SGE_NUM_IN_SGL) {
- WD_ERR("create sgl_pool failed, sgl_num=%u, sge_num=%u\n",
+ WD_ERR("failed to create sgl_pool, sgl_num=%u, sge_num=%u!\n",
sgl_num, sge_num);
return 0;
}
sgl_pool = calloc(1, sizeof(struct hisi_sgl_pool));
if (!sgl_pool) {
- WD_ERR("sgl pool alloc memory failed.\n");
+ WD_ERR("failed to alloc memory for sgl_pool!\n");
return 0;
}
sgl_pool->sgl = calloc(sgl_num, sizeof(void *));
if (!sgl_pool->sgl) {
- WD_ERR("sgl array alloc memory failed.\n");
+ WD_ERR("failed to alloc memory for sgl!\n");
goto err_out;
}
sgl_pool->sgl_align = calloc(sgl_num, sizeof(void *));
if (!sgl_pool->sgl_align) {
- WD_ERR("sgl align array alloc memory failed.\n");
+ WD_ERR("failed to alloc memory for sgl align!\n");
goto err_out;
}
/* base the sgl_num create the sgl chain */
for (i = 0; i < sgl_num; i++) {
sgl_pool->sgl[i] = hisi_qm_create_sgl(sge_num);
- if (!sgl_pool->sgl[i]) {
- WD_ERR("sgl create failed.\n");
+ if (!sgl_pool->sgl[i])
goto err_out;
- }
sgl_pool->sgl_align[i] = hisi_qm_align_sgl(sgl_pool->sgl[i], sge_num);
}
@@ -602,7 +601,7 @@ handle_t hisi_qm_create_sglpool(__u32 sgl_num, __u32 sge_num)
sgl_pool->top = sgl_num;
ret = pthread_spin_init(&sgl_pool->lock, PTHREAD_PROCESS_SHARED);
if (ret) {
- WD_ERR("init sgl pool lock failed.\n");
+ WD_ERR("failed to init sgl pool lock!\n");
goto err_out;
}
@@ -619,7 +618,7 @@ void hisi_qm_destroy_sglpool(handle_t sgl_pool)
int i;
if (!pool) {
- WD_ERR("sgl_pool is NULL\n");
+ WD_ERR("invalid: sgl_pool is NULL!\n");
return;
}
if (pool->sgl) {
@@ -642,7 +641,7 @@ static struct hisi_sgl *hisi_qm_sgl_pop(struct hisi_sgl_pool *pool)
pthread_spin_lock(&pool->lock);
if (pool->top == 0) {
- WD_ERR("The sgl pool is empty\n");
+ WD_ERR("invalid: the sgl pool is empty!\n");
pthread_spin_unlock(&pool->lock);
return NULL;
}
@@ -657,7 +656,7 @@ static int hisi_qm_sgl_push(struct hisi_sgl_pool *pool, struct hisi_sgl *hw_sgl)
{
pthread_spin_lock(&pool->lock);
if (pool->top >= pool->depth) {
- WD_ERR("The sgl pool is full\n");
+ WD_ERR("invalid: the sgl pool is full!\n");
pthread_spin_unlock(&pool->lock);
return -WD_EINVAL;
}
@@ -705,7 +704,7 @@ void *hisi_qm_get_hw_sgl(handle_t sgl_pool, struct wd_datalist *sgl)
int i = 0;
if (!pool || !sgl) {
- WD_ERR("get hw sgl pool or sgl is NULL\n");
+ WD_ERR("invalid: hw sgl pool or sgl is NULL!\n");
return NULL;
}
@@ -723,7 +722,7 @@ void *hisi_qm_get_hw_sgl(handle_t sgl_pool, struct wd_datalist *sgl)
}
if (tmp->len > HISI_MAX_SIZE_IN_SGE) {
- WD_ERR("the data len is invalid: %u\n", tmp->len);
+ WD_ERR("invalid: the data len is %u!\n", tmp->len);
goto err_out;
}
@@ -742,7 +741,7 @@ void *hisi_qm_get_hw_sgl(handle_t sgl_pool, struct wd_datalist *sgl)
if (i == pool->sge_num && tmp->next) {
next = hisi_qm_sgl_pop(pool);
if (!next) {
- WD_ERR("the sgl pool is not enough\n");
+ WD_ERR("invalid: the sgl pool is not enough!\n");
goto err_out;
}
cur->next_dma = (uintptr_t)next;
diff --git a/wd.c b/wd.c
index b88ee62..0774837 100644
--- a/wd.c
+++ b/wd.c
@@ -59,14 +59,14 @@ static int get_raw_attr(const char *dev_root, const char *attr, char *buf,
fd = open(attr_path, O_RDONLY, 0);
if (fd < 0) {
- WD_ERR("open %s fail (%d)!\n", attr_path, -errno);
+ WD_ERR("failed to open %s(%d)!\n", attr_path, -errno);
return -WD_ENODEV;
}
memset(buf, 0, sz);
size = read(fd, buf, sz);
if (size <= 0) {
- WD_ERR("read nothing at %s!\n", attr_path);
+ WD_ERR("failed to read anything at %s!\n", attr_path);
size = -WD_EIO;
}
@@ -601,7 +601,7 @@ static int check_alg_name(const char *alg_name)
while (alg_name[i] != '\0') {
i++;
if (i >= MAX_ATTR_STR_SIZE) {
- WD_ERR("get list failed, alg name is too long!\n");
+ WD_ERR("failed to get list, alg name is too long!\n");
return -WD_EINVAL;
}
}
diff --git a/wd_mempool.c b/wd_mempool.c
index b6e1088..bfacd28 100644
--- a/wd_mempool.c
+++ b/wd_mempool.c
@@ -206,12 +206,17 @@ static __always_inline unsigned long wd_ffs(unsigned long word)
static struct bitmap *create_bitmap(int bits)
{
- struct bitmap *bm = calloc(1, sizeof(*bm));
- if (!bm)
+ struct bitmap *bm;
+
+ bm = calloc(1, sizeof(*bm));
+ if (!bm) {
+ WD_ERR("failed to alloc memory for bitmap!\n");
return NULL;
+ }
bm->map = calloc(BITS_TO_LONGS(bits), sizeof(unsigned long));
if (!bm->map) {
+ WD_ERR("failed to alloc memory for bitmap map!\n");
free(bm);
return NULL;
}
@@ -346,6 +351,7 @@ static int alloc_memzone(struct blkpool *bp, void *addr, size_t blk_num,
zone = calloc(1, sizeof(struct memzone));
if (!zone) {
+ WD_ERR("failed to alloc memory for memzone!\n");
return -ENOMEM;
}
@@ -389,7 +395,8 @@ static void free_mem_to_mempool(struct blkpool *bp)
static int check_mempool_real_size(struct mempool *mp, struct blkpool *bp)
{
if (bp->blk_size * bp->depth > mp->real_size) {
- WD_ERR("wd_mempool: mempool too small: %lu\n", mp->real_size);
+ WD_ERR("invalid: mempool size is too small: %lu!\n",
+ mp->real_size);
return -ENOMEM;
}
@@ -525,8 +532,10 @@ static int init_blkpool_elem(struct blkpool *bp)
int i;
bp->blk_elem = calloc(bp->depth, sizeof(void *));
- if (!bp->blk_elem)
+ if (!bp->blk_elem) {
+ WD_ERR("failed to alloc memory for blk_elem!\n");
return -ENOMEM;
+ }
TAILQ_FOREACH(iter, &bp->mz_list, node) {
for (i = 0; i < iter->blk_num; i++)
@@ -544,7 +553,7 @@ handle_t wd_blockpool_create(handle_t mempool, size_t block_size,
int ret;
if (!mp || !block_size || !block_num) {
- WD_ERR("wd_mempool: input parameter is invalid value\n");
+ WD_ERR("invalid: mempool is NULL or block param is 0!\n");
return (handle_t)(-WD_EINVAL);
}
@@ -552,8 +561,10 @@ handle_t wd_blockpool_create(handle_t mempool, size_t block_size,
return (handle_t)(-WD_EBUSY);
bp = calloc(1, sizeof(struct blkpool));
- if (!bp)
+ if (!bp) {
+ WD_ERR("failed to alloc memory for blkpool!\n");
return (handle_t)(-WD_ENOMEM);
+ }
bp->top = block_num;
bp->depth = block_num;
@@ -563,13 +574,13 @@ handle_t wd_blockpool_create(handle_t mempool, size_t block_size,
ret = alloc_mem_from_mempool(mp, bp);
if (ret < 0) {
- WD_ERR("wd_mempool: failed to allocate memory from mempool\n");
+ WD_ERR("failed to allocate memory from mempool!\n");
goto err_free_bp;
}
ret = init_blkpool_elem(bp);
if (ret < 0) {
- WD_ERR("wd_mempool: failed to init blkpool\n");
+ WD_ERR("failed to init blkpool!\n");
goto err_free_mem;
}
@@ -590,7 +601,7 @@ void wd_blockpool_destroy(handle_t blkpool)
struct mempool *mp;
if (!bp) {
- WD_ERR("wd_mempool: blkpool is NULL\n");
+ WD_ERR("invalid: blkpool is NULL!\n");
return;
}
@@ -620,13 +631,13 @@ static int get_value_from_sysfs(const char *path, ssize_t path_size)
fd = open(dev_path, O_RDONLY, 0);
if (fd < 0) {
- WD_ERR("wd_mempool: failed to open %s\n", dev_path);
+ WD_ERR("failed to open %s!\n", dev_path);
goto err_open;
}
size = read(fd, buf, sizeof(buf));
if (size <= 0) {
- WD_ERR("wd_mempool: failed to read %s\n", dev_path);
+ WD_ERR("failed to read %s!\n", dev_path);
goto err_read;
}
@@ -716,7 +727,7 @@ static int get_hugepage_info(struct mempool *mp)
dir = opendir(hugepage_path);
if (!dir) {
- WD_ERR("wd_mempool: failed to open %s\n", hugepage_path);
+ WD_ERR("failed to open %s\n!", hugepage_path);
return -errno;
}
@@ -728,13 +739,13 @@ static int get_hugepage_info(struct mempool *mp)
tmp = calloc(1, sizeof(*tmp));
if (!tmp) {
- WD_ERR("wd_mempool: failed to calloc\n");
+ WD_ERR("failed to calloc for sys_hugepage_config!\n");
goto err_free_list;
}
ret = get_hugepage_info_per_type(hugepage_path, MAX_HP_STR_SIZE,
hp_dir, tmp);
if (ret < 0) {
- WD_ERR("wd_mempool: failed to get hugepage info\n");
+ WD_ERR("failed to get hugepage info!\n");
goto err_free;
}
@@ -779,7 +790,7 @@ static int mbind_memory(void *addr, size_t size, int node)
node_mask = 1U << (unsigned int)node;
ret = mbind(addr, size, MPOL_BIND, &node_mask, max_node, 0);
if (ret < 0) {
- WD_ERR("wd_mempool: failed to mbind memory, %d\n", ret);
+ WD_ERR("failed to mbind memory, ret is %d!\n", ret);
return ret;
}
@@ -805,7 +816,7 @@ static int alloc_mem_from_hugepage(struct mempool *mp)
break;
}
if (!iter) {
- WD_ERR("wd_mempool: failed to find proper hugepage\n");
+ WD_ERR("failed to find proper hugepage!\n");
ret = -ENOMEM;
goto err_put_info;
}
@@ -826,7 +837,7 @@ static int alloc_mem_from_hugepage(struct mempool *mp)
p = mmap(NULL, real_size, PROT_READ | PROT_WRITE, MAP_PRIVATE |
MAP_ANONYMOUS | MAP_HUGETLB | flags, -1, 0);
if (p == MAP_FAILED) {
- WD_ERR("wd_mempool: failed to allocate huge page\n");
+ WD_ERR("failed to allocate huge page!\n");
ret = -ENOMEM;
goto err_put_info;
}
@@ -862,7 +873,7 @@ static int alloc_mempool_memory(struct mempool *mp)
ret = alloc_mem_from_hugepage(mp);
if (ret) {
- WD_ERR("wd_mempool: failed to alloc memory from hugepage\n");
+ WD_ERR("failed to alloc memory from hugepage!\n");
return -ENOMEM;
}
@@ -908,8 +919,10 @@ handle_t wd_mempool_create(size_t size, int node)
size += WD_MEMPOOL_BLOCK_SIZE - (WD_MEMPOOL_SIZE_MASK & size);
mp = calloc(1, sizeof(*mp));
- if (!mp)
+ if (!mp) {
+ WD_ERR("failed to alloc memory for mempool!\n");
return (handle_t)(-WD_ENOMEM);
+ }
mp->node = node;
mp->size = size;
@@ -938,7 +951,7 @@ void wd_mempool_destroy(handle_t mempool)
struct mempool *mp = (struct mempool *)mempool;
if (!mp) {
- WD_ERR("wd_mempool: mempool is NULL\n");
+ WD_ERR("invalid: mempool is NULL!\n");
return;
}
@@ -954,12 +967,12 @@ void wd_mempool_stats(handle_t mempool, struct wd_mempool_stats *stats)
struct mempool *mp = (struct mempool *)mempool;
if (!mp) {
- WD_ERR("wd_mempool: mempool is NULL\n");
+ WD_ERR("invalid: mempool is NULL!\n");
return;
}
if (!stats) {
- WD_ERR("wd_mempool: mempool stats is NULL\n");
+ WD_ERR("invalid: mempool stats is NULL!\n");
return;
}
@@ -984,7 +997,7 @@ void wd_blockpool_stats(handle_t blkpool, struct wd_blockpool_stats *stats)
struct memzone *iter;
if (!bp || !stats) {
- WD_ERR("wd_mempool: blkpool or stats is NULL\n");
+ WD_ERR("invalid: blkpool or stats is NULL!\n");
return;
}
@@ -1001,7 +1014,7 @@ void wd_blockpool_stats(handle_t blkpool, struct wd_blockpool_stats *stats)
}
if (!size) {
- WD_ERR("wd_mempool: blkpool size is zero\n");
+ WD_ERR("invalid: blkpool size is zero!\n");
wd_unspinlock(&bp->lock);
return;
}
diff --git a/wd_sched.c b/wd_sched.c
index ef90233..9b1998c 100644
--- a/wd_sched.c
+++ b/wd_sched.c
@@ -129,8 +129,8 @@ static bool sched_key_valid(struct wd_sched_ctx *ctx,
{
if (key->numa_id >= ctx->numa_num || key->mode >= SCHED_MODE_BUTT ||
key->type >= ctx->type_num) {
- WD_ERR("ERROR: %s key error - numa: %d, mode: %u, type: %u!\n",
- __FUNCTION__, key->numa_id, key->mode, key->type);
+ WD_ERR("invalid: sched key's numa: %d, mode: %u, type: %u!\n",
+ key->numa_id, key->mode, key->type);
return false;
}
@@ -207,13 +207,13 @@ static int session_sched_poll_policy(handle_t sched_ctx,
__u16 i;
int ret;
- if (!sched_ctx || !count || !ctx) {
- WD_ERR("ERROR: %s the para is NULL!\n", __FUNCTION__);
+ if (!count || !ctx) {
+ WD_ERR("invalid: sched ctx is NULL or count is zero!\n");
return -WD_EINVAL;
}
if (ctx->numa_num > NUMA_NUM_NODES) {
- WD_ERR("ERROR: %s ctx numa num is invalid!\n", __FUNCTION__);
+ WD_ERR("invalid: ctx's numa number is %d!\n", ctx->numa_num);
return -WD_EINVAL;
}
@@ -270,16 +270,14 @@ static __u32 session_sched_init_ctx(handle_t sched_ctx,
bool ret;
if (!ctx || !key) {
- WD_ERR("ERROR: %s the pointer para is NULL!\n", __FUNCTION__);
+ WD_ERR("invalid: sched ctx or key is NULL!\n");
return INVALID_POS;
}
key->mode = sched_mode;
ret = sched_key_valid(ctx, key);
- if (!ret) {
- WD_ERR("ERROR: %s the key is invalid!\n", __FUNCTION__);
+ if (!ret)
return INVALID_POS;
- }
region = sched_get_ctx_range(ctx, key);
if (!region)
@@ -295,7 +293,7 @@ handle_t session_sched_init(handle_t h_sched_ctx, void *sched_param)
skey = malloc(sizeof(struct sched_key));
if (!skey) {
- WD_ERR("fail to alloc session sched key!\n");
+ WD_ERR("failed to alloc memory for session sched key!\n");
return (handle_t)(-WD_ENOMEM);
}
@@ -328,7 +326,7 @@ static __u32 session_sched_pick_next_ctx(handle_t sched_ctx,
struct sched_key *key = (struct sched_key *)sched_key;
if (unlikely(!sched_ctx || !key)) {
- WD_ERR("ERROR: %s the pointer para is NULL!\n", __FUNCTION__);
+ WD_ERR("invalid: sched ctx or key is NULL!\n");
return INVALID_POS;
}
@@ -357,13 +355,12 @@ int wd_sched_rr_instance(const struct wd_sched *sched,
int numa_id;
if (!sched || !sched->h_sched_ctx || !param) {
- WD_ERR("ERROR: %s para err: sched of h_sched_ctx is NULL!\n",
- __FUNCTION__);
+ WD_ERR("invalid: sched or sched_params is NULL!\n");
return -WD_EINVAL;
}
if (param->begin > param->end) {
- WD_ERR("ERROR: sched_params's begin is larger than end!\n");
+ WD_ERR("invalid: sched_params's begin is larger than end!\n");
return -WD_EINVAL;
}
@@ -373,28 +370,28 @@ int wd_sched_rr_instance(const struct wd_sched *sched,
sched_ctx = (struct wd_sched_ctx *)sched->h_sched_ctx;
if (numa_id >= sched_ctx->numa_num || numa_id < 0) {
- WD_ERR("ERROR: %s para err: numa_id = %d, numa_num = %u\n",
- __FUNCTION__, numa_id, sched_ctx->numa_num);
+ WD_ERR("invalid: sched_ctx's numa_id is %d, numa_num is %u!\n",
+ numa_id, sched_ctx->numa_num);
return -WD_EINVAL;
}
if (type >= sched_ctx->type_num) {
- WD_ERR("ERROR: %s para err: type = %u, type_num = %u\n",
- __FUNCTION__, type, sched_ctx->type_num);
+ WD_ERR("invalid: sched_ctx's type is %u, type_num is %u!\n",
+ type, sched_ctx->type_num);
return -WD_EINVAL;
}
if (mode >= SCHED_MODE_BUTT) {
- WD_ERR("ERROR: %s para err: mode = %u, mode_num = %d!\n",
- __FUNCTION__, mode, SCHED_MODE_BUTT);
+ WD_ERR("invalid: sched_ctx's mode is %u, mode_num is %d!\n",
+ mode, SCHED_MODE_BUTT);
return -WD_EINVAL;
}
sched_info = sched_ctx->sched_info;
if (!sched_info[numa_id].ctx_region[mode]) {
- WD_ERR("ERROR: %s ctx_region of numa_id = %d, mode = %u is NULL!\n",
- __FUNCTION__, numa_id, mode);
+ WD_ERR("invalid: ctx_region is NULL, numa: %d, mode: %u!\n",
+ numa_id, mode);
return -WD_EINVAL;
}
@@ -454,27 +451,26 @@ struct wd_sched *wd_sched_rr_alloc(__u8 sched_type, __u8 type_num,
return NULL;
if (!numa_num || numa_num > max_node) {
- WD_ERR("Error: %s numa number = %u!\n", __FUNCTION__,
- numa_num);
+ WD_ERR("invalid: numa number is %u!\n", numa_num);
return NULL;
}
if (sched_type >= SCHED_POLICY_BUTT || !type_num) {
- WD_ERR("Error: %s sched_type = %u or type_num = %u is invalid!\n",
- __FUNCTION__, sched_type, type_num);
+ WD_ERR("invalid: sched_type is %u or type_num is %u!\n",
+ sched_type, type_num);
return NULL;
}
sched = calloc(1, sizeof(struct wd_sched));
if (!sched) {
- WD_ERR("Error: %s wd_sched alloc error!\n", __FUNCTION__);
+ WD_ERR("failed to alloc memory for wd_sched!\n");
return NULL;
}
sched_ctx = calloc(1, sizeof(struct wd_sched_ctx) +
sizeof(struct wd_sched_info) * numa_num);
if (!sched_ctx) {
- WD_ERR("Error: %s sched_ctx alloc error!\n", __FUNCTION__);
+ WD_ERR("failed to alloc memory for sched_ctx!\n");
goto err_out;
}
diff --git a/wd_util.c b/wd_util.c
index 44c8909..03316b6 100644
--- a/wd_util.c
+++ b/wd_util.c
@@ -74,7 +74,7 @@ int wd_init_ctx_config(struct wd_ctx_config_internal *in,
int i, ret;
if (!cfg->ctx_num) {
- WD_ERR("invalid parameters, ctx_num is 0!\n");
+ WD_ERR("invalid: ctx_num is 0!\n");
return -WD_EINVAL;
}
@@ -90,7 +90,7 @@ int wd_init_ctx_config(struct wd_ctx_config_internal *in,
for (i = 0; i < cfg->ctx_num; i++) {
if (!cfg->ctxs[i].ctx) {
- WD_ERR("invalid parameters, ctx is NULL!\n");
+ WD_ERR("invalid: ctx is NULL!\n");
free(ctxs);
return -WD_EINVAL;
}
@@ -98,7 +98,7 @@ int wd_init_ctx_config(struct wd_ctx_config_internal *in,
clone_ctx_to_internal(cfg->ctxs + i, ctxs + i);
ret = pthread_spin_init(&ctxs[i].lock, PTHREAD_PROCESS_SHARED);
if (ret) {
- WD_ERR("init ctxs lock failed!\n");
+ WD_ERR("failed to init ctxs lock!\n");
free(ctxs);
return ret;
}
@@ -243,7 +243,7 @@ void *wd_find_msg_in_pool(struct wd_async_msg_pool *pool,
/* tag value start from 1 */
if (tag == 0 || tag > msg_num) {
- WD_ERR("invalid message cache tag(%u)\n", tag);
+ WD_ERR("invalid: message cache tag is %u!\n", tag);
return NULL;
}
@@ -279,7 +279,7 @@ void wd_put_msg_to_pool(struct wd_async_msg_pool *pool, int ctx_idx, __u32 tag)
/* tag value start from 1 */
if (!tag || tag > msg_num) {
- WD_ERR("invalid message cache idx(%u)\n", tag);
+ WD_ERR("invalid: message cache idx is %u!\n", tag);
return;
}
@@ -318,14 +318,11 @@ void dump_env_info(struct wd_env_config *config)
config_numa->async_ctx_num);
for (j = 0; j < CTX_MODE_MAX; j++)
for (k = 0; k < config_numa->op_type_num; k++) {
- WD_ERR("-> %s: %d: [%d][%d].begin: %u\n",
- __func__,
+ WD_ERR("-> %d: [%d][%d].begin: %u\n",
i, j, k, ctx_table[j][k].begin);
- WD_ERR("-> %s: %d: [%d][%d].end: %u\n",
- __func__,
+ WD_ERR("-> %d: [%d][%d].end: %u\n",
i, j, k, ctx_table[j][k].end);
- WD_ERR("-> %s: %d: [%d][%d].size: %u\n",
- __func__,
+ WD_ERR("-> %d: [%d][%d].size: %u\n",
i, j, k, ctx_table[j][k].size);
}
}
@@ -340,8 +337,10 @@ static void *wd_get_config_numa(struct wd_env_config *config, int node)
if (config_numa->node == node)
break;
- if (i == config->numa_num)
+ if (i == config->numa_num) {
+ WD_ERR("invalid: missing numa node is %d!\n", node);
return NULL;
+ }
return config_numa;
}
@@ -373,7 +372,7 @@ static __u16 wd_get_dev_numa(struct uacce_dev_list *head,
if (list->dev->numa_id < 0) {
list->dev->numa_id = 0;
} else if (list->dev->numa_id >= size) {
- WD_ERR("numa id is wrong(%d)\n", list->dev->numa_id);
+ WD_ERR("invalid: numa id is %d!\n", list->dev->numa_id);
return 0;
}
@@ -396,10 +395,8 @@ static void wd_set_numa_dev(struct uacce_dev_list *head,
while (list) {
config_numa = wd_get_config_numa(config, list->dev->numa_id);
- if (!config_numa) {
- WD_ERR("%s got wrong numa node!\n", __func__);
+ if (!config_numa)
break;
- }
dev = config_numa->dev + config_numa->dev_num;
memcpy(dev, list->dev, sizeof(*list->dev));
@@ -457,7 +454,7 @@ static int wd_alloc_numa(struct wd_env_config *config,
/* get uacce_dev */
head = wd_get_accel_list(ops->alg_name);
if (!head) {
- WD_ERR("no device to support %s\n", ops->alg_name);
+ WD_ERR("invalid: no device to support %s\n", ops->alg_name);
ret = -WD_ENODEV;
goto free_numa_dev_num;
}
@@ -465,7 +462,7 @@ static int wd_alloc_numa(struct wd_env_config *config,
/* get numa num and device num of each numa from uacce_dev list */
config->numa_num = wd_get_dev_numa(head, numa_dev_num, max_node);
if (config->numa_num == 0 || config->numa_num > max_node) {
- WD_ERR("numa num err(%u)!\n", config->numa_num);
+ WD_ERR("invalid: numa number is %u!\n", config->numa_num);
ret = -WD_ENODEV;
goto free_list;
}
@@ -519,13 +516,13 @@ int wd_parse_async_poll_en(struct wd_env_config *config, const char *s)
int tmp;
if (!is_number(s)) {
- WD_ERR("invalid async poll en flag: %s!\n", s);
+ WD_ERR("invalid: async poll en flag is %s!\n", s);
return -WD_EINVAL;
}
tmp = strtol(s, NULL, 10);
if (tmp != 0 && tmp != 1) {
- WD_ERR("async poll en flag is not 0 or 1!\n");
+ WD_ERR("invalid: async poll en flag is not 0 or 1!\n");
return -WD_EINVAL;
}
@@ -539,7 +536,7 @@ static int parse_num_on_numa(const char *s, int *num, int *node)
char *sep, *start, *left;
if (!strlen(s)) {
- WD_ERR("input string length is zero!\n");
+ WD_ERR("invalid: input string length is zero!\n");
return -WD_EINVAL;
}
@@ -560,7 +557,7 @@ static int parse_num_on_numa(const char *s, int *num, int *node)
}
out:
- WD_ERR("input env format is invalid:%s\n", s);
+ WD_ERR("invalid: input env format is %s!\n", s);
free(start);
return -WD_EINVAL;
}
@@ -658,7 +655,7 @@ static int wd_parse_section(struct wd_env_config *config, char *section)
ctx_section = index(section, ':');
if (!ctx_section) {
- WD_ERR("%s got wrong format: %s!\n", __func__, section);
+ WD_ERR("invalid: ctx section got wrong format: %s!\n", section);
return -WD_EINVAL;
}
@@ -669,10 +666,8 @@ static int wd_parse_section(struct wd_env_config *config, char *section)
return ret;
config_numa = wd_get_config_numa(config, node);
- if (!config_numa) {
- WD_ERR("%s got wrong numa node: %s!\n", __func__, section);
+ if (!config_numa)
return -WD_EINVAL;
- }
config_numa->op_type_num = config->op_type_num;
ret = wd_alloc_ctx_table_per_numa(config_numa);
@@ -681,7 +676,8 @@ static int wd_parse_section(struct wd_env_config *config, char *section)
ret = get_and_fill_ctx_num(config_numa, section, ctx_num);
if (ret) {
- WD_ERR("%s got wrong ctx type: %s!\n", __func__, section);
+ WD_ERR("invalid: ctx section got wrong ctx type: %s!\n",
+ section);
wd_free_ctx_table_per_numa(config_numa);
return ret;
}
@@ -798,8 +794,6 @@ int wd_parse_async_poll_num(struct wd_env_config *config, const char *s)
goto out;
config_numa = wd_get_config_numa(config, node);
if (!config_numa) {
- WD_ERR("%s got wrong numa node: %s!\n",
- __func__, section);
ret = -WD_EINVAL;
goto out;
}
@@ -831,7 +825,7 @@ static int wd_parse_env(struct wd_env_config *config)
ret = var->parse_fn(config, var_s);
if (ret) {
- WD_ERR("fail to parse %s environment variable!\n",
+ WD_ERR("failed to parse %s environment variable!\n",
var->name);
return -WD_EINVAL;
}
@@ -847,10 +841,8 @@ static int wd_parse_ctx_attr(struct wd_env_config *env_config,
int ret;
config_numa = wd_get_config_numa(env_config, attr->node);
- if (!config_numa) {
- WD_ERR("%s got wrong numa node!\n", __func__);
+ if (!config_numa)
return -WD_EINVAL;
- }
config_numa->op_type_num = env_config->op_type_num;
ret = wd_alloc_ctx_table_per_numa(config_numa);
@@ -958,7 +950,7 @@ static int wd_get_wd_ctx(struct wd_env_config_per_numa *config,
h_ctx = request_ctx_on_numa(config);
if (!h_ctx) {
ret = -WD_EBUSY;
- WD_ERR("err: request too many ctxs\n");
+ WD_ERR("failed to request more ctxs!\n");
goto free_ctx;
}
@@ -1149,7 +1141,7 @@ static struct async_task_queue *find_async_queue(struct wd_env_config *config,
}
if (!config_numa->async_poll_num) {
- WD_ERR("invalid parameter, async_poll_num of numa is zero!\n");
+ WD_ERR("invalid: async_poll_num of numa is zero!\n");
return NULL;
}
@@ -1304,17 +1296,17 @@ static int wd_init_one_task_queue(struct async_task_queue *task_queue,
task_queue->alg_poll_ctx = alg_poll_ctx;
if (sem_init(&task_queue->empty_sem, 0, depth)) {
- WD_ERR("empty_sem init failed.\n");
+ WD_ERR("failed to init empty_sem!\n");
goto err_free_head;
}
if (sem_init(&task_queue->full_sem, 0, 0)) {
- WD_ERR("full_sem init failed.\n");
+ WD_ERR("failed to init full_sem!\n");
goto err_uninit_empty_sem;
}
if (pthread_mutex_init(&task_queue->lock, NULL)) {
- WD_ERR("mutex init failed.\n");
+ WD_ERR("failed to init task queue's mutex lock!\n");
goto err_uninit_full_sem;
}
@@ -1323,7 +1315,7 @@ static int wd_init_one_task_queue(struct async_task_queue *task_queue,
task_queue->tid = 0;
if (pthread_create(&thread_id, &attr, async_poll_process_func,
task_queue)) {
- WD_ERR("create poll thread failed.\n");
+ WD_ERR("failed to create poll thread!\n");
goto err_destory_mutex;
}
@@ -1547,18 +1539,15 @@ int wd_alg_get_env_param(struct wd_env_config *env_config,
struct wd_env_config_per_numa *config_numa;
if (!num || !is_enable) {
- WD_ERR("input parameter num or is_enable is NULL!\n");
+ WD_ERR("invalid: input pointer num or is_enable is NULL!\n");
return -WD_EINVAL;
}
*is_enable = env_config->enable_internal_poll;
config_numa = wd_get_config_numa(env_config, attr.node);
- if (!config_numa) {
- WD_ERR("%s got wrong numa node: %u!\n",
- __func__, attr.node);
+ if (!config_numa)
return -WD_EINVAL;
- }
*num = (config_numa->ctx_table) ?
config_numa->ctx_table[attr.mode][attr.type].size : 0;
@@ -1570,7 +1559,7 @@ int wd_set_ctx_attr(struct wd_ctx_attr *ctx_attr,
__u32 node, __u32 type, __u8 mode, __u32 num)
{
if (mode >= CTX_MODE_MAX) {
- WD_ERR("wrong ctx mode(%u))!\n", mode);
+ WD_ERR("invalid: ctx mode is %u!\n", mode);
return -WD_EINVAL;
}
@@ -1594,7 +1583,7 @@ int wd_check_ctx(struct wd_ctx_config_internal *config, __u8 mode, __u32 idx)
ctx = config->ctxs + idx;
if (ctx->ctx_mode != mode) {
- WD_ERR("ctx %u mode = %hhu error!\n", idx, ctx->ctx_mode);
+ WD_ERR("invalid: ctx(%u) mode is %hhu!\n", idx, ctx->ctx_mode);
return -WD_EINVAL;
}
--
2.27.0
Reference in New Issue Copy Permalink