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,8 @@ 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

@@ -1089,7 +1089,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 +1122,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 +1152,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->fd < 0) {
+        // 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 +1176,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->fd < 0) {
+        // 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 +1210,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->fd < 0) {
+        // 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 +1242,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->fd < 0) {
+        // 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 +1288,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->fd < 0) {
+        // 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

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() {