x

Author: bratpiorka

src/memory_pool.c

@@ -296,6 +296,7 @@ umf_result_t umfPoolByPtr(const void *ptr, umf_memory_pool_handle_t *pool) {
     umf_memory_properties_handle_t props = NULL;
     umf_result_t ret = umfGetMemoryPropertiesHandle(ptr, &props);
     if (ret != UMF_RESULT_SUCCESS || props == NULL || props->pool == NULL) {
+        *pool = NULL;
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 

src/memory_props.c

@@ -17,27 +17,40 @@
 #include "memory_provider_internal.h"
 #include "provider/provider_tracking.h"
 
+// TODO flag - IPC?
 umf_result_t
 umfGetMemoryPropertiesHandle(const void *ptr,
                              umf_memory_properties_handle_t *props_handle) {
 
-    LOG_DEBUG("umfGetMemoryPropertiesHandle: ptr=%p, props_handle=%p", ptr,
-              props_handle);
+    //LOG_DEBUG("umfGetMemoryPropertiesHandle: ptr=%p, props_handle=%p", ptr,
+    //          props_handle);
 
     if (props_handle == NULL) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
     tracker_alloc_info_t *info = NULL;
     umf_result_t ret = umfMemoryTrackerGetAllocInfo(ptr, &info);
-    if (ret != UMF_RESULT_SUCCESS) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+
+    if (ret == UMF_RESULT_SUCCESS) {
+        *props_handle = &info->props;
+        //LOG_DEBUG("umfGetMemoryPropertiesHandle: props_handle=%p, id=%" PRIu64,
+        //          *props_handle, (*props_handle)->id);
+        return UMF_RESULT_SUCCESS;
     }
 
-    *props_handle = &info->props;
+    // try to get IPC info
+    umf_ipc_info_t ipc_info;
+    ret = umfMemoryTrackerGetIpcInfo(ptr, &ipc_info);
+    if (ret != UMF_RESULT_SUCCESS) {
+        LOG_ERR("Failed to get memory properties handle for ptr=%p", ptr);
+        return ret;
+    }
 
-    LOG_DEBUG("umfGetMemoryPropertiesHandle: props_handle=%p, id=%" PRIu64,
-              *props_handle, (*props_handle)->id);
+    *props_handle = ipc_info.props;
+    //LOG_DEBUG(
+    //    "umfGetMemoryPropertiesHandle (IPC info): props_handle=%p, id=%" PRIu64,
+    //    *props_handle, (*props_handle)->id);
 
     return UMF_RESULT_SUCCESS;
 }
@@ -46,20 +59,24 @@ umf_result_t umfGetMemoryProperty(umf_memory_properties_handle_t props_handle,
                                   umf_memory_property_id_t memory_property_id,
                                   size_t max_property_size, void *value) {
 
+    /*                                       
     LOG_DEBUG("umfGetMemoryProperty: props_handle=%p, memory_property_id=%d, "
               "max_property_size=%zu, value=%p",
               props_handle, memory_property_id, max_property_size, value);
+    */
 
     if ((value == NULL) || (props_handle == NULL) || (max_property_size == 0)) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
     umf_memory_provider_t *provider = props_handle->provider;
 
+    /*
     LOG_DEBUG("umfGetMemoryProperty: provider=%p", provider);
     LOG_DEBUG("dereferencing value...");
 
     LOG_DEBUG("value: %zu", *(size_t *)value);
+    */
 
     switch (memory_property_id) {
     case UMF_MEMORY_PROPERTY_INVALID:

src/pool/pool_disjoint.c

@@ -898,16 +898,17 @@ umf_result_t disjoint_pool_malloc_usable_size(void *pool, const void *ptr,
         umf_memory_properties_handle_t props = NULL;
         umf_result_t umf_result = umfGetMemoryPropertiesHandle(ptr, &props);
         if (umf_result != UMF_RESULT_SUCCESS) {
-            return 0;
+            return umf_result;
         }
 
         if (props == NULL) {
             TLS_last_allocation_error = UMF_RESULT_ERROR_UNKNOWN;
             LOG_ERR("failed to get allocation info from the memory tracker");
-            return 0;
+            return UMF_RESULT_ERROR_UNKNOWN;
         }
 
-        return props->base_size;
+        *size = props->base_size;
+        return UMF_RESULT_SUCCESS;
     }
 
     // Get the unaligned pointer

src/provider/provider_tracking.c

@@ -47,6 +47,7 @@ struct umf_memory_tracker_t {
 };
 
 typedef struct tracker_ipc_info_t {
+    umf_memory_properties_t props;
     size_t size;
     umf_memory_provider_handle_t provider;
     ipc_opened_cache_value_t *ipc_cache_value;
@@ -410,6 +411,14 @@ umfMemoryTrackerAddIpcSegment(umf_memory_tracker_handle_t hTracker,
     value->provider = provider;
     value->ipc_cache_value = cache_entry;
 
+    memset(&value->props, 0, sizeof(umf_memory_properties_t));
+    value->props.id = utils_atomic_increment_u64(&unique_alloc_id);
+    value->props.base = (void *)ptr;
+    value->props.base_size = size;
+    value->props.provider = provider;
+    value->props.ptr = (void *)ptr;
+    value->props.pool = NULL; // TODO
+
     int ret =
         critnib_insert(hTracker->ipc_segments_map, (uintptr_t)ptr, value, 0);
     if (ret == 0) {
@@ -593,6 +602,8 @@ umf_result_t umfMemoryTrackerGetIpcInfo(const void *ptr,
     pIpcInfo->baseSize = rvalue->size;
     pIpcInfo->provider = rvalue->provider;
 
+    pIpcInfo->props = &rvalue->props;
+
     if (ref_value) {
         critnib_release(TRACKER->ipc_segments_map, ref_value);
     }

src/provider/provider_tracking.h

@@ -50,6 +50,8 @@ umf_result_t umfMemoryTrackerGetAllocInfo(const void *ptr,
                                           tracker_alloc_info_t **info);
 
 typedef struct umf_ipc_info_t {
+    umf_memory_properties_handle_t props;
+
     void *base;
     size_t baseSize;
     umf_memory_provider_handle_t provider;