Add logs to the tracking provider

Author: vinser52

src/memory_pool.c

@@ -59,6 +59,7 @@ static umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
     }
 
     *hPool = pool;
+    LOG_INFO("Memory pool created: %p", (void *)pool);
     return UMF_RESULT_SUCCESS;
 
 err_pool_init:
@@ -83,6 +84,9 @@ void umfPoolDestroy(umf_memory_pool_handle_t hPool) {
         // Destroy tracking provider.
         umfMemoryProviderDestroy(hPool->provider);
     }
+
+    LOG_INFO("Memory pool destroyed: %p", (void *)hPool);
+
     // TODO: this free keeps memory in base allocator, so it can lead to OOM in some scenarios (it should be optimized)
     umf_ba_global_free(hPool);
 }

src/provider/provider_tracking.c

@@ -37,6 +37,9 @@ static umf_result_t umfMemoryTrackerAdd(umf_memory_tracker_handle_t hTracker,
 
     tracker_value_t *value = umf_ba_alloc(hTracker->tracker_allocator);
     if (value == NULL) {
+        LOG_ERR("umfMemoryTrackerAdd: failed to allocate tracker value, "
+                "ptr=%p, size=%zu",
+                ptr, size);
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
 
@@ -46,16 +49,22 @@ static umf_result_t umfMemoryTrackerAdd(umf_memory_tracker_handle_t hTracker,
     int ret = critnib_insert(hTracker->map, (uintptr_t)ptr, value, 0);
 
     if (ret == 0) {
+        LOG_DEBUG("umfMemoryTrackerAdd: memory region is added, tracker=%p, "
+                  "ptr=%p, size=%zu",
+                  (void *)hTracker, ptr, size);
         return UMF_RESULT_SUCCESS;
     }
 
+    LOG_ERR("umfMemoryTrackerAdd: failed to insert tracker value, ret=%d, "
+            "ptr=%p, size=%zu",
+            ret, ptr, size);
+
     umf_ba_free(hTracker->tracker_allocator, value);
 
     if (ret == ENOMEM) {
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
 
-    LOG_ERR("umfMemoryTrackerAdd: Unknown Error %d", ret);
     return UMF_RESULT_ERROR_UNKNOWN;
 }
 
@@ -109,6 +118,9 @@ umf_result_t umfMemoryTrackerGetAllocInfo(const void *ptr,
     int found = critnib_find(TRACKER->map, (uintptr_t)ptr, FIND_LE,
                              (void *)&rkey, (void **)&rvalue);
     if (!found || (uintptr_t)ptr >= rkey + rvalue->size) {
+        LOG_WARN("umfMemoryTrackerGetAllocInfo: pointer %p not found in the "
+                 "tacker, TRACKER=%p",
+                 ptr, (void *)TRACKER);
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
@@ -585,13 +597,20 @@ static umf_result_t trackingOpenIpcHandle(void *provider, void *providerIpcData,
 
     ret = umfMemoryProviderOpenIPCHandle(p->hUpstream, providerIpcData, ptr);
     if (ret != UMF_RESULT_SUCCESS) {
+        LOG_ERR(
+            "tracking open ipc handle: umfMemoryProviderOpenIPCHandle failed");
         return ret;
     }
     size_t bufferSize = getDataSizeFromIpcHandle(providerIpcData);
     ret = umfMemoryTrackerAdd(p->hTracker, p->pool, *ptr, bufferSize);
     if (ret != UMF_RESULT_SUCCESS) {
+        LOG_ERR("tracking open ipc handle: umfMemoryTrackerAdd failed, ptr=%p, "
+                "size=%zu",
+                *ptr, bufferSize);
         if (umfMemoryProviderCloseIPCHandle(p->hUpstream, *ptr, bufferSize)) {
-            // TODO: LOG
+            LOG_ERR("tracking open ipc handle: umfMemoryProviderCloseIPCHandle "
+                    "failed, ptr=%p, size=%zu",
+                    *ptr, bufferSize);
         }
     }
     return ret;
@@ -611,7 +630,9 @@ static umf_result_t trackingCloseIpcHandle(void *provider, void *ptr,
         if (ret != UMF_RESULT_SUCCESS) {
             // DO NOT return an error here, because the tracking provider
             // cannot change behaviour of the upstream provider.
-            LOG_ERR("tracking free: umfMemoryTrackerRemove failed");
+            LOG_ERR("tracking free: umfMemoryTrackerRemove failed, ptr=%p, "
+                    "size=%zu",
+                    ptr, size);
         }
     }
     return umfMemoryProviderCloseIPCHandle(p->hUpstream, ptr, size);
@@ -645,14 +666,21 @@ umf_result_t umfTrackingMemoryProviderCreate(
     params.hUpstream = hUpstream;
     params.hTracker = TRACKER;
     if (!params.hTracker) {
+        LOG_ERR("umfTrackingMemoryProviderCreate: failed, TRACKER is NULL");
         return UMF_RESULT_ERROR_UNKNOWN;
     }
     params.pool = hPool;
     params.ipcCache = critnib_new();
     if (!params.ipcCache) {
+        LOG_ERR("umfTrackingMemoryProviderCreate: failed to create IPC cache");
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
 
+    LOG_DEBUG("umfTrackingMemoryProviderCreate: upstream=%p, tracker=%p, "
+              "pool=%p, ipcCache=%p",
+              (void *)params.hUpstream, (void *)params.hTracker,
+              (void *)params.pool, (void *)params.ipcCache);
+
     return umfMemoryProviderCreate(&UMF_TRACKING_MEMORY_PROVIDER_OPS, &params,
                                    hTrackingProvider);
 }
@@ -691,6 +719,10 @@ umf_memory_tracker_handle_t umfMemoryTrackerCreate(void) {
         goto err_destroy_mutex;
     }
 
+    LOG_DEBUG(
+        "umfMemoryTrackerCreate: tracker created, handle=%p, segment map=%p",
+        (void *)handle, (void *)handle->map);
+
     return handle;
 
 err_destroy_mutex: