Update L0 provider to use getpidfd function to open IPC handle from remote process

vinser52 · vinser52 · commit ce005694e293 · 2024-06-22T23:54:51.000+02:00
diff --git a/src/provider/provider_level_zero.c b/src/provider/provider_level_zero.c
@@ -285,11 +285,16 @@ static umf_result_t ze_memory_provider_allocation_split(void *provider,
     return UMF_RESULT_ERROR_NOT_SUPPORTED;
 }
 
+typedef struct ze_ipc_data_t {
+    int pid;
+    ze_ipc_mem_handle_t ze_handle;
+} ze_ipc_data_t;
+
 static umf_result_t ze_memory_provider_get_ipc_handle_size(void *provider,
                                                            size_t *size) {
     (void)provider;
     ASSERT(size != NULL);
-    *size = sizeof(ze_ipc_mem_handle_t);
+    *size = sizeof(ze_ipc_data_t);
     return UMF_RESULT_SUCCESS;
 }
 
@@ -301,17 +306,19 @@ static umf_result_t ze_memory_provider_get_ipc_handle(void *provider,
     ASSERT(providerIpcData != NULL);
     (void)size;
     ze_result_t ze_result;
-    ze_ipc_mem_handle_t *ze_ipc_handle = (ze_ipc_mem_handle_t *)providerIpcData;
+    ze_ipc_data_t *ze_ipc_data = (ze_ipc_data_t *)providerIpcData;
     struct ze_memory_provider_t *ze_provider =
         (struct ze_memory_provider_t *)provider;
 
-    ze_result =
-        g_ze_ops.zeMemGetIpcHandle(ze_provider->context, ptr, ze_ipc_handle);
+    ze_result = g_ze_ops.zeMemGetIpcHandle(ze_provider->context, ptr,
+                                           &ze_ipc_data->ze_handle);
     if (ze_result != ZE_RESULT_SUCCESS) {
         LOG_ERR("zeMemGetIpcHandle() failed.");
         return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
     }
 
+    ze_ipc_data->pid = utils_getpid();
+
     return UMF_RESULT_SUCCESS;
 }
 
@@ -322,7 +329,7 @@ static umf_result_t ze_memory_provider_put_ipc_handle(void *provider,
     ze_result_t ze_result;
     struct ze_memory_provider_t *ze_provider =
         (struct ze_memory_provider_t *)provider;
-    ze_ipc_mem_handle_t *ze_ipc_handle = (ze_ipc_mem_handle_t *)providerIpcData;
+    ze_ipc_data_t *ze_ipc_data = (ze_ipc_data_t *)providerIpcData;
 
     if (g_ze_ops.zeMemPutIpcHandle == NULL) {
         // g_ze_ops.zeMemPutIpcHandle can be NULL because it was introduced
@@ -331,8 +338,8 @@ static umf_result_t ze_memory_provider_put_ipc_handle(void *provider,
         return UMF_RESULT_SUCCESS;
     }
 
-    ze_result =
-        g_ze_ops.zeMemPutIpcHandle(ze_provider->context, *ze_ipc_handle);
+    ze_result = g_ze_ops.zeMemPutIpcHandle(ze_provider->context,
+                                           ze_ipc_data->ze_handle);
     if (ze_result != ZE_RESULT_SUCCESS) {
         LOG_ERR("zeMemPutIpcHandle() failed.");
         return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
@@ -347,12 +354,29 @@ static umf_result_t ze_memory_provider_open_ipc_handle(void *provider,
     ASSERT(providerIpcData != NULL);
     ASSERT(ptr != NULL);
     ze_result_t ze_result;
-    ze_ipc_mem_handle_t *ze_ipc_handle = (ze_ipc_mem_handle_t *)providerIpcData;
+    ze_ipc_data_t *ze_ipc_data = (ze_ipc_data_t *)providerIpcData;
     struct ze_memory_provider_t *ze_provider =
         (struct ze_memory_provider_t *)provider;
+    int fd_local = -1;
+
+    if (ze_ipc_data->pid != utils_getpid()) {
+        int fd_remote = -1;
+        memcpy(&fd_remote, &ze_ipc_data->ze_handle, sizeof(fd_remote));
+        umf_result_t umf_result =
+            utils_duplicate_fd(ze_ipc_data->pid, fd_remote, &fd_local);
+        if (umf_result != UMF_RESULT_SUCCESS) {
+            LOG_PERR("duplicating file descriptor failed");
+            return umf_result;
+        }
+        memcpy(&ze_ipc_data->ze_handle, &fd_local, sizeof(fd_local));
+    }
 
-    ze_result = g_ze_ops.zeMemOpenIpcHandle(
-        ze_provider->context, ze_provider->device, *ze_ipc_handle, 0, ptr);
+    ze_result =
+        g_ze_ops.zeMemOpenIpcHandle(ze_provider->context, ze_provider->device,
+                                    ze_ipc_data->ze_handle, 0, ptr);
+    if (fd_local != -1) {
+        utils_close_fd(fd_local);
+    }
     if (ze_result != ZE_RESULT_SUCCESS) {
         LOG_ERR("zeMemOpenIpcHandle() failed.");
         return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
diff --git a/src/provider/provider_os_memory.c b/src/provider/provider_os_memory.c
@@ -326,7 +326,7 @@ create_fd_for_mmap(umf_os_memory_provider_params_t *in_params,
 
 err_close_file:
     if (provider->fd > 0) {
-        (void)os_close_fd(provider->fd);
+        (void)utils_close_fd(provider->fd);
     }
 
     return result;
@@ -1248,7 +1248,7 @@ static umf_result_t os_open_ipc_handle(void *provider, void *providerIpcData,
         (void)os_shm_unlink(os_provider->shm_name);
     } else {
         umf_result_t umf_result =
-            os_duplicate_fd(os_ipc_data->pid, os_ipc_data->fd, &fd);
+            utils_duplicate_fd(os_ipc_data->pid, os_ipc_data->fd, &fd);
         if (umf_result != UMF_RESULT_SUCCESS) {
             LOG_PERR("duplicating file descriptor failed");
             return umf_result;
@@ -1263,7 +1263,7 @@ static umf_result_t os_open_ipc_handle(void *provider, void *providerIpcData,
         ret = UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
     }
 
-    (void)os_close_fd(fd);
+    (void)utils_close_fd(fd);
 
     return ret;
 }
diff --git a/src/provider/provider_os_memory_internal.h b/src/provider/provider_os_memory_internal.h
@@ -97,10 +97,6 @@ size_t os_get_page_size(void);
 
 void os_strerror(int errnum, char *buf, size_t buflen);
 
-umf_result_t os_duplicate_fd(int pid, int fd_in, int *fd_out);
-
-umf_result_t os_close_fd(int fd);
-
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/provider/provider_os_memory_posix.c b/src/provider/provider_os_memory_posix.c
@@ -89,47 +89,3 @@ 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);
 }
-
-umf_result_t os_duplicate_fd(int pid, int fd_in, int *fd_out) {
-// pidfd_getfd(2) is used to obtain a duplicate of another process's file descriptor.
-// Permission to duplicate another process's file descriptor
-// is governed by a ptrace access mode PTRACE_MODE_ATTACH_REALCREDS check (see ptrace(2))
-// that can be changed using the /proc/sys/kernel/yama/ptrace_scope interface.
-// pidfd_getfd(2) is supported since Linux 5.6
-// pidfd_open(2) is supported since Linux 5.3
-#if defined(__NR_pidfd_open) && defined(__NR_pidfd_getfd)
-    errno = 0;
-    int pid_fd = syscall(SYS_pidfd_open, pid, 0);
-    if (pid_fd == -1) {
-        LOG_PDEBUG("SYS_pidfd_open");
-        return UMF_RESULT_ERROR_UNKNOWN;
-    }
-
-    int fd_dup = syscall(SYS_pidfd_getfd, pid_fd, fd_in, 0);
-    close(pid_fd);
-    if (fd_dup == -1) {
-        LOG_PDEBUG("SYS_pidfd_getfd");
-        return UMF_RESULT_ERROR_UNKNOWN;
-    }
-
-    *fd_out = fd_dup;
-
-    return UMF_RESULT_SUCCESS;
-#else
-    // TODO: find another way to obtain a duplicate of another process's file descriptor
-    (void)pid;    // unused
-    (void)fd_in;  // unused
-    (void)fd_out; // unused
-    errno = ENOTSUP;
-    return UMF_RESULT_ERROR_NOT_SUPPORTED; // unsupported
-#endif /* defined(__NR_pidfd_open) && defined(__NR_pidfd_getfd) */
-}
-
-umf_result_t os_close_fd(int fd) {
-    if (close(fd)) {
-        LOG_PERR("close() failed");
-        return UMF_RESULT_ERROR_UNKNOWN;
-    }
-
-    return UMF_RESULT_SUCCESS;
-}
diff --git a/src/provider/provider_os_memory_windows.c b/src/provider/provider_os_memory_windows.c
@@ -139,15 +139,3 @@ size_t os_get_page_size(void) {
 void os_strerror(int errnum, char *buf, size_t buflen) {
     strerror_s(buf, buflen, errnum);
 }
-
-umf_result_t os_duplicate_fd(int pid, int fd_in, int *fd_out) {
-    (void)pid;                             // unused
-    (void)fd_in;                           // unused
-    (void)fd_out;                          // unused
-    return UMF_RESULT_ERROR_NOT_SUPPORTED; // unsupported
-}
-
-umf_result_t os_close_fd(int fd) {
-    (void)fd;                              // unused
-    return UMF_RESULT_ERROR_NOT_SUPPORTED; // unsupported
-}
diff --git a/src/utils/utils_common.h b/src/utils/utils_common.h
@@ -14,6 +14,8 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include <umf/base.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -77,6 +79,12 @@ int utils_getpid(void);
 // get the current thread ID
 int utils_gettid(void);
 
+// close file descriptor
+int utils_close_fd(int fd);
+
+// obtain a duplicate of another process's file descriptor
+umf_result_t utils_duplicate_fd(int pid, int fd_in, int *fd_out);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/utils/utils_posix_common.c b/src/utils/utils_posix_common.c
@@ -7,12 +7,22 @@
  *
  */
 
+#include <errno.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/syscall.h>
 #include <unistd.h>
 
+#include "utils_common.h"
 #include "utils_concurrency.h"
+#include "utils_log.h"
+
+#ifndef __NR_pidfd_open
+#define __NR_pidfd_open 434 /* Syscall id */
+#endif
+#ifndef __NR_pidfd_getfd
+#define __NR_pidfd_getfd 438 /* Syscall id */
+#endif
 
 static UTIL_ONCE_FLAG Page_size_is_initialized = UTIL_ONCE_FLAG_INIT;
 static size_t Page_size;
@@ -38,3 +48,64 @@ int utils_gettid(void) {
     return syscall(SYS_gettid);
 #endif
 }
+
+int utils_close_fd(int fd) { return close(fd); }
+
+umf_result_t utils_duplicate_fd(int pid, int fd_in, int *fd_out) {
+#ifdef __APPLE__
+    (void)pid;    // unused
+    (void)fd_in;  // unused
+    (void)fd_out; // unused
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+#else
+    // pidfd_getfd(2) is used to obtain a duplicate of another process's file descriptor.
+    // Permission to duplicate another process's file descriptor
+    // is governed by a ptrace access mode PTRACE_MODE_ATTACH_REALCREDS check (see ptrace(2))
+    // that can be changed using the /proc/sys/kernel/yama/ptrace_scope interface.
+    // pidfd_getfd(2) is supported since Linux 5.6
+    // pidfd_open(2) is supported since Linux 5.3
+    errno = 0;
+    int pid_fd = syscall(__NR_pidfd_open, pid, 0);
+    if (pid_fd == -1) {
+        LOG_PERR("__NR_pidfd_open");
+        switch (errno) {
+        case EINVAL:
+        case ESRCH:
+            return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        case EMFILE:
+        case ENOMEM:
+            return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+        case ENODEV:
+        case ENOSYS:
+        case ENOTSUP:
+            return UMF_RESULT_ERROR_NOT_SUPPORTED;
+        default:
+            return UMF_RESULT_ERROR_UNKNOWN;
+        }
+    }
+
+    int fd_dup = syscall(__NR_pidfd_getfd, pid_fd, fd_in, 0);
+    close(pid_fd);
+    if (fd_dup == -1) {
+        LOG_PERR("__NR_pidfd_open");
+        switch (errno) {
+        case EBADF:
+        case EINVAL:
+        case ESRCH:
+        case EPERM:
+            return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        case EMFILE:
+            return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+        case ENOSYS:
+        case ENOTSUP:
+            return UMF_RESULT_ERROR_NOT_SUPPORTED;
+        default:
+            return UMF_RESULT_ERROR_UNKNOWN;
+        }
+    }
+
+    *fd_out = fd_dup;
+
+    return UMF_RESULT_SUCCESS;
+#endif
+}
diff --git a/src/utils/utils_windows_common.c b/src/utils/utils_windows_common.c
@@ -12,6 +12,7 @@
 #include <processenv.h>
 #include <processthreadsapi.h>
 
+#include "utils_common.h"
 #include "utils_concurrency.h"
 
 #define BUFFER_SIZE 1024
@@ -33,3 +34,13 @@ size_t util_get_page_size(void) {
 int utils_getpid(void) { return GetCurrentProcessId(); }
 
 int utils_gettid(void) { return GetCurrentThreadId(); }
+
+int utils_close_fd(int fd) { return -1; }
+
+umf_result_t utils_duplicate_fd(int pid, int fd_in, int *fd_out) {
+    // TODO: find another way to obtain a duplicate of another process's file descriptor
+    (void)pid;    // unused
+    (void)fd_in;  // unused
+    (void)fd_out; // unused
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}

Original file line number	Diff line number	Diff line change
`@@ -97,10 +97,6 @@ size_t os_get_page_size(void);`
`97`	`97`
`98`	`98`	`void os_strerror(int errnum, char *buf, size_t buflen);`
`99`	`99`
`100`		`-umf_result_t os_duplicate_fd(int pid, int fd_in, int *fd_out);`
`101`		`-`
`102`		`-umf_result_t os_close_fd(int fd);`
`103`		`-`
`104`	`100`	`#ifdef __cplusplus`
`105`	`101`	`}`
`106`	`102`	`#endif`