Add umfFixedMemoryProviderParamsSetFlags()

Add umfFixedMemoryProviderParamsSetFlags() to set flags
of Fixed-size Memory Provider.

Add the UMF_FIXED_FLAG_CREATE_FROM_POOL_PTR flag
that makes it possible to create Fixed-size Memory Provider
from a pointer belonging to a UMF memory pool.
This pointer is already tracked in the UMF tracker,
so we will have to remove this memory range <base, base+size)
from the tracker.

Signed-off-by: Lukasz Dorau <lukasz.dorau@intel.com>

Author: ldorau

include/umf/providers/provider_fixed_memory.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-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,14 @@ extern "C" {
 #define UMF_FIXED_RESULTS_START_FROM 4000
 /// @endcond
 
+/// @brief Fixed Memory Provider flags
+typedef enum umf_fixed_memory_provider_flag {
+    UMF_FIXED_FLAG_DEFAULT = 0, ///< the default - no flags set
+    UMF_FIXED_FLAG_CREATE_FROM_POOL_PTR =
+        (1
+         << 0), ///< The Fixed Memory Provider is created from the UMF pool's pointer
+} umf_fixed_memory_provider_flag_t;
+
 struct umf_fixed_memory_provider_params_t;
 
 typedef struct umf_fixed_memory_provider_params_t
@@ -41,6 +49,13 @@ umf_result_t umfFixedMemoryProviderParamsCreate(
 umf_result_t umfFixedMemoryProviderParamsSetMemory(
     umf_fixed_memory_provider_params_handle_t hParams, void *ptr, size_t size);
 
+/// @brief  Set the memory region flags in params struct.
+/// @param  hParams [in] handle to the parameters of the Fixed Memory Provider.
+/// @param  flags [in] flags for the memory region.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfFixedMemoryProviderParamsSetFlags(
+    umf_fixed_memory_provider_params_handle_t hParams, unsigned int flags);
+
 /// @brief  Destroy parameters struct.
 /// @param  hParams [in] handle to the parameters of the Fixed Memory Provider.
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.

src/libumf.def

@@ -134,5 +134,6 @@ EXPORTS
     umfFixedMemoryProviderOps
     umfFixedMemoryProviderParamsCreate
     umfFixedMemoryProviderParamsDestroy
+    umfFixedMemoryProviderParamsSetFlags
     umfLevelZeroMemoryProviderParamsSetFreePolicy
     umfLevelZeroMemoryProviderParamsSetDeviceOrdinal

src/libumf.map

@@ -132,6 +132,7 @@ UMF_0.11 {
         umfFixedMemoryProviderOps;
         umfFixedMemoryProviderParamsCreate;
         umfFixedMemoryProviderParamsDestroy;
+        umfFixedMemoryProviderParamsSetFlags;
         umfLevelZeroMemoryProviderParamsSetFreePolicy;
         umfLevelZeroMemoryProviderParamsSetDeviceOrdinal;
 } UMF_0.10;

src/provider/provider_fixed_memory.c

@@ -27,15 +27,20 @@
 #define TLS_MSG_BUF_LEN 1024
 
 typedef struct fixed_memory_provider_t {
-    void *base;       // base address of memory
-    size_t size;      // size of the memory region
-    coarse_t *coarse; // coarse library handle
+    void *base;         // base address of memory
+    size_t size;        // size of the memory region
+    unsigned int flags; // flags of the memory region
+    coarse_t *coarse;   // coarse library handle
+
+    // used only when the UMF_FIXED_FLAG_CREATE_FROM_POOL_PTR flag is set
+    size_t ptr_orig_size; // original size of the memory region in the tracker
 } fixed_memory_provider_t;
 
 // Fixed Memory provider settings struct
 typedef struct umf_fixed_memory_provider_params_t {
     void *ptr;
     size_t size;
+    unsigned int flags;
 } umf_fixed_memory_provider_params_t;
 
 typedef struct fixed_last_native_error_t {
@@ -83,6 +88,7 @@ static umf_result_t fixed_allocation_merge_cb(void *provider, void *lowPtr,
 
 static umf_result_t fixed_initialize(void *params, void **provider) {
     umf_result_t ret;
+    size_t ptr_orig_size = 0;
 
     if (params == NULL) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
@@ -91,6 +97,15 @@ static umf_result_t fixed_initialize(void *params, void **provider) {
     umf_fixed_memory_provider_params_t *in_params =
         (umf_fixed_memory_provider_params_t *)params;
 
+    if (in_params->flags & UMF_FIXED_FLAG_CREATE_FROM_POOL_PTR) {
+        umf_memory_pool_handle_t pool = umfPoolByPtr(in_params->ptr);
+        if (pool == NULL) {
+            LOG_ERR("The UMF_FIXED_FLAG_CREATE_FROM_POOL_PTR flag is set, but "
+                    "the given pointer does not belong to any UMF pool");
+            return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        }
+    }
+
     fixed_memory_provider_t *fixed_provider =
         umf_ba_global_alloc(sizeof(*fixed_provider));
     if (!fixed_provider) {
@@ -122,6 +137,8 @@ static umf_result_t fixed_initialize(void *params, void **provider) {
 
     fixed_provider->base = in_params->ptr;
     fixed_provider->size = in_params->size;
+    fixed_provider->flags = in_params->flags;
+    fixed_provider->ptr_orig_size = ptr_orig_size;
 
     // add the entire memory as a single block
     ret = coarse_add_memory_fixed(coarse, fixed_provider->base,
@@ -333,5 +350,26 @@ umf_result_t umfFixedMemoryProviderParamsSetMemory(
 
     hParams->ptr = ptr;
     hParams->size = size;
+    hParams->flags = 0;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfFixedMemoryProviderParamsSetFlags(
+    umf_fixed_memory_provider_params_handle_t hParams, unsigned int flags) {
+    if (hParams == NULL) {
+        LOG_ERR("Memory Provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if ((flags & UMF_FIXED_FLAG_CREATE_FROM_POOL_PTR) &&
+        (umfPoolByPtr(hParams->ptr) == NULL)) {
+        LOG_ERR("Cannot set the UMF_FIXED_FLAG_CREATE_FROM_POOL_PTR, because "
+                "the given pointer does not belong to any UMF pool");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->flags = flags;
+
     return UMF_RESULT_SUCCESS;
 }