From f3acd9c4dbf618ec5f40c14aaa30d5d5005ab73c Mon Sep 17 00:00:00 2001 From: zhoulingjuan Date: Mon, 29 Dec 2025 12:17:47 +0800 Subject: [PATCH] umq: memory module supports increasing the blk_size by one level description: memory module supports increasing the blk_size by one level --- .../include/umq/transport_layer/umq_tp_api.h | 8 ++ src/urpc/include/umq/umq_api.h | 9 ++ src/urpc/include/umq/umq_types.h | 5 + src/urpc/umq/qbuf/umq_huge_qbuf_pool.c | 116 +++++++----------- src/urpc/umq/qbuf/umq_huge_qbuf_pool.h | 1 + src/urpc/umq/qbuf/umq_qbuf_pool.h | 34 +++-- src/urpc/umq/umq_api.c | 11 ++ src/urpc/umq/umq_ub/core/private/umq_ub.c | 7 +- .../umq/umq_ub/core/private/umq_ub_private.h | 3 +- src/urpc/umq/umq_ub/core/umq_ub_impl.c | 8 ++ src/urpc/umq/umq_ub/core/umq_ub_impl.h | 1 + src/urpc/umq/umq_ub/umq_ub_api.c | 6 + src/urpc/umq/umq_ub/umq_ub_plus_api.c | 6 + src/urpc/umq/umq_ubmm/umq_ubmm_impl.c | 2 - 14 files changed, 125 insertions(+), 92 deletions(-) diff --git a/src/urpc/include/umq/transport_layer/umq_tp_api.h b/src/urpc/include/umq/transport_layer/umq_tp_api.h index 55ad817..d7cab57 100644 --- a/src/urpc/include/umq/transport_layer/umq_tp_api.h +++ b/src/urpc/include/umq/transport_layer/umq_tp_api.h @@ -252,6 +252,14 @@ typedef struct umq_ops { * Return: 0 on success, other value on error */ int (*umq_tp_mempool_state_refresh)(uint64_t umqh_tp, uint32_t mempool_id); + + /** + * Get queue cfg. + * @param[in] umqh_tp: umq tp handle + * @param[out] cfg: the address to put cfg + * Return: 0 on success, other value on error + */ + int (*umq_tp_cfg_get)(uint64_t umqh_tp, umq_cfg_get_t *cfg); } umq_ops_t; typedef umq_ops_t* (*umq_ops_get_t)(void); diff --git a/src/urpc/include/umq/umq_api.h b/src/urpc/include/umq/umq_api.h index 44f4d7b..cee720a 100644 --- a/src/urpc/include/umq/umq_api.h +++ b/src/urpc/include/umq/umq_api.h @@ -295,6 +295,15 @@ int umq_mempool_state_get(uint64_t umqh, uint32_t mempool_id, umq_mempool_state_ */ int umq_mempool_state_refresh(uint64_t umqh, uint32_t mempool_id); +/** + * Get umq handle configuration + * @param[in] urpc_qh: umq handle (umqh) + * @param[out] cfg: Configuration information for the umq (cfg) + * Return UMQ_SUCCESS on success, error code on failure, the specific error code is as follows + * -URPC_ERR_EINVAL: Invalid parameter + */ +int umq_queue_cfg_get(uint64_t umqh, umq_cfg_get_t *cfg); + #ifdef __cplusplus } #endif diff --git a/src/urpc/include/umq/umq_types.h b/src/urpc/include/umq/umq_types.h index 9d5ca7d..bdc1b72 100644 --- a/src/urpc/include/umq/umq_types.h +++ b/src/urpc/include/umq/umq_types.h @@ -530,6 +530,11 @@ typedef struct umq_mempool_state { mempool_import_state_t import_state; } umq_mempool_state_t; +typedef struct umq_cfg_get { + uint8_t max_rx_sge; // max sge number of receive array + uint8_t max_tx_sge; // max sge number of send array +} umq_cfg_get_t; + #ifdef __cplusplus } #endif diff --git a/src/urpc/umq/qbuf/umq_huge_qbuf_pool.c b/src/urpc/umq/qbuf/umq_huge_qbuf_pool.c index 68149f4..f15a425 100644 --- a/src/urpc/umq/qbuf/umq_huge_qbuf_pool.c +++ b/src/urpc/umq/qbuf/umq_huge_qbuf_pool.c @@ -53,6 +53,7 @@ static uint32_t (*g_huge_pool_size[HUGE_QBUF_POOL_SIZE_TYPE_MAX])(void) = { umq_buf_size_middle, umq_buf_size_big, umq_buf_size_huge, + umq_buf_size_gigantic, }; static int umq_huge_qbuf_pool_init(huge_qbuf_pool_size_type_t type, huge_pool_t *pool) @@ -122,8 +123,10 @@ huge_qbuf_pool_size_type_t umq_huge_qbuf_get_type_by_size(uint32_t buf_size) type = HUGE_QBUF_POOL_SIZE_TYPE_MID; } else if (buf_size < umq_buf_size_huge()) { type = HUGE_QBUF_POOL_SIZE_TYPE_BIG; - } else { + } else if (buf_size < umq_buf_size_gigantic()){ type = HUGE_QBUF_POOL_SIZE_TYPE_HUGE; + } else { + type = HUGE_QBUF_POOL_SIZE_TYPE_GIGANTIC; } return type; @@ -140,9 +143,12 @@ uint32_t umq_huge_qbuf_get_size_by_type(huge_qbuf_pool_size_type_t type) case HUGE_QBUF_POOL_SIZE_TYPE_BIG: blk_size = umq_buf_size_big(); break; - case HUGE_QBUF_POOL_SIZE_TYPE_HUGE: + case HUGE_QBUF_POOL_SIZE_TYPE_HUGE: blk_size = umq_buf_size_huge(); break; + case HUGE_QBUF_POOL_SIZE_TYPE_GIGANTIC: + blk_size = umq_buf_size_gigantic(); + break; default: break; } @@ -402,15 +408,18 @@ int umq_huge_qbuf_alloc(huge_qbuf_pool_size_type_t type, uint32_t request_size, static huge_qbuf_pool_size_type_t umq_huge_qbuf_get_type_by_mempool_id(uint32_t mempool_id) { huge_qbuf_pool_size_type_t type; - uint32_t mid_big = HUGE_QBUF_POOL_IDX_SHIFT + HUGE_QBUF_POOL_NUM_MAX; - uint32_t big_huge = HUGE_QBUF_POOL_IDX_SHIFT + (HUGE_QBUF_POOL_NUM_MAX << 1); + uint32_t mid_big = g_huge_pool_ctx.pool[HUGE_QBUF_POOL_SIZE_TYPE_BIG].pool_idx_shift; + uint32_t big_huge = g_huge_pool_ctx.pool[HUGE_QBUF_POOL_SIZE_TYPE_HUGE].pool_idx_shift; + uint32_t huge_gigantic = g_huge_pool_ctx.pool[HUGE_QBUF_POOL_SIZE_TYPE_GIGANTIC].pool_idx_shift; if (mempool_id < mid_big) { type = HUGE_QBUF_POOL_SIZE_TYPE_MID; } else if (mempool_id < big_huge) { type = HUGE_QBUF_POOL_SIZE_TYPE_BIG; - } else { + } else if (mempool_id < huge_gigantic) { type = HUGE_QBUF_POOL_SIZE_TYPE_HUGE; + } else { + type = HUGE_QBUF_POOL_SIZE_TYPE_GIGANTIC; } return type; @@ -448,60 +457,33 @@ int umq_huge_qbuf_register_seg( { int ret = 0; uint32_t failed_idx = 0; - // register mid mem pool - huge_pool_t *pool = &g_huge_pool_ctx.pool[HUGE_QBUF_POOL_SIZE_TYPE_MID]; - for (uint32_t i = 0; i < pool->pool_idx; i++) { - ret = register_seg_func(ctx, pool->pool_idx_shift + i, pool->pool_info[i].data_buffer, pool->total_size); - if (ret != UMQ_SUCCESS) { - failed_idx = i; - UMQ_VLOG_ERR("register mid mem pool failed, ret: %d, pool idx %u\n", ret, i); - goto UNREGISTER_MID_SEG; - } - } + int failed_type = 0; + huge_pool_t *pool = NULL; - // register big mem pool - pool = &g_huge_pool_ctx.pool[HUGE_QBUF_POOL_SIZE_TYPE_BIG]; - for (uint32_t i = 0; i < pool->pool_idx; i++) { - ret = register_seg_func(ctx, pool->pool_idx_shift + i, pool->pool_info[i].data_buffer, pool->total_size); - if (ret != UMQ_SUCCESS) { - failed_idx = i; - UMQ_VLOG_ERR("register big mem pool failed, ret: %d, pool idx %u\n", ret, i); - goto UNREGISTER_BIG_SEG; + for (int i = 0; i < HUGE_QBUF_POOL_SIZE_TYPE_MAX; i++) { + pool = &g_huge_pool_ctx.pool[i]; + for (uint32_t j = 0; j < pool->pool_idx; j++) { + ret = register_seg_func(ctx, pool->pool_idx_shift + j, pool->pool_info[j].data_buffer, pool->total_size); + if (ret != UMQ_SUCCESS) { + failed_idx = j; + failed_type = i; + UMQ_VLOG_ERR("register mid mem pool failed, ret: %d, pool idx: %u, pool type: %d\n", ret, j, i); + goto UNREGISTER_SEG; + } } } - // register huge mem pool - pool = &g_huge_pool_ctx.pool[HUGE_QBUF_POOL_SIZE_TYPE_HUGE]; - for (uint32_t i = 0; i < pool->pool_idx; i++) { - ret = register_seg_func(ctx, pool->pool_idx_shift + i, pool->pool_info[i].data_buffer, pool->total_size); - if (ret != UMQ_SUCCESS) { - failed_idx = i; - UMQ_VLOG_ERR("register huge mem pool failed, ret: %d, pool idx %u\n", ret, i); - goto UNREGISTER_HUGE_SEG; - } - } return UMQ_SUCCESS; -UNREGISTER_HUGE_SEG: - pool = &g_huge_pool_ctx.pool[HUGE_QBUF_POOL_SIZE_TYPE_HUGE]; - for (uint32_t i = 0; i < failed_idx; i++) { - (void)unregister_seg_func(ctx, pool->pool_idx_shift + i); - } - pool = &g_huge_pool_ctx.pool[HUGE_QBUF_POOL_SIZE_TYPE_BIG]; - failed_idx = pool->pool_idx; - -UNREGISTER_BIG_SEG: - pool = &g_huge_pool_ctx.pool[HUGE_QBUF_POOL_SIZE_TYPE_BIG]; - for (uint32_t i = 0; i < failed_idx; i++) { - (void)unregister_seg_func(ctx, pool->pool_idx_shift + i); +UNREGISTER_SEG: + for (uint32_t j = 0; j < failed_idx; j++) { + (void)unregister_seg_func(ctx, pool->pool_idx_shift + j); } - pool = &g_huge_pool_ctx.pool[HUGE_QBUF_POOL_SIZE_TYPE_MID]; - failed_idx = pool->pool_idx; - -UNREGISTER_MID_SEG: - pool = &g_huge_pool_ctx.pool[HUGE_QBUF_POOL_SIZE_TYPE_MID]; - for (uint32_t i = 0; i < failed_idx; i++) { - (void)unregister_seg_func(ctx, pool->pool_idx_shift + i); + for (int i = 0; i < failed_type; i++) { + pool = &g_huge_pool_ctx.pool[i]; + for (uint32_t j = 0; j < pool->pool_idx; j++) { + (void)unregister_seg_func(ctx, pool->pool_idx_shift + j); + } } return ret; } @@ -509,30 +491,14 @@ UNREGISTER_MID_SEG: void umq_huge_qbuf_unregister_seg(uint8_t *ctx, unregister_seg_callback_t unregister_seg_func) { int ret = 0; - // register mid mem pool - huge_pool_t *pool = &g_huge_pool_ctx.pool[HUGE_QBUF_POOL_SIZE_TYPE_MID]; - for (uint32_t i = 0; i < pool->pool_idx; i++) { - ret = unregister_seg_func(ctx, pool->pool_idx_shift + i); - if (ret != UMQ_SUCCESS) { - UMQ_VLOG_ERR("unregister mid mem pool failed, ret: %d, pool idx %u\n", ret, i); - } - } - // register big mem pool - pool = &g_huge_pool_ctx.pool[HUGE_QBUF_POOL_SIZE_TYPE_BIG]; - for (uint32_t i = 0; i < pool->pool_idx; i++) { - ret = unregister_seg_func(ctx, pool->pool_idx_shift + i); - if (ret != UMQ_SUCCESS) { - UMQ_VLOG_ERR("unregister big mem pool failed, ret: %d, pool idx %u\n", ret, i); - } - } - - // register huge mem pool - pool = &g_huge_pool_ctx.pool[HUGE_QBUF_POOL_SIZE_TYPE_HUGE]; - for (uint32_t i = 0; i < pool->pool_idx; i++) { - ret = unregister_seg_func(ctx, pool->pool_idx_shift + i); - if (ret != UMQ_SUCCESS) { - UMQ_VLOG_ERR("unregister big mem pool failed, ret: %d, pool idx %u\n", ret, i); + for (int i = 0; i < HUGE_QBUF_POOL_SIZE_TYPE_MAX; i++) { + huge_pool_t *pool = &g_huge_pool_ctx.pool[i]; + for (uint32_t j = 0; j < pool->pool_idx; j++) { + ret = unregister_seg_func(ctx, pool->pool_idx_shift + j); + if (ret != UMQ_SUCCESS) { + UMQ_VLOG_ERR("unregister big mem pool failed, ret: %d, pool idx: %u, type: %d\n", ret, j, i); + } } } } diff --git a/src/urpc/umq/qbuf/umq_huge_qbuf_pool.h b/src/urpc/umq/qbuf/umq_huge_qbuf_pool.h index 4797794..69ab547 100644 --- a/src/urpc/umq/qbuf/umq_huge_qbuf_pool.h +++ b/src/urpc/umq/qbuf/umq_huge_qbuf_pool.h @@ -25,6 +25,7 @@ typedef enum huge_qbuf_pool_size_type { HUGE_QBUF_POOL_SIZE_TYPE_MID, HUGE_QBUF_POOL_SIZE_TYPE_BIG, HUGE_QBUF_POOL_SIZE_TYPE_HUGE, + HUGE_QBUF_POOL_SIZE_TYPE_GIGANTIC, HUGE_QBUF_POOL_SIZE_TYPE_MAX, } huge_qbuf_pool_size_type_t; diff --git a/src/urpc/umq/qbuf/umq_qbuf_pool.h b/src/urpc/umq/qbuf/umq_qbuf_pool.h index 20f939c..01b3c5c 100644 --- a/src/urpc/umq/qbuf/umq_qbuf_pool.h +++ b/src/urpc/umq/qbuf/umq_qbuf_pool.h @@ -30,9 +30,9 @@ extern "C" { #define UMQ_QBUF_SIZE_POW_16K (14) #define UMQ_QBUF_SIZE_POW_32K (15) #define UMQ_QBUF_SIZE_POW_64K (16) -// middle = small * 32, and big = middle * 32 -#define UMQ_QBUF_SIZE_POW_INTERVAL (5) -#define UMQ_QBUF_SIZE_MULTIPLE_INTERVAL (6) +// middle = small * 4, and big = middle * 4 +#define UMQ_QBUF_SIZE_POW_INTERVAL (2) + typedef struct qbuf_pool_cfg { void *buf_addr; // buffer addr uint64_t total_size; // total buffer size @@ -45,19 +45,24 @@ int umq_buf_size_pow_small_set(umq_buf_block_size_t block_size); uint8_t umq_buf_size_pow_small(void); -static inline uint8_t umq_buf_size_mul_middle(void) +static inline uint8_t umq_buf_size_pow_middle(void) +{ + return (umq_buf_size_pow_small() + UMQ_QBUF_SIZE_POW_INTERVAL); +} + +static inline uint8_t umq_buf_size_pow_big(void) { - return UMQ_QBUF_SIZE_MULTIPLE_INTERVAL; + return (umq_buf_size_pow_middle() + UMQ_QBUF_SIZE_POW_INTERVAL); } -static inline uint8_t umq_buf_size_mul_big(void) +static inline uint8_t umq_buf_size_pow_huge(void) { - return (umq_buf_size_mul_middle() * UMQ_QBUF_SIZE_MULTIPLE_INTERVAL); + return (umq_buf_size_pow_big() + UMQ_QBUF_SIZE_POW_INTERVAL); } -static inline uint8_t umq_buf_size_mul_huge(void) +static inline uint8_t umq_buf_size_pow_gigantic(void) { - return (umq_buf_size_mul_big() * UMQ_QBUF_SIZE_MULTIPLE_INTERVAL); + return (umq_buf_size_pow_huge() + UMQ_QBUF_SIZE_POW_INTERVAL); } // small qbuf block size: 8K, or 64K size @@ -68,17 +73,22 @@ static inline uint32_t umq_buf_size_small(void) static inline uint32_t umq_buf_size_middle(void) { - return umq_buf_size_small() * umq_buf_size_mul_middle(); + return (1 << umq_buf_size_pow_middle()); } static inline uint32_t umq_buf_size_big(void) { - return umq_buf_size_small() * umq_buf_size_mul_big(); + return (1 << umq_buf_size_pow_big()); } static inline uint32_t umq_buf_size_huge(void) { - return umq_buf_size_small() * umq_buf_size_mul_huge(); + return (1 << umq_buf_size_pow_huge()); +} + +static inline uint32_t umq_buf_size_gigantic(void) +{ + return (1 << umq_buf_size_pow_gigantic()); } void *umq_io_buf_malloc(umq_buf_mode_t buf_mode, uint64_t size); diff --git a/src/urpc/umq/umq_api.c b/src/urpc/umq/umq_api.c index 1642657..e76bd58 100644 --- a/src/urpc/umq/umq_api.c +++ b/src/urpc/umq/umq_api.c @@ -1081,4 +1081,15 @@ int umq_mempool_state_refresh(uint64_t umqh, uint32_t mempool_id) } return umq->tp_ops->umq_tp_mempool_state_refresh(umq->umqh_tp, mempool_id); +} + +int umq_queue_cfg_get(uint64_t umqh, umq_cfg_get_t *cfg) +{ + umq_t *umq = (umq_t *)(uintptr_t)umqh; + if (umq == NULL || cfg == NULL || umq->umqh_tp == UMQ_INVALID_HANDLE || umq->tp_ops->umq_tp_cfg_get == NULL) { + UMQ_VLOG_ERR("parameter invalid\n"); + return -UMQ_ERR_EINVAL; + } + + return umq->tp_ops->umq_tp_cfg_get(umq->umqh_tp, cfg); } \ No newline at end of file diff --git a/src/urpc/umq/umq_ub/core/private/umq_ub.c b/src/urpc/umq/umq_ub/core/private/umq_ub.c index 8513466..781eedb 100644 --- a/src/urpc/umq/umq_ub/core/private/umq_ub.c +++ b/src/urpc/umq/umq_ub/core/private/umq_ub.c @@ -1284,8 +1284,11 @@ static inline uint32_t get_mem_interval(uint32_t used_mem_size) return UMQ_SIZE_SMALL_MID_INTERVAL; } else if (used_mem_size <= umq_buf_size_big()) { return UMQ_SIZE_MID_BIG_INTERVAL; + } else if (used_mem_size <= umq_buf_size_huge()) { + return UMQ_SIZE_BIG_HUGE_INTERVAL; } - return UMQ_SIZE_BIG_HUGE_INTERVAL; + + return UMQ_SIZE_HUGE_GIGANTIC_INTERVAL; } void ub_fill_umq_imm_head(umq_imm_head_t *umq_imm_head, umq_buf_t *buffer) @@ -1826,7 +1829,7 @@ int umq_ub_write_imm(uint64_t umqh_tp, uint64_t target_addr, uint32_t len, uint6 .flag.bs.inline_flag = URMA_INLINE_ENABLE, .tjetty = queue->bind_ctx->tjetty, .user_ctx = UINT16_MAX, // do not report TX events - .rw = { + .rw = { .src = {.sge = &src_sge, .num_sge = 1}, .dst = {.sge = &dst_sge, .num_sge = 1}, .notify_data = imm_value, }, diff --git a/src/urpc/umq/umq_ub/core/private/umq_ub_private.h b/src/urpc/umq/umq_ub/core/private/umq_ub_private.h index 72cb51c..b5f9519 100644 --- a/src/urpc/umq/umq_ub/core/private/umq_ub_private.h +++ b/src/urpc/umq/umq_ub/core/private/umq_ub_private.h @@ -35,7 +35,7 @@ extern "C" { #define UMQ_MAX_ID_NUM (1 << 16) #define UMQ_CONTINUE_FLAG 1 -#define UMQ_MAX_TSEG_NUM 255 +#define UMQ_MAX_TSEG_NUM 383 #define UMQ_UB_RW_SEGMENT_LEN 64 // ub_queue read/write buf splited 64B for each module, such as mem import/flow control #define HUGE_QBUF_BUFFER_INC_BATCH 64 #define UMQ_QBUF_ALIGN_SIZE 4096 @@ -52,6 +52,7 @@ typedef enum umq_size_interval { UMQ_SIZE_SMALL_MID_INTERVAL, // (umq_buf_size_small(), umq_buf_size_middle()] size UMQ_SIZE_MID_BIG_INTERVAL, // (umq_buf_size_middle(), umq_buf_size_big()] size UMQ_SIZE_BIG_HUGE_INTERVAL, // (umq_buf_size_big(), umq_buf_size_huge()] size + UMQ_SIZE_HUGE_GIGANTIC_INTERVAL, // (umq_buf_size_huge(), umq_buf_size_gigantic()] size UMQ_SIZE_INTERVAL_MAX, } umq_size_interval_t; diff --git a/src/urpc/umq/umq_ub/core/umq_ub_impl.c b/src/urpc/umq/umq_ub/core/umq_ub_impl.c index ee0f3ac..61e5042 100644 --- a/src/urpc/umq/umq_ub/core/umq_ub_impl.c +++ b/src/urpc/umq/umq_ub/core/umq_ub_impl.c @@ -1392,3 +1392,11 @@ FREE_BUF: umq_buf_free(send_buf); return ret; } + +int umq_ub_cfg_get_impl(uint64_t umqh_tp, umq_cfg_get_t *cfg) +{ + ub_queue_t *queue = (ub_queue_t *)(uintptr_t)umqh_tp; + cfg->max_rx_sge = queue->max_rx_sge; + cfg->max_tx_sge = queue->max_tx_sge; + return UMQ_SUCCESS; +} \ No newline at end of file diff --git a/src/urpc/umq/umq_ub/core/umq_ub_impl.h b/src/urpc/umq/umq_ub/core/umq_ub_impl.h index e39ec1a..0dea312 100644 --- a/src/urpc/umq/umq_ub/core/umq_ub_impl.h +++ b/src/urpc/umq/umq_ub/core/umq_ub_impl.h @@ -80,6 +80,7 @@ int umq_ub_get_route_list_impl(const umq_route_t *route, umq_route_list_t *route int umq_ub_user_ctl_impl(uint64_t umqh_tp, umq_user_ctl_in_t *in, umq_user_ctl_out_t *out); int umq_ub_mempool_state_get_impl(uint64_t umqh_tp, uint32_t mempool_id, umq_mempool_state_t *mempool_state); int umq_ub_mempool_state_refresh_impl(uint64_t umqh_tp, uint32_t mempool_id); +int umq_ub_cfg_get_impl(uint64_t umqh_tp, umq_cfg_get_t *cfg); #ifdef __cplusplus } diff --git a/src/urpc/umq/umq_ub/umq_ub_api.c b/src/urpc/umq/umq_ub/umq_ub_api.c index b67a712..360329d 100644 --- a/src/urpc/umq/umq_ub/umq_ub_api.c +++ b/src/urpc/umq/umq_ub/umq_ub_api.c @@ -169,6 +169,11 @@ static int umq_tp_ub_mempool_state_refresh(uint64_t umqh_tp, uint32_t mempool_id return umq_ub_mempool_state_refresh_impl(umqh_tp, mempool_id); } +static int umq_tp_ub_cfg_get(uint64_t umqh_tp, umq_cfg_get_t *cfg) +{ + return umq_ub_cfg_get_impl(umqh_tp, cfg); +} + static umq_ops_t g_umq_ub_ops = { .mode = UMQ_TRANS_MODE_UB, // control plane api @@ -188,6 +193,7 @@ static umq_ops_t g_umq_ub_ops = { .umq_tp_user_ctl = umq_tp_ub_user_ctl_impl, .umq_tp_mempool_state_get = umq_tp_ub_mempool_state_get, .umq_tp_mempool_state_refresh = umq_tp_ub_mempool_state_refresh, + .umq_tp_cfg_get = umq_tp_ub_cfg_get, // datapath plane api .umq_tp_buf_alloc = umq_tp_ub_buf_alloc, diff --git a/src/urpc/umq/umq_ub/umq_ub_plus_api.c b/src/urpc/umq/umq_ub/umq_ub_plus_api.c index 5b74592..9e55854 100644 --- a/src/urpc/umq/umq_ub/umq_ub_plus_api.c +++ b/src/urpc/umq/umq_ub/umq_ub_plus_api.c @@ -183,6 +183,11 @@ static int umq_tp_ub_plus_mempool_state_refresh(uint64_t umqh_tp, uint32_t mempo return umq_ub_mempool_state_refresh_impl(umqh_tp, mempool_id); } +static int umq_tp_ub_plus_qcfg_get(uint64_t umqh_tp, umq_cfg_get_t *cfg) +{ + return umq_ub_cfg_get_impl(umqh_tp, cfg); +} + static umq_ops_t g_umq_ub_plus_ops = { .mode = UMQ_TRANS_MODE_UB_PLUS, // control plane api @@ -202,6 +207,7 @@ static umq_ops_t g_umq_ub_plus_ops = { .umq_tp_get_topo = umq_tp_ub_plus_get_route_list_impl, .umq_tp_mempool_state_get = umq_tp_ub_plus_mempool_state_get, .umq_tp_mempool_state_refresh = umq_tp_ub_plus_mempool_state_refresh, + .umq_tp_cfg_get = umq_tp_ub_plus_qcfg_get, // datapath plane api .umq_tp_buf_alloc = umq_tp_ub_plus_buf_alloc, diff --git a/src/urpc/umq/umq_ubmm/umq_ubmm_impl.c b/src/urpc/umq/umq_ubmm/umq_ubmm_impl.c index b0b4ea9..2c31235 100644 --- a/src/urpc/umq/umq_ubmm/umq_ubmm_impl.c +++ b/src/urpc/umq/umq_ubmm/umq_ubmm_impl.c @@ -15,8 +15,6 @@ #include "umq_ub_imm_data.h" #include "umq_ubmm_impl.h" -#define UMQ_MAX_TSEG_NUM 255 - typedef struct umq_ubmm_init_ctx { uint8_t *ub_init_ctx; umq_trans_info_t trans_info; -- Gitee