From 61912fcfdef3b29e22731b38fbb81dff47102568 Mon Sep 17 00:00:00 2001 From: Wenkai Lin 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 --- 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