Implement size limit for the cache of opened IPC handles

Author: vinser52

src/ipc_cache.c

@@ -54,6 +54,22 @@ typedef struct ipc_mapped_handle_cache_t {
 
 ipc_mapped_handle_cache_global_t *IPC_MAPPED_CACHE_GLOBAL = NULL;
 
+// Returns value of the UMF_MAX_OPENED_IPC_HANDLES environment variable
+// or 0 if it is not set.
+static size_t umfIpcCacheGlobalInitMaxOpenedHandles(void) {
+    const char *max_size_str = getenv("UMF_MAX_OPENED_IPC_HANDLES");
+    if (max_size_str) {
+        char *endptr;
+        size_t max_size = strtoul(max_size_str, &endptr, 10);
+        if (*endptr == '\0') {
+            return max_size;
+        }
+        LOG_ERR("Invalid value of UMF_MAX_OPENED_IPC_HANDLES: %s",
+                max_size_str);
+    }
+    return 0;
+}
+
 umf_result_t umfIpcCacheGlobalInit(void) {
     umf_result_t ret = UMF_RESULT_SUCCESS;
     ipc_mapped_handle_cache_global_t *cache_global =
@@ -78,8 +94,7 @@ umf_result_t umfIpcCacheGlobalInit(void) {
         goto err_mutex_destroy;
     }
 
-    // TODO: make max_size configurable via environment variable
-    cache_global->max_size = 0;
+    cache_global->max_size = umfIpcCacheGlobalInitMaxOpenedHandles();
     cache_global->cur_size = 0;
     cache_global->lru_list = NULL;
 
@@ -189,7 +204,16 @@ umfIpcHandleMappedCacheGet(ipc_mapped_handle_cache_handle_t cache,
         if (entry == NULL && cache->global->max_size != 0 &&
             cache->global->cur_size >= cache->global->max_size) {
             // If max_size is set and the cache is full, evict the least recently used entry.
-            entry = cache->global->lru_list->prev;
+            // we need to search for the least recently used entry with ref_count == 0
+            // The utlist implementation of the doubly-linked list keeps a tail pointer in head->prev
+            ipc_handle_cache_entry_t *candidate = cache->global->lru_list->prev;
+            do {
+                if (candidate->ref_count == 0) {
+                    entry = candidate;
+                    break;
+                }
+                candidate = candidate->prev;
+            } while (candidate != cache->global->lru_list->prev);
         }
 
         if (entry) { // we have eviction candidate
@@ -242,3 +266,20 @@ umfIpcHandleMappedCacheGet(ipc_mapped_handle_cache_handle_t cache,
 
     return ret;
 }
+
+umf_result_t
+umfIpcHandleMappedCacheRelease(ipc_mapped_handle_cache_value_t *cacheValue) {
+    if (!cacheValue) {
+        LOG_ERR("cacheValue is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    // get pointer to the entry
+    ipc_handle_cache_entry_t *entry =
+        (ipc_handle_cache_entry_t *)((char *)cacheValue -
+                                     offsetof(ipc_handle_cache_entry_t, value));
+    // decrement the ref count
+    utils_atomic_decrement(&entry->ref_count);
+
+    return UMF_RESULT_SUCCESS;
+}

src/provider/provider_tracking.c

@@ -709,7 +709,7 @@ static umf_result_t trackingOpenIpcHandle(void *provider, void *providerIpcData,
 
     void *mapped_ptr = NULL;
     utils_atomic_load_acquire(&(cache_entry->mapped_base_ptr), &mapped_ptr);
-    if (mapped_ptr == NULL) {
+    if (mapped_ptr == NULL) { // new cache entry
         utils_mutex_lock(&(cache_entry->mmap_lock));
         utils_atomic_load_acquire(&(cache_entry->mapped_base_ptr), &mapped_ptr);
         if (mapped_ptr == NULL) {
@@ -734,6 +734,10 @@ static umf_result_t trackingOpenIpcHandle(void *provider, void *providerIpcData,
 
 static umf_result_t trackingCloseIpcHandle(void *provider, void *ptr,
                                            size_t size) {
+#if 0
+    umf_tracking_memory_provider_t *p =
+        (umf_tracking_memory_provider_t *)provider;
+#else
     (void)provider;
     (void)ptr;
     (void)size;
@@ -746,6 +750,7 @@ static umf_result_t trackingCloseIpcHandle(void *provider, void *ptr,
     // we need to introduce a reference counting mechanism.
     // The trackingOpenIpcHandle will increment the refcount for the corresponding entry.
     // The trackingCloseIpcHandle will decrement the refcount for the corresponding cache entry.
+#endif
     return UMF_RESULT_SUCCESS;
 }