[CTL] Add CTL by handle

Author: KFilipek

include/umf/base.h

@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023-2024 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -48,6 +48,29 @@ typedef enum umf_result_t {
     UMF_RESULT_ERROR_UNKNOWN = 0x7ffffffe ///< Unknown or internal error
 } umf_result_t;
 
+/// @brief Type for determine the type of the CTL query
+typedef enum umf_ctl_query_type {
+    CTL_QUERY_READ,
+    CTL_QUERY_WRITE,
+    CTL_QUERY_RUNNABLE,
+    CTL_QUERY_SUBTREE,
+
+    MAX_CTL_QUERY_TYPE
+} umf_ctl_query_type;
+
+// struct ctl;
+
+// enum ctl_query_source;
+
+// int ctl_query(struct ctl *ctl, void *ctx, enum ctl_query_source source,
+//               const char *name, typedef enum umf_ctl_query_type type, void *arg);
+
+int umfCtlGet(const char *name, void *ctx, void *arg);
+
+// void umfCtlSet(const char *name, ...) { (void)name; }
+
+// void umfCtlExec(const char *name, ...) { (void)name; }
+
 #ifdef __cplusplus
 }
 #endif

include/umf/memory_pool_ops.h

@@ -17,6 +17,26 @@
 extern "C" {
 #endif
 
+/// @brief This structure comprises function pointers used by corresponding umfMemoryPool calls.
+typedef struct umf_memory_pool_ext_ops_t {
+    ///
+    /// @brief Control operation for the memory provider.
+    ///        The function is used to perform various control operations
+    ///        on the memory provider.
+    ///
+    /// @param hPool handle to the memory provider.
+    /// @param operationType type of the operation to be performed.
+    /// @param name name associated with the operation.
+    /// @param arg argument for the operation.
+    /// @param extra_name additional name associated with the operation.
+    /// @param query_type type of the query to be performed.
+    ///
+    /// @return umf_result_t result of the control operation.
+    ///
+    umf_result_t (*ctl)(void *hPool, int operationType, const char *name,
+                        void *arg, umf_ctl_query_type query_type);
+} umf_memory_pool_ext_ops_t;
+
 ///
 /// @brief This structure comprises function pointers used by corresponding umfPool*
 /// calls. Each memory pool implementation should initialize all function
@@ -120,6 +140,11 @@ typedef struct umf_memory_pool_ops_t {
     ///         The value is undefined if the previous allocation was successful.
     ///
     umf_result_t (*get_last_allocation_error)(void *pool);
+
+    ///
+    /// @brief Optional ops
+    ///
+    umf_memory_provider_ext_ops_t ext;
 } umf_memory_pool_ops_t;
 
 #ifdef __cplusplus

include/umf/memory_provider_ops.h

@@ -1,12 +1,11 @@
 /*
  *
- * Copyright (C) 2023-2024 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  *
  */
-
 #ifndef UMF_MEMORY_PROVIDER_OPS_H
 #define UMF_MEMORY_PROVIDER_OPS_H 1
 
@@ -78,6 +77,23 @@ typedef struct umf_memory_provider_ext_ops_t {
     umf_result_t (*allocation_split)(void *hProvider, void *ptr,
                                      size_t totalSize, size_t firstSize);
 
+    ///
+    /// @brief Control operation for the memory provider.
+    ///        The function is used to perform various control operations
+    ///        on the memory provider.
+    ///
+    /// @param hProvider handle to the memory provider.
+    /// @param operationType type of the operation to be performed.
+    /// @param name name associated with the operation.
+    /// @param arg argument for the operation.
+    /// @param extra_name additional name associated with the operation.
+    /// @param query_type type of the query to be performed.
+    ///
+    /// @return umf_result_t result of the control operation.
+    ///
+    umf_result_t (*ctl)(void *hProvider, int operationType, const char *name,
+                        void *arg, umf_ctl_query_type query_type);
+
 } umf_memory_provider_ext_ops_t;
 
 ///

src/ctl/ctl.c

@@ -43,6 +43,7 @@
 #define CTL_QUERY_NODE_SEPARATOR "."
 #define CTL_VALUE_ARG_SEPARATOR ","
 
+/* GLOBAL TREE */
 static int ctl_global_first_free = 0;
 static struct ctl_node CTL_NODE(global)[CTL_MAX_ENTRIES];
 
@@ -78,6 +79,11 @@ char *Strdup(const char *s) {
     return p;
 }
 
+int umfCtlGet(const char *name, void *ctx, void *arg) {
+    return ctl_query(NULL, ctx, CTL_QUERY_PROGRAMMATIC, name, CTL_QUERY_READ,
+                     arg);
+}
+
 /*
  * ctl_find_node -- (internal) searches for a matching entry point in the
  *    provided nodes
@@ -102,6 +108,9 @@ static const struct ctl_node *ctl_find_node(const struct ctl_node *nodes,
      * in the main ctl tree.
      */
     while (node_name != NULL) {
+        if (n != NULL && n->type == CTL_NODE_SUBTREE) {
+            break;
+        }
         char *endptr;
         /*
          * Ignore errno from strtol: FreeBSD returns EINVAL if no
@@ -128,6 +137,7 @@ static const struct ctl_node *ctl_find_node(const struct ctl_node *nodes,
                 break;
             }
         }
+
         if (n->name == NULL) {
             goto error;
         }
@@ -244,21 +254,29 @@ static void ctl_query_cleanup_real_args(const struct ctl_node *n,
  */
 static int ctl_exec_query_read(void *ctx, const struct ctl_node *n,
                                enum ctl_query_source source, void *arg,
-                               struct ctl_index_utlist *indexes) {
+                               struct ctl_index_utlist *indexes,
+                               char *extra_name,
+                               umf_ctl_query_type query_type) {
+    (void)extra_name, (void)query_type;
     if (arg == NULL) {
         errno = EINVAL;
         return -1;
     }
 
-    return n->cb[CTL_QUERY_READ](ctx, source, arg, indexes);
+    assert(MAX_CTL_QUERY_TYPE != query_type);
+    return n->cb[CTL_QUERY_READ](ctx, source, arg, indexes, NULL,
+                                 MAX_CTL_QUERY_TYPE);
 }
 
 /*
  * ctl_exec_query_write -- (internal) calls the write callback of a node
  */
 static int ctl_exec_query_write(void *ctx, const struct ctl_node *n,
                                 enum ctl_query_source source, void *arg,
-                                struct ctl_index_utlist *indexes) {
+                                struct ctl_index_utlist *indexes,
+                                char *extra_name,
+                                umf_ctl_query_type query_type) {
+    (void)extra_name, (void)query_type;
     if (arg == NULL) {
         errno = EINVAL;
         return -1;
@@ -269,7 +287,9 @@ static int ctl_exec_query_write(void *ctx, const struct ctl_node *n,
         return -1;
     }
 
-    int ret = n->cb[CTL_QUERY_WRITE](ctx, source, real_arg, indexes);
+    assert(MAX_CTL_QUERY_TYPE != query_type);
+    int ret = n->cb[CTL_QUERY_WRITE](ctx, source, real_arg, indexes, NULL,
+                                     MAX_CTL_QUERY_TYPE);
     ctl_query_cleanup_real_args(n, real_arg, source);
 
     return ret;
@@ -280,24 +300,40 @@ static int ctl_exec_query_write(void *ctx, const struct ctl_node *n,
  */
 static int ctl_exec_query_runnable(void *ctx, const struct ctl_node *n,
                                    enum ctl_query_source source, void *arg,
-                                   struct ctl_index_utlist *indexes) {
-    return n->cb[CTL_QUERY_RUNNABLE](ctx, source, arg, indexes);
+                                   struct ctl_index_utlist *indexes,
+                                   char *extra_name,
+                                   umf_ctl_query_type query_type) {
+    (void)extra_name, (void)query_type;
+    assert(MAX_CTL_QUERY_TYPE != query_type);
+    return n->cb[CTL_QUERY_RUNNABLE](ctx, source, arg, indexes, NULL,
+                                     MAX_CTL_QUERY_TYPE);
+}
+
+static int ctl_exec_query_subtree(void *ctx, const struct ctl_node *n,
+                                  enum ctl_query_source source, void *arg,
+                                  struct ctl_index_utlist *indexes,
+                                  char *extra_name,
+                                  umf_ctl_query_type query_type) {
+    return n->cb[CTL_QUERY_SUBTREE](ctx, source, arg, indexes, extra_name,
+                                    query_type);
 }
 
 static int (*ctl_exec_query[MAX_CTL_QUERY_TYPE])(
     void *ctx, const struct ctl_node *n, enum ctl_query_source source,
-    void *arg, struct ctl_index_utlist *indexes) = {
+    void *arg, struct ctl_index_utlist *indexes, char *extra_name,
+    umf_ctl_query_type query_type) = {
     ctl_exec_query_read,
     ctl_exec_query_write,
     ctl_exec_query_runnable,
+    ctl_exec_query_subtree,
 };
 
 /*
  * ctl_query -- (internal) parses the name and calls the appropriate methods
  *    from the ctl tree
  */
 int ctl_query(struct ctl *ctl, void *ctx, enum ctl_query_source source,
-              const char *name, enum ctl_query_type type, void *arg) {
+              const char *name, umf_ctl_query_type type, void *arg) {
     if (name == NULL) {
         errno = EINVAL;
         return -1;
@@ -324,13 +360,17 @@ int ctl_query(struct ctl *ctl, void *ctx, enum ctl_query_source source,
         n = ctl_find_node(ctl->root, name, indexes);
     }
 
-    if (n == NULL || n->type != CTL_NODE_LEAF || n->cb[type] == NULL) {
+    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;
         goto out;
     }
 
-    ret = ctl_exec_query[type](ctx, n, source, arg, indexes);
-
+    char *extra_name = strstr(name, n->name);
+    ret =
+        ctl_exec_query[n->type == CTL_NODE_SUBTREE ? CTL_QUERY_SUBTREE : type](
+            ctx, n, source, arg, indexes, extra_name, type);
 out:
     ctl_delete_indexes(indexes);
 

src/ctl/ctl.h

@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2016-2024 Intel Corporation
+ * Copyright (C) 2016-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -18,6 +18,8 @@
 #ifndef UMF_CTL_H
 #define UMF_CTL_H 1
 
+#include <umf/memory_pool.h>
+
 #include <errno.h>
 #include <stddef.h>
 
@@ -43,22 +45,16 @@ enum ctl_query_source {
     MAX_CTL_QUERY_SOURCE
 };
 
-enum ctl_query_type {
-    CTL_QUERY_READ,
-    CTL_QUERY_WRITE,
-    CTL_QUERY_RUNNABLE,
-
-    MAX_CTL_QUERY_TYPE
-};
-
 typedef int (*node_callback)(void *ctx, enum ctl_query_source type, void *arg,
-                             struct ctl_index_utlist *indexes);
+                             struct ctl_index_utlist *indexes, char *extra_name,
+                             umf_ctl_query_type query_type);
 
 enum ctl_node_type {
     CTL_NODE_UNKNOWN,
     CTL_NODE_NAMED,
     CTL_NODE_LEAF,
     CTL_NODE_INDEXED,
+    CTL_NODE_SUBTREE,
 
     MAX_CTL_NODE
 };
@@ -104,6 +100,8 @@ struct ctl_node {
 struct ctl *ctl_new(void);
 void ctl_delete(struct ctl *stats);
 
+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);
@@ -139,7 +137,7 @@ 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, enum ctl_query_source source,
-              const char *name, enum ctl_query_type type, void *arg);
+              const char *name, umf_ctl_query_type type, void *arg);
 
 /* Declaration of a new child node */
 #define CTL_CHILD(name, ...)                                                   \
@@ -161,6 +159,8 @@ int ctl_query(struct ctl *ctl, void *ctx, enum ctl_query_source source,
 
 #define CTL_RUNNABLE_HANDLER(name, ...) ctl_##__VA_ARGS__##_##name##_runnable
 
+#define CTL_SUBTREE_HANDLER(name, ...) ctl_##__VA_ARGS__##_##name##_subtree
+
 #define CTL_ARG(name) ctl_arg_##name
 
 /*
@@ -170,7 +170,8 @@ int ctl_query(struct ctl *ctl, void *ctx, enum ctl_query_source source,
 #define CTL_LEAF_RO(name, ...)                                                 \
     {                                                                          \
         CTL_STR(name), CTL_NODE_LEAF,                                          \
-            {CTL_READ_HANDLER(name, __VA_ARGS__), NULL, NULL}, NULL, NULL      \
+            {CTL_READ_HANDLER(name, __VA_ARGS__), NULL, NULL, NULL}, NULL,     \
+            NULL                                                               \
     }
 
 /*
@@ -180,7 +181,7 @@ int ctl_query(struct ctl *ctl, void *ctx, enum ctl_query_source source,
 #define CTL_LEAF_WO(name, ...)                                                 \
     {                                                                          \
         CTL_STR(name), CTL_NODE_LEAF,                                          \
-            {NULL, CTL_WRITE_HANDLER(name, __VA_ARGS__), NULL},                \
+            {NULL, CTL_WRITE_HANDLER(name, __VA_ARGS__), NULL, NULL},          \
             &CTL_ARG(name), NULL                                               \
     }
 
@@ -191,7 +192,22 @@ int ctl_query(struct ctl *ctl, void *ctx, enum ctl_query_source source,
 #define CTL_LEAF_RUNNABLE(name, ...)                                           \
     {                                                                          \
         CTL_STR(name), CTL_NODE_LEAF,                                          \
-            {NULL, NULL, CTL_RUNNABLE_HANDLER(name, __VA_ARGS__)}, NULL, NULL  \
+            {NULL, NULL, CTL_RUNNABLE_HANDLER(name, __VA_ARGS__), NULL}, NULL, \
+            NULL                                                               \
+    }
+
+#define CTL_LEAF_SUBTREE(name, ...)                                            \
+    {                                                                          \
+        CTL_STR(name), CTL_NODE_SUBTREE,                                       \
+            {NULL, NULL, NULL, CTL_SUBTREE_HANDLER(name, __VA_ARGS__)}, NULL,  \
+            NULL                                                               \
+    }
+
+#define CTL_LEAF_SUBTREE2(name, fun, ...)                                      \
+    {                                                                          \
+        CTL_STR(name), CTL_NODE_SUBTREE,                                       \
+            {NULL, NULL, NULL, CTL_SUBTREE_HANDLER(fun, __VA_ARGS__)}, NULL,   \
+            NULL                                                               \
     }
 
 /*
@@ -201,7 +217,7 @@ int ctl_query(struct ctl *ctl, void *ctx, enum ctl_query_source source,
 #define CTL_LEAF_RW(name)                                                      \
     {                                                                          \
         CTL_STR(name), CTL_NODE_LEAF,                                          \
-            {CTL_READ_HANDLER(name), CTL_WRITE_HANDLER(name), NULL},           \
+            {CTL_READ_HANDLER(name), CTL_WRITE_HANDLER(name), NULL, NULL},     \
             &CTL_ARG(name), NULL                                               \
     }