IPC API of OS memory provider requires UMF_MEM_MAP_SHARED visibility

IPC API of OS memory provider requires the `UMF_MEM_MAP_SHARED`
memory `visibility` mode (`UMF_RESULT_ERROR_INVALID_ARGUMENT`
is returned otherwise).

Signed-off-by: Lukasz Dorau <[email protected]>

Author: ldorau

README.md

@@ -143,6 +143,9 @@ OS memory provider supports two types of memory mappings (set by the `visibility
 1) private memory mapping (`UMF_MEM_MAP_PRIVATE`)
 2) shared memory mapping (`UMF_MEM_MAP_SHARED` - supported on Linux only yet)
 
+IPC API requires the `UMF_MEM_MAP_SHARED` memory `visibility` mode
+(`UMF_RESULT_ERROR_INVALID_ARGUMENT` is returned otherwise).
+
 There are available two mechanisms for the shared memory mapping:
 1) a named shared memory object (used if the `shm_name` parameter is not NULL) or
 2) an anonymous file descriptor (used if the `shm_name` parameter is NULL)

src/provider/provider_os_memory.c

@@ -402,6 +402,9 @@ static umf_result_t translate_params(umf_os_memory_provider_params_t *in_params,
         return result;
     }
 
+    // IPC API requires in_params->visibility == UMF_MEM_MAP_SHARED
+    provider->IPC_enabled = (in_params->visibility == UMF_MEM_MAP_SHARED);
+
     // NUMA config
     int emptyNodeset = in_params->numa_list_len == 0;
     result = validate_numa_mode(in_params->numa_mode, emptyNodeset);
@@ -1089,7 +1092,7 @@ static umf_result_t os_allocation_split(void *provider, void *ptr,
     (void)totalSize;
 
     os_memory_provider_t *os_provider = (os_memory_provider_t *)provider;
-    if (os_provider->fd <= 0) {
+    if (os_provider->fd < 0) {
         return UMF_RESULT_SUCCESS;
     }
 
@@ -1122,7 +1125,7 @@ static umf_result_t os_allocation_merge(void *provider, void *lowPtr,
     (void)totalSize;
 
     os_memory_provider_t *os_provider = (os_memory_provider_t *)provider;
-    if (os_provider->fd <= 0) {
+    if (os_provider->fd < 0) {
         return UMF_RESULT_SUCCESS;
     }
 
@@ -1152,6 +1155,11 @@ static umf_result_t os_get_ipc_handle_size(void *provider, size_t *size) {
     }
 
     os_memory_provider_t *os_provider = (os_memory_provider_t *)provider;
+    if (!os_provider->IPC_enabled) {
+        // IPC API requires params->visibility == UMF_MEM_MAP_SHARED
+        LOG_ERR("memory visibility mode is not UMF_MEM_MAP_SHARED")
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
 
     if (os_provider->shm_name[0]) {
         // os_ipc_data_t->shm_name will be used
@@ -1171,7 +1179,9 @@ static umf_result_t os_get_ipc_handle(void *provider, const void *ptr,
     }
 
     os_memory_provider_t *os_provider = (os_memory_provider_t *)provider;
-    if (os_provider->fd <= 0) {
+    if (!os_provider->IPC_enabled) {
+        // IPC API requires params->visibility == UMF_MEM_MAP_SHARED
+        LOG_ERR("memory visibility mode is not UMF_MEM_MAP_SHARED")
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
@@ -1203,6 +1213,12 @@ static umf_result_t os_put_ipc_handle(void *provider, void *providerIpcData) {
     }
 
     os_memory_provider_t *os_provider = (os_memory_provider_t *)provider;
+    if (!os_provider->IPC_enabled) {
+        // IPC API requires params->visibility == UMF_MEM_MAP_SHARED
+        LOG_ERR("memory visibility mode is not UMF_MEM_MAP_SHARED")
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
     os_ipc_data_t *os_ipc_data = (os_ipc_data_t *)providerIpcData;
 
     if (os_ipc_data->pid != utils_getpid()) {
@@ -1229,6 +1245,12 @@ static umf_result_t os_open_ipc_handle(void *provider, void *providerIpcData,
     }
 
     os_memory_provider_t *os_provider = (os_memory_provider_t *)provider;
+    if (!os_provider->IPC_enabled) {
+        // IPC API requires params->visibility == UMF_MEM_MAP_SHARED
+        LOG_ERR("memory visibility mode is not UMF_MEM_MAP_SHARED")
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
     os_ipc_data_t *os_ipc_data = (os_ipc_data_t *)providerIpcData;
     umf_result_t ret = UMF_RESULT_SUCCESS;
     int fd;
@@ -1269,6 +1291,13 @@ static umf_result_t os_close_ipc_handle(void *provider, void *ptr,
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
+    os_memory_provider_t *os_provider = (os_memory_provider_t *)provider;
+    if (!os_provider->IPC_enabled) {
+        // IPC API requires params->visibility == UMF_MEM_MAP_SHARED
+        LOG_ERR("memory visibility mode is not UMF_MEM_MAP_SHARED")
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
     errno = 0;
     int ret = utils_munmap(ptr, size);
     // ignore error when size == 0

src/provider/provider_os_memory_internal.h

@@ -9,6 +9,7 @@
 #define UMF_OS_MEMORY_PROVIDER_INTERNAL_H
 
 #include <limits.h>
+#include <stdbool.h>
 
 #if defined(_WIN32) && !defined(NAME_MAX)
 #include <stdlib.h>
@@ -29,8 +30,13 @@ extern "C" {
 typedef struct os_memory_provider_t {
     unsigned protection; // combination of OS-specific protection flags
     unsigned visibility; // memory visibility mode
+
+    /// IPC is enabled only if (in_params->visibility == UMF_MEM_MAP_SHARED)
+    bool IPC_enabled;
+
     // a name of a shared memory file (valid only in case of the shared memory visibility)
     char shm_name[NAME_MAX];
+
     int fd;                // file descriptor for memory mapping
     size_t size_fd;        // size of file used for memory mapping
     size_t max_size_fd;    // maximum size of file used for memory mapping

test/provider_os_memory.cpp

@@ -328,6 +328,41 @@ TEST_P(umfProviderTest, purge_force_INVALID_POINTER) {
                              UMF_OS_RESULT_ERROR_PURGE_FORCE_FAILED);
 }
 
+TEST_P(umfProviderTest, get_ipc_handle_size_wrong_visibility) {
+    size_t size;
+    umf_result_t umf_result =
+        umfMemoryProviderGetIPCHandleSize(provider.get(), &size);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_P(umfProviderTest, get_ipc_handle_wrong_visibility) {
+    char providerIpcData;
+    umf_result_t umf_result = umfMemoryProviderGetIPCHandle(
+        provider.get(), INVALID_PTR, 1, &providerIpcData);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_P(umfProviderTest, put_ipc_handle_wrong_visibility) {
+    char providerIpcData;
+    umf_result_t umf_result =
+        umfMemoryProviderPutIPCHandle(provider.get(), &providerIpcData);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_P(umfProviderTest, open_ipc_handle_wrong_visibility) {
+    char providerIpcData;
+    void *ptr;
+    umf_result_t umf_result =
+        umfMemoryProviderOpenIPCHandle(provider.get(), &providerIpcData, &ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_P(umfProviderTest, close_ipc_handle_wrong_visibility) {
+    umf_result_t umf_result =
+        umfMemoryProviderCloseIPCHandle(provider.get(), INVALID_PTR, 1);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(umfIpcTest);
 
 umf_os_memory_provider_params_t osMemoryProviderParamsShared() {