add pool_by_name

lplewa · lplewa · commit df6508d6591d · 2025-08-01T15:33:08.000+02:00
diff --git a/docs/config/spelling_exceptions.txt b/docs/config/spelling_exceptions.txt
@@ -71,4 +71,5 @@ umfPoolMallocUsableSize
 umfPoolRealloc
 umfMemspaceUserFilter
 umfMemspaceMemtargetAdd
-unfreed
+unfreed
+zA
diff --git a/include/umf/memory_pool_ops.h b/include/umf/memory_pool_ops.h
@@ -138,8 +138,13 @@ typedef struct umf_memory_pool_ops_t {
     ///
     /// * Implementations *must* return default pool name when NULL is provided,
     ///   otherwise the pool's name is returned.
-    /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
     ///
+    /// * The returned name should not exceed 64 characters and may contain
+    ///   only [a-zA-Z0-9_-] characters. Names violating these rules are deprecated
+    ///   and will not be supported in the next major API release.
+    ///   CTL functionality may be limited if other characters are returned.
+    ///
+    /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
     umf_result_t (*get_name)(void *pool, const char **name);
 
     ///
diff --git a/include/umf/memory_provider_ops.h b/include/umf/memory_provider_ops.h
@@ -123,8 +123,18 @@ typedef struct umf_memory_provider_ops_t {
     /// @brief Retrieve name of a given memory \p provider.
     /// @param provider pointer to the memory provider
     /// @param name [out] pointer to a string containing the name of the \p provider
-    /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+    /// \details
+    /// * Implementations *must* return a literal null-terminated string.
+    ///
+    /// * Implementations *must* return default pool name when NULL is provided,
+    ///   otherwise the pool's name is returned.
     ///
+    /// * The returned name should not exceed 64 characters and may contain
+    ///   only [a-zA-Z0-9_-] characters. Names violating these rules are deprecated
+    ///   and will not be supported in the next major API release.
+    ///   CTL functionality may be limited if other characters are returned.
+    ///
+    /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
     umf_result_t (*get_name)(void *provider, const char **name);
 
     ///
diff --git a/include/umf/pools/pool_disjoint.h b/include/umf/pools/pool_disjoint.h
@@ -111,6 +111,8 @@ umf_result_t umfDisjointPoolParamsSetSharedLimits(
 /// @param hParams handle to the parameters of the disjoint pool.
 /// @param name custom name of the pool. Must not be NULL. Name longer than 63
 ///        characters will be truncated.
+/// \details Name should contain only [a-zA-Z0-9_-] characters.
+/// Other names are deprecated and may limit CTL functionality.
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 umf_result_t
 umfDisjointPoolParamsSetName(umf_disjoint_pool_params_handle_t hParams,
diff --git a/include/umf/pools/pool_jemalloc.h b/include/umf/pools/pool_jemalloc.h
@@ -47,6 +47,8 @@ umfJemallocPoolParamsSetNumArenas(umf_jemalloc_pool_params_handle_t hParams,
 /// @param hParams handle to the parameters of the jemalloc pool.
 /// @param name custom name. Must not be NULL. Name longer than 63 characters
 ///        will be truncated.
+/// \details Name should contain only [a-zA-Z0-9_-] characters.
+/// Other names are deprecated and may limit CTL functionality.
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 umf_result_t
 umfJemallocPoolParamsSetName(umf_jemalloc_pool_params_handle_t hParams,
diff --git a/include/umf/pools/pool_scalable.h b/include/umf/pools/pool_scalable.h
@@ -57,6 +57,8 @@ umfScalablePoolParamsSetKeepAllMemory(umf_scalable_pool_params_handle_t hParams,
 /// @param  hParams handle to the parameters of the scalable pool.
 /// @param  name custom name. Must not be NULL. Name longer than 63 characters
 ///         will be truncated.
+/// \details Name should contain only [a-zA-Z0-9_-] characters.
+/// Other names are deprecated and may limit CTL functionality.
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 umf_result_t
 umfScalablePoolParamsSetName(umf_scalable_pool_params_handle_t hParams,
diff --git a/include/umf/providers/provider_cuda.h b/include/umf/providers/provider_cuda.h
@@ -65,6 +65,8 @@ umf_result_t umfCUDAMemoryProviderParamsSetAllocFlags(
 /// @param  hParams handle to the parameters of the CUDA Memory Provider.
 /// @param  name custom name. Must not be NULL. Name longer than 63 characters
 ///         will be truncated.
+/// \details Name should contain only [a-zA-Z0-9_-] characters.
+/// Other names are deprecated and may limit CTL functionality.
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 umf_result_t umfCUDAMemoryProviderParamsSetName(
     umf_cuda_memory_provider_params_handle_t hParams, const char *name);
diff --git a/include/umf/providers/provider_devdax_memory.h b/include/umf/providers/provider_devdax_memory.h
@@ -60,6 +60,8 @@ umf_result_t umfDevDaxMemoryProviderParamsSetProtection(
 /// @param  hParams [in]  handle to the parameters of the Devdax Memory Provider.
 /// @param  name [in] custom name. Must not be NULL. Name longer than 63 characters
 ///         will be truncated.
+/// \details Name should contain only [a-zA-Z0-9_-] characters.
+/// Other names are deprecated and may limit CTL functionality.
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 umf_result_t umfDevDaxMemoryProviderParamsSetName(
     umf_devdax_memory_provider_params_handle_t hParams, const char *name);
diff --git a/include/umf/providers/provider_file_memory.h b/include/umf/providers/provider_file_memory.h
@@ -72,6 +72,8 @@ const umf_memory_provider_ops_t *umfFileMemoryProviderOps(void);
 /// @param  hParams handle to the parameters of the File Memory Provider.
 /// @param  name custom name. Must not be NULL. Name longer than 63 characters
 ///         will be truncated.
+/// \details Name should contain only [a-zA-Z0-9_-] characters.
+/// Other names are deprecated and may limit CTL functionality.
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 umf_result_t umfFileMemoryProviderParamsSetName(
     umf_file_memory_provider_params_handle_t hParams, const char *name);
diff --git a/include/umf/providers/provider_fixed_memory.h b/include/umf/providers/provider_fixed_memory.h
@@ -55,6 +55,8 @@ const umf_memory_provider_ops_t *umfFixedMemoryProviderOps(void);
 /// @param  hParams [in] handle to the parameters of the Fixed Memory Provider.
 /// @param  name [in] custom name. Must not be NULL. Name longer than 63 characters
 ///         will be truncated.
+/// \details Name should contain only [a-zA-Z0-9_-] characters.
+/// Other names are deprecated and may limit CTL functionality.
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 umf_result_t umfFixedMemoryProviderParamsSetName(
     umf_fixed_memory_provider_params_handle_t hParams, const char *name);
diff --git a/include/umf/providers/provider_level_zero.h b/include/umf/providers/provider_level_zero.h
@@ -95,6 +95,8 @@ umf_result_t umfLevelZeroMemoryProviderParamsSetDeviceOrdinal(
 /// @param  hParams handle to the parameters of the Level Zero Memory Provider.
 /// @param  name custom name. Must not be NULL. Name longer than 63 characters
 ///         will be truncated.
+/// \details Name should contain only [a-zA-Z0-9_-] characters.
+/// Other names are deprecated and may limit CTL functionality.
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 umf_result_t umfLevelZeroMemoryProviderParamsSetName(
     umf_level_zero_memory_provider_params_handle_t hParams, const char *name);
diff --git a/include/umf/providers/provider_os_memory.h b/include/umf/providers/provider_os_memory.h
@@ -138,6 +138,8 @@ umf_result_t umfOsMemoryProviderParamsSetPartitions(
 /// @param  hParams handle to the parameters of the OS memory provider.
 /// @param  name custom name. Must not be NULL. Name longer than 63 characters
 ///         will be truncated.
+/// \details Name should contain only [a-zA-Z0-9_-] characters.
+/// Other names are deprecated and may limit CTL functionality.
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 umf_result_t
 umfOsMemoryProviderParamsSetName(umf_os_memory_provider_params_handle_t hParams,
diff --git a/src/base_alloc/base_alloc_global.c b/src/base_alloc/base_alloc_global.c
@@ -265,3 +265,19 @@ size_t umf_ba_global_malloc_usable_size(const void *ptr) {
 
     return usable_size;
 }
+
+char *umf_ba_global_strdup(const char *s) {
+    if (!s) {
+        return NULL;
+    }
+
+    size_t len = strlen(s);
+
+    char *ptr = umf_ba_global_alloc(len + 1);
+    if (!ptr) {
+        return NULL;
+    }
+
+    memcpy(ptr, s, len + 1);
+    return ptr;
+}
diff --git a/src/base_alloc/base_alloc_global.h b/src/base_alloc/base_alloc_global.h
@@ -22,6 +22,7 @@ void umf_ba_destroy_global(void);
 bool umf_ba_global_is_destroyed(void);
 size_t umf_ba_global_malloc_usable_size(const void *ptr);
 void *umf_ba_global_aligned_alloc(size_t size, size_t alignment);
+char *umf_ba_global_strdup(const char *s);
 
 #ifdef __cplusplus
 }
diff --git a/src/ctl/ctl.c b/src/ctl/ctl.c
@@ -95,7 +95,7 @@ char *Strdup(const char *s) {
         }                                                                      \
         case CTL_ARG_TYPE_STRING: {                                            \
             char *str = va_arg(va, char *);                                    \
-            memcpy(output, str, ctl_argument->dest_size);                      \
+            snprintf((char *)output, ctl_argument->dest_size, "%s", str);      \
             break;                                                             \
         }                                                                      \
         case CTL_ARG_TYPE_INT: {                                               \
@@ -108,9 +108,14 @@ char *Strdup(const char *s) {
             *(long long *)output = ll;                                         \
             break;                                                             \
         }                                                                      \
+        case CTL_ARG_TYPE_UNSIGNED_LONG_LONG: {                                \
+            unsigned long long ll = va_arg(va, unsigned long long);            \
+            *(unsigned long long *)output = ll;                                \
+            break;                                                             \
+        }                                                                      \
         case CTL_ARG_TYPE_PTR: {                                               \
-            void *p = va_arg(va, void *);                                      \
-            *(uintptr_t *)output = (uintptr_t)p;                               \
+            void *ptr = va_arg(va, void *);                                    \
+            *(uintptr_t *)output = (uintptr_t)ptr;                             \
             break;                                                             \
         }                                                                      \
         default:                                                               \
@@ -173,9 +178,6 @@ static void *ctl_parse_args(const struct ctl_argument *arg_proto, char *arg) {
     char *arg_sep = strtok_r(arg, CTL_VALUE_ARG_SEPARATOR, &sptr);
     for (const struct ctl_argument_parser *p = arg_proto->parsers;
          p->parser != NULL; ++p) {
-        if (arg_sep == NULL) {
-            goto error_parsing;
-        }
 
         if (p->parser(arg_sep, dest_arg + p->dest_offset, p->dest_size) != 0) {
             goto error_parsing;
@@ -375,31 +377,53 @@ ctl_find_and_execute_node(const umf_ctl_node_t *nodes, void *ctx,
                 // if the node has an argument, but no next node, then it is an error
                 goto error;
             }
-            void *node_arg;
-            if (strcmp(next_node, CTL_WILDCARD) == 0) {
-                if (source == CTL_QUERY_CONFIG_INPUT) {
-                    LOG_ERR(
-                        "ctl {} wildcard is not supported for config input");
-                    goto error;
-                }
-                // argument is a wildcard so we need to allocate it from va_list
-                node_arg = ctl_malloc_fn(n->arg->dest_size);
-                if (node_arg == NULL) {
-                    goto error;
-                }
-                pop_va_list(args, n->arg, node_arg);
-            } else {
-                node_arg = ctl_parse_args(n->arg, next_node);
 
-                if (node_arg == NULL) {
-                    goto error;
+            char *node_arg = ctl_malloc_fn(n->arg->dest_size);
+            if (node_arg == NULL) {
+                goto error;
+            }
+
+            char *sptr2 = NULL;
+            char *arg_sep =
+                strtok_r(next_node, CTL_VALUE_ARG_SEPARATOR, &sptr2);
+            for (const struct ctl_argument_parser *p = n->arg->parsers;
+                 p->dest_size != 0; ++p) {
+                if (arg_sep && strcmp(arg_sep, CTL_WILDCARD) == 0) {
+                    if (source == CTL_QUERY_CONFIG_INPUT) {
+                        ctl_free_fn(node_arg);
+                        LOG_ERR("ctl {} wildcard is not supported for config "
+                                "input");
+                        goto error;
+                    }
+
+                    if (p->type == CTL_ARG_TYPE_UNKNOWN) {
+                        ctl_free_fn(node_arg);
+                        LOG_ERR("ctl {} wildcard is not supported for node: %s",
+                                node_name);
+                        goto error;
+                    }
+                    char *output = node_arg + p->dest_offset;
+                    pop_va_list(args, p, output);
+                } else {
+                    if (!p->parser) {
+                        LOG_ERR("this node can be only pass as {} wildcard: %s",
+                                arg_sep);
+                        ctl_free_fn(node_arg);
+                        goto error;
+                    }
+                    if (p->parser(arg_sep, node_arg + p->dest_offset,
+                                  p->dest_size) != 0) {
+                        ctl_free_fn(node_arg);
+                        goto error;
+                    }
                 }
+                arg_sep = strtok_r(NULL, CTL_VALUE_ARG_SEPARATOR, &sptr2);
             }
 
             umf_ctl_index_utlist_t *entry = NULL;
             entry = ctl_malloc_fn(sizeof(*entry));
             if (entry == NULL) {
-                ctl_free_fn(arg);
+                ctl_free_fn(node_arg);
                 goto error;
             }
 
@@ -678,6 +702,22 @@ umf_result_t ctl_load_config_from_file(struct ctl *ctl, void *ctx,
     return ret;
 }
 
+/*
+ * ctl_parse_ull -- (internal) parses and returns an unsigned long long
+ */
+static unsigned long long ctl_parse_ull(const char *str) {
+    char *endptr;
+    int olderrno = errno;
+    errno = 0;
+    unsigned long long val = strtoull(str, &endptr, 0);
+    if (endptr == str || errno != 0) {
+        return ULLONG_MAX;
+    }
+    errno = olderrno;
+
+    return val;
+}
+
 /*
  * ctl_parse_ll -- (internal) parses and returns a long long signed integer
  */
@@ -701,6 +741,9 @@ static long long ctl_parse_ll(const char *str) {
 int ctl_arg_boolean(const void *arg, void *dest, size_t dest_size) {
     /* suppress unused-parameter errors */
     (void)dest_size;
+    if (!arg) {
+        return -1;
+    }
 
     int *intp = dest;
     char in = ((const char *)arg)[0];
@@ -716,10 +759,49 @@ int ctl_arg_boolean(const void *arg, void *dest, size_t dest_size) {
     return -1;
 }
 
+/*
+ * ctl_arg_unsigned -- parses unsigned integer argument
+ */
+int ctl_arg_unsigned(const void *arg, void *dest, size_t dest_size) {
+    if (!arg) {
+        return -1;
+    }
+
+    unsigned long long val = ctl_parse_ull(arg);
+    if (val == ULLONG_MAX) {
+        return -1;
+    }
+
+    switch (dest_size) {
+    case sizeof(unsigned int):
+        if (val > UINT_MAX) {
+            return -1;
+        }
+        *(unsigned int *)dest = (unsigned int)val;
+        break;
+    case sizeof(unsigned long long):
+        *(unsigned long long *)dest = val;
+        break;
+    case sizeof(uint8_t):
+        if (val > UINT8_MAX) {
+            return -1;
+        }
+        *(uint8_t *)dest = (uint8_t)val;
+        break;
+    default:
+        return -1;
+    }
+
+    return 0;
+}
+
 /*
  * ctl_arg_integer -- parses signed integer argument
  */
 int ctl_arg_integer(const void *arg, void *dest, size_t dest_size) {
+    if (!arg) {
+        return -1;
+    }
     long long val = ctl_parse_ll(arg);
     if (val == LLONG_MIN) {
         return -1;
@@ -735,12 +817,6 @@ int ctl_arg_integer(const void *arg, void *dest, size_t dest_size) {
     case sizeof(long long):
         *(long long *)dest = val;
         break;
-    case sizeof(uint8_t):
-        if (val > UINT8_MAX || val < 0) {
-            return -1;
-        }
-        *(uint8_t *)dest = (uint8_t)val;
-        break;
     default:
         return -1;
     }
@@ -753,6 +829,10 @@ int ctl_arg_integer(const void *arg, void *dest, size_t dest_size) {
  *    buffer
  */
 int ctl_arg_string(const void *arg, void *dest, size_t dest_size) {
+    if (!arg) {
+        return -1;
+    }
+
     /* check if the incoming string is longer or equal to dest_size */
     if (strnlen(arg, dest_size) == dest_size) {
         return -1;
diff --git a/src/ctl/ctl_internal.h b/src/ctl/ctl_internal.h
diff --git a/src/memory_pool.c b/src/memory_pool.c
diff --git a/src/memory_provider.c b/src/memory_provider.c
diff --git a/src/utils/utils_name.h b/src/utils/utils_name.h
diff --git a/test/ctl/ctl_api.cpp b/test/ctl/ctl_api.cpp
diff --git a/test/memoryProviderAPI.cpp b/test/memoryProviderAPI.cpp
