From f0c207a0b564ccd356534c67d6265864a2722a7a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C5=81ukasz=20Plewa?= Date: Wed, 11 Jun 2025 16:13:51 +0200 Subject: [PATCH] use umf_result in ctl fixes: #1365 --- src/ctl/ctl.c | 117 ++++++++++++------------- src/ctl/ctl.h | 22 ++--- src/libumf.c | 8 +- src/memory_pool.c | 47 +++++----- src/memory_provider.c | 4 +- src/pool/pool_disjoint.c | 30 ++++--- src/provider/provider_ctl_stats_impl.h | 36 ++++---- src/provider/provider_os_memory.c | 12 ++- test/ctl/ctl_debug.c | 72 +++++++-------- test/ctl/ctl_unittest.cpp | 22 +++-- 10 files changed, 175 insertions(+), 195 deletions(-) diff --git a/src/ctl/ctl.c b/src/ctl/ctl.c index e66df9937..b48c58a30 100644 --- a/src/ctl/ctl.c +++ b/src/ctl/ctl.c @@ -247,21 +247,20 @@ static void ctl_query_cleanup_real_args(const umf_ctl_node_t *n, void *real_arg, /* * ctl_exec_query_read -- (internal) calls the read callback of a node */ -static int ctl_exec_query_read(void *ctx, const umf_ctl_node_t *n, - umf_ctl_query_source_t source, void *arg, - size_t size, umf_ctl_index_utlist_t *indexes, - const char *extra_name, - umf_ctl_query_type_t query_type) { +static umf_result_t ctl_exec_query_read(void *ctx, const umf_ctl_node_t *n, + umf_ctl_query_source_t source, + void *arg, size_t size, + umf_ctl_index_utlist_t *indexes, + const char *extra_name, + umf_ctl_query_type_t query_type) { (void)query_type; assert(n != NULL); assert(n->cb[CTL_QUERY_READ] != NULL); assert(MAX_CTL_QUERY_TYPE != query_type); if (arg == NULL) { - errno = EINVAL; - return -1; + return UMF_RESULT_ERROR_INVALID_ARGUMENT; } - return n->cb[CTL_QUERY_READ](ctx, source, arg, size, indexes, extra_name, MAX_CTL_QUERY_TYPE); } @@ -269,28 +268,28 @@ static int ctl_exec_query_read(void *ctx, const umf_ctl_node_t *n, /* * ctl_exec_query_write -- (internal) calls the write callback of a node */ -static int ctl_exec_query_write(void *ctx, const umf_ctl_node_t *n, - umf_ctl_query_source_t source, void *arg, - size_t size, umf_ctl_index_utlist_t *indexes, - const char *extra_name, - umf_ctl_query_type_t query_type) { +static umf_result_t ctl_exec_query_write(void *ctx, const umf_ctl_node_t *n, + umf_ctl_query_source_t source, + void *arg, size_t size, + umf_ctl_index_utlist_t *indexes, + const char *extra_name, + umf_ctl_query_type_t query_type) { (void)query_type; assert(n != NULL); assert(n->cb[CTL_QUERY_WRITE] != NULL); assert(MAX_CTL_QUERY_TYPE != query_type); if (arg == NULL) { - errno = EINVAL; - return -1; + return UMF_RESULT_ERROR_INVALID_ARGUMENT; } void *real_arg = ctl_query_get_real_args(n, arg, source); if (real_arg == NULL) { - return -1; + return UMF_RESULT_ERROR_INVALID_ARGUMENT; } - int ret = n->cb[CTL_QUERY_WRITE](ctx, source, real_arg, size, indexes, - extra_name, MAX_CTL_QUERY_TYPE); + umf_result_t ret = n->cb[CTL_QUERY_WRITE]( + ctx, source, real_arg, size, indexes, extra_name, MAX_CTL_QUERY_TYPE); ctl_query_cleanup_real_args(n, real_arg, source); return ret; @@ -299,11 +298,12 @@ static int ctl_exec_query_write(void *ctx, const umf_ctl_node_t *n, /* * ctl_exec_query_runnable -- (internal) calls the run callback of a node */ -static int ctl_exec_query_runnable(void *ctx, const umf_ctl_node_t *n, - umf_ctl_query_source_t source, void *arg, - size_t size, umf_ctl_index_utlist_t *indexes, - const char *extra_name, - umf_ctl_query_type_t query_type) { +static umf_result_t ctl_exec_query_runnable(void *ctx, const umf_ctl_node_t *n, + umf_ctl_query_source_t source, + void *arg, size_t size, + umf_ctl_index_utlist_t *indexes, + const char *extra_name, + umf_ctl_query_type_t query_type) { (void)query_type; assert(n != NULL); assert(n->cb[CTL_QUERY_RUNNABLE] != NULL); @@ -312,11 +312,12 @@ static int ctl_exec_query_runnable(void *ctx, const umf_ctl_node_t *n, extra_name, MAX_CTL_QUERY_TYPE); } -static int ctl_exec_query_subtree(void *ctx, const umf_ctl_node_t *n, - umf_ctl_query_source_t source, void *arg, - size_t size, umf_ctl_index_utlist_t *indexes, - const char *extra_name, - umf_ctl_query_type_t query_type) { +static umf_result_t ctl_exec_query_subtree(void *ctx, const umf_ctl_node_t *n, + umf_ctl_query_source_t source, + void *arg, size_t size, + umf_ctl_index_utlist_t *indexes, + const char *extra_name, + umf_ctl_query_type_t query_type) { assert(n != NULL); assert(n->cb[CTL_QUERY_SUBTREE] != NULL); assert(MAX_CTL_QUERY_TYPE != query_type); @@ -324,12 +325,12 @@ static int ctl_exec_query_subtree(void *ctx, const umf_ctl_node_t *n, query_type); } -typedef int (*umf_ctl_exec_query_t)(void *ctx, const umf_ctl_node_t *n, - umf_ctl_query_source_t source, void *arg, - size_t size, - umf_ctl_index_utlist_t *indexes, - const char *extra_name, - umf_ctl_query_type_t query_type); +typedef umf_result_t (*umf_ctl_exec_query_t)(void *ctx, const umf_ctl_node_t *n, + umf_ctl_query_source_t source, + void *arg, size_t size, + umf_ctl_index_utlist_t *indexes, + const char *extra_name, + umf_ctl_query_type_t query_type); static umf_ctl_exec_query_t ctl_exec_query[MAX_CTL_QUERY_TYPE] = { ctl_exec_query_read, @@ -342,12 +343,11 @@ static umf_ctl_exec_query_t ctl_exec_query[MAX_CTL_QUERY_TYPE] = { * ctl_query -- (internal) parses the name and calls the appropriate methods * from the ctl tree */ -int ctl_query(struct ctl *ctl, void *ctx, umf_ctl_query_source_t source, - const char *name, umf_ctl_query_type_t type, void *arg, - size_t size) { +umf_result_t ctl_query(struct ctl *ctl, void *ctx, + umf_ctl_query_source_t source, const char *name, + umf_ctl_query_type_t type, void *arg, size_t size) { if (name == NULL) { - errno = EINVAL; - return -1; + return UMF_RESULT_ERROR_INVALID_ARGUMENT; } /* @@ -358,10 +358,10 @@ int ctl_query(struct ctl *ctl, void *ctx, umf_ctl_query_source_t source, umf_ctl_index_utlist_t *indexes = NULL; indexes = Zalloc(sizeof(*indexes)); if (!indexes) { - return -1; + return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY; } - int ret = -1; + umf_result_t ret = UMF_RESULT_ERROR_UNKNOWN; size_t name_offset = 0; const umf_ctl_node_t *n = @@ -377,7 +377,7 @@ int ctl_query(struct ctl *ctl, void *ctx, umf_ctl_query_source_t source, if (n == NULL || (n->type != CTL_NODE_LEAF && n->type != CTL_NODE_SUBTREE) || n->cb[n->type == CTL_NODE_SUBTREE ? CTL_QUERY_SUBTREE : type] == NULL) { - errno = EINVAL; + ret = UMF_RESULT_ERROR_INVALID_ARGUMENT; goto out; } @@ -436,24 +436,24 @@ static int ctl_parse_query(char *qbuf, char **name, char **value) { /* * ctl_load_config -- executes the entire query collection from a provider */ -static int ctl_load_config(struct ctl *ctl, void *ctx, char *buf) { - int r = 0; +static umf_result_t ctl_load_config(struct ctl *ctl, void *ctx, char *buf) { + umf_result_t ret = UMF_RESULT_SUCCESS; char *sptr = NULL; /* for internal use of strtok */ char *name; char *value; char *qbuf = strtok_r(buf, CTL_STRING_QUERY_SEPARATOR, &sptr); while (qbuf != NULL) { - r = ctl_parse_query(qbuf, &name, &value); - if (r != 0) { - return -1; + int parse_res = ctl_parse_query(qbuf, &name, &value); + if (parse_res != 0) { + return UMF_RESULT_ERROR_INVALID_ARGUMENT; } - r = ctl_query(ctl, ctx, CTL_QUERY_CONFIG_INPUT, name, CTL_QUERY_WRITE, - value, 0); + ret = ctl_query(ctl, ctx, CTL_QUERY_CONFIG_INPUT, name, CTL_QUERY_WRITE, + value, 0); - if (r < 0 && ctx != NULL) { - return -1; + if (ret != UMF_RESULT_SUCCESS && ctx != NULL) { + return ret; } qbuf = strtok_r(NULL, CTL_STRING_QUERY_SEPARATOR, &sptr); @@ -465,14 +465,14 @@ static int ctl_load_config(struct ctl *ctl, void *ctx, char *buf) { /* * ctl_load_config_from_string -- loads obj configuration from string */ -int ctl_load_config_from_string(struct ctl *ctl, void *ctx, - const char *cfg_string) { +umf_result_t ctl_load_config_from_string(struct ctl *ctl, void *ctx, + const char *cfg_string) { char *buf = Strdup(cfg_string); if (buf == NULL) { - return -1; + return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY; } - int ret = ctl_load_config(ctl, ctx, buf); + umf_result_t ret = ctl_load_config(ctl, ctx, buf); umf_ba_global_free(buf); return ret; @@ -485,9 +485,9 @@ int ctl_load_config_from_string(struct ctl *ctl, void *ctx, * the size of the file, reads its content and sanitizes it for ctl_load_config. */ #ifndef _WIN32 // TODO: implement for Windows -int ctl_load_config_from_file(struct ctl *ctl, void *ctx, - const char *cfg_file) { - int ret = -1; +umf_result_t ctl_load_config_from_file(struct ctl *ctl, void *ctx, + const char *cfg_file) { + umf_result_t ret = UMF_RESULT_ERROR_UNKNOWN; long fsize = 0; char *buf = NULL; @@ -608,7 +608,6 @@ int ctl_arg_integer(const void *arg, void *dest, size_t dest_size) { *(uint8_t *)dest = (uint8_t)val; break; default: - errno = EINVAL; return -1; } diff --git a/src/ctl/ctl.h b/src/ctl/ctl.h index 59aa3c799..754381d64 100644 --- a/src/ctl/ctl.h +++ b/src/ctl/ctl.h @@ -45,10 +45,11 @@ typedef enum ctl_query_source { MAX_CTL_QUERY_SOURCE } umf_ctl_query_source_t; -typedef int (*node_callback)(void *ctx, umf_ctl_query_source_t type, void *arg, - size_t size, umf_ctl_index_utlist_t *indexes, - const char *extra_name, - umf_ctl_query_type_t query_type); +typedef umf_result_t (*node_callback)(void *ctx, umf_ctl_query_source_t type, + void *arg, size_t size, + umf_ctl_index_utlist_t *indexes, + const char *extra_name, + umf_ctl_query_type_t query_type); enum ctl_node_type { CTL_NODE_UNKNOWN, @@ -115,9 +116,10 @@ struct ctl { void initialize_global_ctl(void); -int ctl_load_config_from_string(struct ctl *ctl, void *ctx, - const char *cfg_string); -int ctl_load_config_from_file(struct ctl *ctl, void *ctx, const char *cfg_file); +umf_result_t ctl_load_config_from_string(struct ctl *ctl, void *ctx, + const char *cfg_string); +umf_result_t ctl_load_config_from_file(struct ctl *ctl, void *ctx, + const char *cfg_file); /* Use through CTL_REGISTER_MODULE, never directly */ void ctl_register_module_node(struct ctl *c, const char *name, @@ -149,9 +151,9 @@ int ctl_arg_string(const void *arg, void *dest, size_t dest_size); #define CTL_NODE(name, ...) ctl_node_##__VA_ARGS__##_##name -int ctl_query(struct ctl *ctl, void *ctx, umf_ctl_query_source_t source, - const char *name, umf_ctl_query_type_t type, void *arg, - size_t size); +umf_result_t ctl_query(struct ctl *ctl, void *ctx, + umf_ctl_query_source_t source, const char *name, + umf_ctl_query_type_t type, void *arg, size_t size); /* Declaration of a new child node */ #define CTL_CHILD(name, ...) \ diff --git a/src/libumf.c b/src/libumf.c index 46c264016..60030fed6 100644 --- a/src/libumf.c +++ b/src/libumf.c @@ -115,9 +115,7 @@ umf_result_t umfCtlSet(const char *name, void *ctx, void *arg, size_t size) { } return ctl_query(NULL, ctx, CTL_QUERY_PROGRAMMATIC, name, CTL_QUERY_WRITE, - arg, size) - ? UMF_RESULT_ERROR_UNKNOWN - : UMF_RESULT_SUCCESS; + arg, size); } umf_result_t umfCtlExec(const char *name, void *ctx, void *arg, size_t size) { @@ -133,7 +131,5 @@ umf_result_t umfCtlExec(const char *name, void *ctx, void *arg, size_t size) { } return ctl_query(NULL, ctx, CTL_QUERY_PROGRAMMATIC, name, - CTL_QUERY_RUNNABLE, arg, size) - ? UMF_RESULT_ERROR_UNKNOWN - : UMF_RESULT_SUCCESS; + CTL_QUERY_RUNNABLE, arg, size); } diff --git a/src/memory_pool.c b/src/memory_pool.c index ad5182236..bef783427 100644 --- a/src/memory_pool.c +++ b/src/memory_pool.c @@ -37,32 +37,27 @@ static struct ctl umf_pool_ctl_root; static void ctl_init(void); -static int CTL_SUBTREE_HANDLER(by_handle_pool)(void *ctx, - umf_ctl_query_source_t source, - void *arg, size_t size, - umf_ctl_index_utlist_t *indexes, - const char *extra_name, - umf_ctl_query_type_t queryType) { +static umf_result_t CTL_SUBTREE_HANDLER(by_handle_pool)( + void *ctx, umf_ctl_query_source_t source, void *arg, size_t size, + umf_ctl_index_utlist_t *indexes, const char *extra_name, + umf_ctl_query_type_t queryType) { (void)indexes, (void)source; umf_memory_pool_handle_t hPool = (umf_memory_pool_handle_t)ctx; - int ret = ctl_query(&umf_pool_ctl_root, hPool, source, extra_name, - queryType, arg, size); - if (ret == -1 && - errno == EINVAL) { // node was not found in pool_ctl_root, try to - // query the specific pool directly - hPool->ops.ext_ctl(hPool->pool_priv, source, extra_name, arg, size, - queryType); + umf_result_t ret = ctl_query(&umf_pool_ctl_root, hPool, source, extra_name, + queryType, arg, size); + if (ret == UMF_RESULT_ERROR_INVALID_ARGUMENT) { + // Node was not found in pool_ctl_root, try to query the specific pool + ret = hPool->ops.ext_ctl(hPool->pool_priv, source, extra_name, arg, + size, queryType); } - return 0; + return ret; } -static int CTL_SUBTREE_HANDLER(default)(void *ctx, - umf_ctl_query_source_t source, - void *arg, size_t size, - umf_ctl_index_utlist_t *indexes, - const char *extra_name, - umf_ctl_query_type_t queryType) { +static umf_result_t CTL_SUBTREE_HANDLER(default)( + void *ctx, umf_ctl_query_source_t source, void *arg, size_t size, + umf_ctl_index_utlist_t *indexes, const char *extra_name, + umf_ctl_query_type_t queryType) { (void)indexes, (void)source, (void)ctx; utils_init_once(&mem_pool_ctl_initialized, ctl_init); utils_mutex_lock(&ctl_mtx); @@ -101,15 +96,13 @@ static int CTL_SUBTREE_HANDLER(default)(void *ctx, utils_mutex_unlock(&ctl_mtx); - return 0; + return UMF_RESULT_SUCCESS; } -static int CTL_READ_HANDLER(alloc_count)(void *ctx, - umf_ctl_query_source_t source, - void *arg, size_t size, - umf_ctl_index_utlist_t *indexes, - const char *extra_name, - umf_ctl_query_type_t query_type) { +static umf_result_t CTL_READ_HANDLER(alloc_count)( + void *ctx, umf_ctl_query_source_t source, void *arg, size_t size, + umf_ctl_index_utlist_t *indexes, const char *extra_name, + umf_ctl_query_type_t query_type) { /* suppress unused-parameter errors */ (void)source, (void)size, (void)indexes, (void)extra_name, (void)query_type; diff --git a/src/memory_provider.c b/src/memory_provider.c index c262ad80d..995fab642 100644 --- a/src/memory_provider.c +++ b/src/memory_provider.c @@ -21,7 +21,7 @@ #include "umf/base.h" #include "utils_assert.h" -static int CTL_SUBTREE_HANDLER(by_handle_provider)( +static umf_result_t CTL_SUBTREE_HANDLER(by_handle_provider)( void *ctx, umf_ctl_query_source_t source, void *arg, size_t size, umf_ctl_index_utlist_t *indexes, const char *extra_name, umf_ctl_query_type_t queryType) { @@ -29,7 +29,7 @@ static int CTL_SUBTREE_HANDLER(by_handle_provider)( umf_memory_provider_handle_t hProvider = (umf_memory_provider_handle_t)ctx; hProvider->ops.ext_ctl(hProvider->provider_priv, /*unused*/ 0, extra_name, arg, size, queryType); - return 0; + return UMF_RESULT_SUCCESS; } umf_ctl_node_t CTL_NODE(provider)[] = { diff --git a/src/pool/pool_disjoint.c b/src/pool/pool_disjoint.c index ca5e483f5..a5f62c4e0 100644 --- a/src/pool/pool_disjoint.c +++ b/src/pool/pool_disjoint.c @@ -33,41 +33,43 @@ static char *DEFAULT_NAME = "disjoint"; struct ctl disjoint_ctl_root; static UTIL_ONCE_FLAG ctl_initialized = UTIL_ONCE_FLAG_INIT; -static int CTL_READ_HANDLER(name)(void *ctx, umf_ctl_query_source_t source, - void *arg, size_t size, - umf_ctl_index_utlist_t *indexes, - const char *extra_name, - umf_ctl_query_type_t queryType) { +static umf_result_t +CTL_READ_HANDLER(name)(void *ctx, umf_ctl_query_source_t source, void *arg, + size_t size, umf_ctl_index_utlist_t *indexes, + const char *extra_name, umf_ctl_query_type_t queryType) { (void)source, (void)indexes, (void)queryType, (void)extra_name; disjoint_pool_t *pool = (disjoint_pool_t *)ctx; if (arg == NULL) { - return -1; + return UMF_RESULT_ERROR_INVALID_ARGUMENT; } if (size > 0) { strncpy((char *)arg, pool->params.name, size - 1); ((char *)arg)[size - 1] = '\0'; } - return 0; + + return UMF_RESULT_SUCCESS; } static const struct ctl_argument CTL_ARG(name) = CTL_ARG_STRING(255); -static int CTL_WRITE_HANDLER(name)(void *ctx, umf_ctl_query_source_t source, - void *arg, size_t size, - umf_ctl_index_utlist_t *indexes, - const char *extra_name, - umf_ctl_query_type_t queryType) { +static umf_result_t CTL_WRITE_HANDLER(name)(void *ctx, + umf_ctl_query_source_t source, + void *arg, size_t size, + umf_ctl_index_utlist_t *indexes, + const char *extra_name, + umf_ctl_query_type_t queryType) { (void)source, (void)indexes, (void)queryType, (void)size, (void)extra_name; disjoint_pool_t *pool = (disjoint_pool_t *)ctx; if (arg == NULL) { - return -1; + return UMF_RESULT_ERROR_INVALID_ARGUMENT; } strncpy(pool->params.name, (char *)arg, sizeof(pool->params.name) - 1); pool->params.name[sizeof(pool->params.name) - 1] = '\0'; - return 0; + + return UMF_RESULT_SUCCESS; } static const umf_ctl_node_t CTL_NODE(disjoint)[] = {CTL_LEAF_RW(name), diff --git a/src/provider/provider_ctl_stats_impl.h b/src/provider/provider_ctl_stats_impl.h index 565ed78b0..1a6604905 100644 --- a/src/provider/provider_ctl_stats_impl.h +++ b/src/provider/provider_ctl_stats_impl.h @@ -21,27 +21,23 @@ extern "C" { #include "ctl/ctl.h" #include "utils/utils_assert.h" -static int CTL_READ_HANDLER(peak_memory)(void *ctx, - umf_ctl_query_source_t source, - void *arg, size_t size, - umf_ctl_index_utlist_t *indexes, - const char *extra_name, - umf_ctl_query_type_t query_type) { +static umf_result_t CTL_READ_HANDLER(peak_memory)( + void *ctx, umf_ctl_query_source_t source, void *arg, size_t size, + umf_ctl_index_utlist_t *indexes, const char *extra_name, + umf_ctl_query_type_t query_type) { /* suppress unused-parameter errors */ (void)source, (void)size, (void)indexes, (void)extra_name, (void)query_type; size_t *arg_out = arg; CTL_PROVIDER_TYPE *provider = (CTL_PROVIDER_TYPE *)ctx; utils_atomic_load_acquire_size_t(&provider->stats.peak_memory, arg_out); - return 0; + return UMF_RESULT_SUCCESS; } -static int CTL_READ_HANDLER(allocated_memory)(void *ctx, - umf_ctl_query_source_t source, - void *arg, size_t size, - umf_ctl_index_utlist_t *indexes, - const char *extra_name, - umf_ctl_query_type_t query_type) { +static umf_result_t CTL_READ_HANDLER(allocated_memory)( + void *ctx, umf_ctl_query_source_t source, void *arg, size_t size, + umf_ctl_index_utlist_t *indexes, const char *extra_name, + umf_ctl_query_type_t query_type) { /* suppress unused-parameter errors */ (void)source, (void)size, (void)indexes, (void)extra_name, (void)query_type; @@ -49,14 +45,14 @@ static int CTL_READ_HANDLER(allocated_memory)(void *ctx, CTL_PROVIDER_TYPE *provider = (CTL_PROVIDER_TYPE *)ctx; utils_atomic_load_acquire_size_t(&provider->stats.allocated_memory, arg_out); - return 0; + return UMF_RESULT_SUCCESS; } -static int CTL_RUNNABLE_HANDLER(reset)(void *ctx, umf_ctl_query_source_t source, - void *arg, size_t size, - umf_ctl_index_utlist_t *indexes, - const char *extra_name, - umf_ctl_query_type_t query_type) { +static umf_result_t +CTL_RUNNABLE_HANDLER(reset)(void *ctx, umf_ctl_query_source_t source, void *arg, + size_t size, umf_ctl_index_utlist_t *indexes, + const char *extra_name, + umf_ctl_query_type_t query_type) { /* suppress unused-parameter errors */ (void)source, (void)indexes, (void)arg, (void)size, (void)extra_name, (void)query_type; @@ -73,7 +69,7 @@ static int CTL_RUNNABLE_HANDLER(reset)(void *ctx, umf_ctl_query_source_t source, } while (!utils_compare_exchange_size_t(&provider->stats.peak_memory, ¤t_peak, &allocated)); - return 0; + return UMF_RESULT_SUCCESS; } static const umf_ctl_node_t CTL_NODE(peak_memory)[] = {CTL_LEAF_RUNNABLE(reset), diff --git a/src/provider/provider_os_memory.c b/src/provider/provider_os_memory.c index 7bcc0e4d2..8ebdaa38e 100644 --- a/src/provider/provider_os_memory.c +++ b/src/provider/provider_os_memory.c @@ -177,12 +177,10 @@ struct ctl os_memory_ctl_root; static UTIL_ONCE_FLAG ctl_initialized = UTIL_ONCE_FLAG_INIT; -static int CTL_READ_HANDLER(ipc_enabled)(void *ctx, - umf_ctl_query_source_t source, - void *arg, size_t size, - umf_ctl_index_utlist_t *indexes, - const char *extra_name, - umf_ctl_query_type_t query_type) { +static umf_result_t CTL_READ_HANDLER(ipc_enabled)( + void *ctx, umf_ctl_query_source_t source, void *arg, size_t size, + umf_ctl_index_utlist_t *indexes, const char *extra_name, + umf_ctl_query_type_t query_type) { /* suppress unused-parameter errors */ (void)source, (void)indexes, (void)ctx, (void)extra_name, (void)query_type, (void)size; @@ -190,7 +188,7 @@ static int CTL_READ_HANDLER(ipc_enabled)(void *ctx, int *arg_out = arg; os_memory_provider_t *os_provider = (os_memory_provider_t *)ctx; *arg_out = os_provider->IPC_enabled; - return 0; + return UMF_RESULT_SUCCESS; } static const umf_ctl_node_t CTL_NODE(params)[] = {CTL_LEAF_RO(ipc_enabled), diff --git a/test/ctl/ctl_debug.c b/test/ctl/ctl_debug.c index 965e4871c..ad6746eaa 100644 --- a/test/ctl/ctl_debug.c +++ b/test/ctl/ctl_debug.c @@ -24,96 +24,86 @@ struct ctl *get_debug_ctl(void) { return &ctl_debug; } /* * CTL_WRITE_HANDLER(alloc_pattern) -- sets the alloc_pattern field in heap */ -static int CTL_WRITE_HANDLER(alloc_pattern)(void *ctx, - umf_ctl_query_source_t source, - void *arg, size_t size, - umf_ctl_index_utlist_t *indexes, - const char *extra_name, - umf_ctl_query_type_t query_type) { +static umf_result_t CTL_WRITE_HANDLER(alloc_pattern)( + void *ctx, umf_ctl_query_source_t source, void *arg, size_t size, + umf_ctl_index_utlist_t *indexes, const char *extra_name, + umf_ctl_query_type_t query_type) { /* suppress unused-parameter errors */ (void)source, (void)indexes, (void)ctx, (void)extra_name, (void)query_type, (void)size; int arg_in = *(int *)arg; alloc_pattern = arg_in; - return 0; + return UMF_RESULT_SUCCESS; } /* * CTL_READ_HANDLER(alloc_pattern) -- returns alloc_pattern heap field */ -static int CTL_READ_HANDLER(alloc_pattern)(void *ctx, - umf_ctl_query_source_t source, - void *arg, size_t size, - umf_ctl_index_utlist_t *indexes, - const char *extra_name, - umf_ctl_query_type_t query_type) { +static umf_result_t CTL_READ_HANDLER(alloc_pattern)( + void *ctx, umf_ctl_query_source_t source, void *arg, size_t size, + umf_ctl_index_utlist_t *indexes, const char *extra_name, + umf_ctl_query_type_t query_type) { /* suppress unused-parameter errors */ (void)source, (void)indexes, (void)ctx, (void)extra_name, (void)query_type, (void)size; int *arg_out = arg; *arg_out = alloc_pattern; - return 0; + return UMF_RESULT_SUCCESS; } -static int CTL_WRITE_HANDLER(enable_logging)(void *ctx, - umf_ctl_query_source_t source, - void *arg, size_t size, - umf_ctl_index_utlist_t *indexes, - const char *extra_name, - umf_ctl_query_type_t query_type) { +static umf_result_t CTL_WRITE_HANDLER(enable_logging)( + void *ctx, umf_ctl_query_source_t source, void *arg, size_t size, + umf_ctl_index_utlist_t *indexes, const char *extra_name, + umf_ctl_query_type_t query_type) { /* suppress unused-parameter errors */ (void)source, (void)indexes, (void)ctx, (void)extra_name, (void)query_type, (void)size; int arg_in = *(int *)arg; enable_logging = arg_in; - return 0; + return UMF_RESULT_SUCCESS; } -static int CTL_READ_HANDLER(enable_logging)(void *ctx, - umf_ctl_query_source_t source, - void *arg, size_t size, - umf_ctl_index_utlist_t *indexes, - const char *extra_name, - umf_ctl_query_type_t query_type) { +static umf_result_t CTL_READ_HANDLER(enable_logging)( + void *ctx, umf_ctl_query_source_t source, void *arg, size_t size, + umf_ctl_index_utlist_t *indexes, const char *extra_name, + umf_ctl_query_type_t query_type) { /* suppress unused-parameter errors */ (void)source, (void)indexes, (void)ctx, (void)extra_name, (void)query_type, (void)size; int *arg_out = arg; *arg_out = enable_logging; - return 0; + return UMF_RESULT_SUCCESS; } -static int CTL_WRITE_HANDLER(log_level)(void *ctx, - umf_ctl_query_source_t source, - void *arg, size_t size, - umf_ctl_index_utlist_t *indexes, - const char *extra_name, - umf_ctl_query_type_t query_type) { +static umf_result_t CTL_WRITE_HANDLER(log_level)( + void *ctx, umf_ctl_query_source_t source, void *arg, size_t size, + umf_ctl_index_utlist_t *indexes, const char *extra_name, + umf_ctl_query_type_t query_type) { /* suppress unused-parameter errors */ (void)source, (void)indexes, (void)ctx, (void)extra_name, (void)query_type, (void)size; int arg_in = *(int *)arg; log_level = arg_in; - return 0; + return UMF_RESULT_SUCCESS; } -static int CTL_READ_HANDLER(log_level)(void *ctx, umf_ctl_query_source_t source, - void *arg, size_t size, - umf_ctl_index_utlist_t *indexes, - const char *extra_name, - umf_ctl_query_type_t query_type) { +static umf_result_t +CTL_READ_HANDLER(log_level)(void *ctx, umf_ctl_query_source_t source, void *arg, + size_t size, umf_ctl_index_utlist_t *indexes, + const char *extra_name, + umf_ctl_query_type_t query_type) { /* suppress unused-parameter errors */ (void)source, (void)indexes, (void)ctx, (void)extra_name, (void)query_type, (void)size; int *arg_out = arg; *arg_out = log_level; - return 0; + return UMF_RESULT_SUCCESS; } static const struct ctl_argument CTL_ARG(alloc_pattern) = CTL_ARG_LONG_LONG; diff --git a/test/ctl/ctl_unittest.cpp b/test/ctl/ctl_unittest.cpp index f98825bd4..28cae17a8 100644 --- a/test/ctl/ctl_unittest.cpp +++ b/test/ctl/ctl_unittest.cpp @@ -16,8 +16,9 @@ using namespace umf_test; TEST_F(test, ctl_debug_read_from_string) { initialize_debug_ctl(); auto ctl_handler = get_debug_ctl(); - ctl_load_config_from_string(ctl_handler, NULL, - "debug.heap.alloc_pattern=1"); + ASSERT_EQ(ctl_load_config_from_string(ctl_handler, NULL, + "debug.heap.alloc_pattern=1"), + UMF_RESULT_SUCCESS); int value = 0; ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC, @@ -26,16 +27,18 @@ TEST_F(test, ctl_debug_read_from_string) { ASSERT_EQ(value, 1); // Test setting alloc_pattern to 2 - ctl_load_config_from_string(ctl_handler, NULL, - "debug.heap.alloc_pattern=2"); + ASSERT_EQ(ctl_load_config_from_string(ctl_handler, NULL, + "debug.heap.alloc_pattern=2"), + UMF_RESULT_SUCCESS); ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC, "debug.heap.alloc_pattern", CTL_QUERY_READ, &value, sizeof(value)); ASSERT_EQ(value, 2); // Test setting alloc_pattern to 0 - ctl_load_config_from_string(ctl_handler, NULL, - "debug.heap.alloc_pattern=0"); + ASSERT_EQ(ctl_load_config_from_string(ctl_handler, NULL, + "debug.heap.alloc_pattern=0"), + UMF_RESULT_SUCCESS); ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC, "debug.heap.alloc_pattern", CTL_QUERY_READ, &value, sizeof(value)); @@ -45,13 +48,13 @@ TEST_F(test, ctl_debug_read_from_string) { ASSERT_NE(ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC, "debug.heap.non_existent", CTL_QUERY_READ, &value, sizeof(value)), - 0); + UMF_RESULT_SUCCESS); // Negative test: invalid path ASSERT_NE(ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC, "invalid.path.alloc_pattern", CTL_QUERY_READ, &value, sizeof(value)), - 0); + UMF_RESULT_SUCCESS); debug_ctl_register(ctl_handler); } @@ -74,7 +77,8 @@ TEST_F(test, ctl_debug_read_from_file) { 0); initialize_debug_ctl(); auto ctl_handler = get_debug_ctl(); - ASSERT_EQ(ctl_load_config_from_file(ctl_handler, NULL, "config.txt"), 0); + ASSERT_EQ(ctl_load_config_from_file(ctl_handler, NULL, "config.txt"), + UMF_RESULT_SUCCESS); int value = 0; ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC,