Implement IPC hooks in OS memory provider

Signed-off-by: Lukasz Dorau <lukasz.dorau@intel.com>

Author: ldorau

src/provider/provider_os_memory.c

@@ -666,6 +666,104 @@ static umf_result_t os_allocation_merge(void *provider, void *lowPtr,
     return UMF_RESULT_SUCCESS;
 }
 
+typedef struct os_ipc_data_t {
+    int pid;
+    int fd;
+    size_t fd_offset;
+    size_t size;
+} os_ipc_data_t;
+
+static umf_result_t os_get_ipc_handle_size(void *provider, size_t *size) {
+    if (provider == NULL || size == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    *size = sizeof(os_ipc_data_t);
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t os_get_ipc_handle(void *provider, const void *ptr,
+                                      size_t size, void *providerIpcData) {
+    if (provider == NULL || providerIpcData == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    os_memory_provider_t *os_provider = (os_memory_provider_t *)provider;
+
+    void *value = critnib_get(os_provider->ptr_off, (uintptr_t)ptr);
+    if (value == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    os_ipc_data_t *os_ipc_data = (os_ipc_data_t *)providerIpcData;
+    os_ipc_data->pid = os_getpid();
+    os_ipc_data->fd = os_provider->fd;
+    os_ipc_data->fd_offset = (size_t)value;
+    os_ipc_data->size = size;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t os_put_ipc_handle(void *provider, void *providerIpcData) {
+    if (provider == NULL || providerIpcData == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    os_memory_provider_t *os_provider = (os_memory_provider_t *)provider;
+    os_ipc_data_t *os_ipc_data = (os_ipc_data_t *)providerIpcData;
+
+    if (os_ipc_data->fd != os_provider->fd || os_ipc_data->pid != os_getpid()) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t os_open_ipc_handle(void *provider, void *providerIpcData,
+                                       void **ptr) {
+    if (provider == NULL || providerIpcData == NULL || ptr == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    os_memory_provider_t *os_provider = (os_memory_provider_t *)provider;
+    os_ipc_data_t *os_ipc_data = (os_ipc_data_t *)providerIpcData;
+
+    int fd = os_duplicate_fd(os_ipc_data->pid, os_ipc_data->fd);
+    if (fd == -1) {
+        LOG_PERR("duplicating file descriptor failed");
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    *ptr = os_mmap(NULL, os_ipc_data->size, os_provider->protection,
+                   os_provider->flag, fd, os_ipc_data->fd_offset);
+    if (*ptr == NULL) {
+        os_store_last_native_error(UMF_OS_RESULT_ERROR_ALLOC_FAILED, errno);
+        LOG_PERR("memory mapping failed");
+        return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t os_close_ipc_handle(void *provider, void *ptr,
+                                        size_t size) {
+    if (provider == NULL || ptr == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    errno = 0;
+    int ret = os_munmap(ptr, size);
+    // ignore error when size == 0
+    if (ret && (size > 0)) {
+        os_store_last_native_error(UMF_OS_RESULT_ERROR_FREE_FAILED, errno);
+        LOG_PERR("memory unmapping failed");
+
+        return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
 static umf_memory_provider_ops_t UMF_OS_MEMORY_PROVIDER_OPS = {
     .version = UMF_VERSION_CURRENT,
     .initialize = os_initialize,
@@ -680,11 +778,11 @@ static umf_memory_provider_ops_t UMF_OS_MEMORY_PROVIDER_OPS = {
     .ext.purge_force = os_purge_force,
     .ext.allocation_merge = os_allocation_merge,
     .ext.allocation_split = os_allocation_split,
-    .ipc.get_ipc_handle_size = NULL,
-    .ipc.get_ipc_handle = NULL,
-    .ipc.put_ipc_handle = NULL,
-    .ipc.open_ipc_handle = NULL,
-    .ipc.close_ipc_handle = NULL};
+    .ipc.get_ipc_handle_size = os_get_ipc_handle_size,
+    .ipc.get_ipc_handle = os_get_ipc_handle,
+    .ipc.put_ipc_handle = os_put_ipc_handle,
+    .ipc.open_ipc_handle = os_open_ipc_handle,
+    .ipc.close_ipc_handle = os_close_ipc_handle};
 
 umf_memory_provider_ops_t *umfOsMemoryProviderOps(void) {
     return &UMF_OS_MEMORY_PROVIDER_OPS;

src/provider/provider_os_memory_internal.h

@@ -45,6 +45,10 @@ size_t os_get_page_size(void);
 
 void os_strerror(int errnum, char *buf, size_t buflen);
 
+int os_getpid(void);
+
+int os_duplicate_fd(int pid, int fd);
+
 #ifdef __cplusplus
 }
 #endif

src/provider/provider_os_memory_linux.c

@@ -146,3 +146,25 @@ int os_purge(void *addr, size_t length, int advice) {
 void os_strerror(int errnum, char *buf, size_t buflen) {
     strerror_r(errnum, buf, buflen);
 }
+
+int os_getpid(void) { return getpid(); }
+
+int os_duplicate_fd(int pid, int fd) {
+// SYS_pidfd_open is supported since Linux 5.3
+// SYS_pidfd_getfd is supported since Linux 5.6
+#if defined(__NR_pidfd_open) && defined(__NR_pidfd_getfd)
+    int pid_fd = syscall(SYS_pidfd_open, pid, 0);
+    if (pid_fd == -1) {
+        return -1;
+    }
+
+    int fd_dup = syscall(SYS_pidfd_getfd, pid_fd, fd, 0);
+    close(pid_fd);
+    return fd_dup;
+#else
+    (void)pid; // unused
+    (void)fd;  // unused
+    return -1; // unsupported
+               // TODO: find another way
+#endif /* defined(__NR_pidfd_open) && defined(__NR_pidfd_getfd) */
+}

src/provider/provider_os_memory_windows.c

@@ -112,3 +112,11 @@ size_t os_get_page_size(void) {
 void os_strerror(int errnum, char *buf, size_t buflen) {
     strerror_s(buf, buflen, errnum);
 }
+
+int os_getpid(void) { return GetCurrentProcessId(); }
+
+int os_duplicate_fd(int pid, int fd) {
+    (void)pid; // unused
+    (void)fd;  // unused
+    return -1; // unsupported
+}