Return proper clDevice for given media adapter

Signed-off-by: Kamil Diedrich <[email protected]>

Author: kamdiedrich

opencl/source/sharings/va/CMakeLists.txt

@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2017-2020 Intel Corporation
+# Copyright (C) 2017-2021 Intel Corporation
 #
 # SPDX-License-Identifier: MIT
 #
@@ -8,6 +8,7 @@ set(RUNTIME_SRCS_SHARINGS_VA
     ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
     ${CMAKE_CURRENT_SOURCE_DIR}/${BRANCH_DIR_SUFFIX}/va_device.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/va_device.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/va_device_shared.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/${BRANCH_DIR_SUFFIX}/va_extension.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/cl_va_api.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/cl_va_api.h

opencl/source/sharings/va/cl_va_api.cpp

@@ -75,7 +75,12 @@ clGetDeviceIDsFromVA_APIMediaAdapterINTEL(cl_platform_id platform, cl_va_api_dev
         VADevice vaDevice{};
         cl_device_id device = vaDevice.getDeviceFromVA(pPlatform, mediaAdapter);
         GetInfoHelper::set(devices, device);
-        GetInfoHelper::set(numDevices, 1u);
+        if (device == nullptr) {
+            GetInfoHelper::set(numDevices, 0u);
+            status = CL_DEVICE_NOT_FOUND;
+        } else {
+            GetInfoHelper::set(numDevices, 1u);
+        }
     }
     return status;
 }

opencl/source/sharings/va/va_device.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020 Intel Corporation
+ * Copyright (C) 2020-2021 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -16,7 +16,7 @@ VADevice::VADevice() {
 }
 
 ClDevice *VADevice::getDeviceFromVA(Platform *pPlatform, VADisplay vaDisplay) {
-    return pPlatform->getClDevice(0);
+    return getRootDeviceFromVaDisplay(pPlatform, vaDisplay);
 }
 
 VADevice::~VADevice() {

opencl/source/sharings/va/va_device.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020 Intel Corporation
+ * Copyright (C) 2020-2021 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -20,6 +20,7 @@ class VADevice {
     VADevice();
     virtual ~VADevice();
 
+    ClDevice *getRootDeviceFromVaDisplay(Platform *pPlatform, VADisplay vaDisplay);
     ClDevice *getDeviceFromVA(Platform *pPlatform, VADisplay vaDisplay);
 
     static std::function<void *(const char *, int)> fdlopen;

opencl/source/sharings/va/va_device_shared.cpp

@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2021 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/device/device.h"
+#include "shared/source/os_interface/linux/drm_neo.h"
+#include "shared/source/os_interface/linux/os_interface.h"
+#include "shared/source/os_interface/linux/sys_calls.h"
+
+#include "opencl/source/cl_device/cl_device.h"
+#include "opencl/source/platform/platform.h"
+#include "opencl/source/sharings/va/va_device.h"
+
+#include <sys/stat.h>
+#include <system_error>
+#include <unistd.h>
+#include <va/va_backend.h>
+
+namespace NEO {
+ClDevice *VADevice::getRootDeviceFromVaDisplay(Platform *pPlatform, VADisplay vaDisplay) {
+    VADisplayContextP pDisplayContext_test = reinterpret_cast<VADisplayContextP>(vaDisplay);
+    UNRECOVERABLE_IF(pDisplayContext_test->vadpy_magic != 0x56414430);
+    VADriverContextP pDriverContext_test = pDisplayContext_test->pDriverContext;
+    int deviceFd = *(int *)pDriverContext_test->drm_state;
+
+    UNRECOVERABLE_IF(deviceFd < 0);
+
+    char path[256] = {0};
+    size_t pathlen = 256;
+
+    if (SysCalls::getDevicePath(deviceFd, path, pathlen)) {
+        return nullptr;
+    }
+
+    if (SysCalls::access(path, F_OK)) {
+        return nullptr;
+    }
+
+    int readLinkSize = 0;
+    char devicePath[256] = {0};
+    readLinkSize = SysCalls::readlink(path, devicePath, pathlen);
+
+    if (readLinkSize == -1) {
+        return nullptr;
+    }
+
+    std::string_view prefixView = "../../devices/pci0000:00/0000:";
+    std::string_view devicePathView(devicePath, static_cast<size_t>(readLinkSize));
+    devicePathView.remove_prefix(prefixView.size());
+    devicePathView = devicePathView.substr(0, 7);
+
+    for (size_t i = 0; i < pPlatform->getNumDevices(); ++i) {
+        auto device = pPlatform->getClDevice(i);
+        NEO::Device *neoDevice = &device->getDevice();
+
+        auto *drm = neoDevice->getRootDeviceEnvironment().osInterface->get()->getDrm();
+        auto pciPath = drm->getPciPath();
+        if (devicePathView == pciPath) {
+            return device;
+        }
+    }
+    return nullptr;
+}
+} // namespace NEO

opencl/test/unit_test/os_interface/linux/sys_calls_linux_ult.cpp

@@ -1,25 +1,32 @@
 /*
- * Copyright (C) 2020 Intel Corporation
+ * Copyright (C) 2020-2021 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
  */
 
+#include "shared/source/helpers/string.h"
 #include "shared/source/os_interface/linux/sys_calls.h"
 
 #include "drm/i915_drm.h"
 
 #include <cstdint>
 #include <cstdio>
 #include <cstring>
+#include <iostream>
+#include <stdio.h>
+#include <string.h>
 #include <sys/ioctl.h>
+#include <system_error>
 
 namespace NEO {
 namespace SysCalls {
 uint32_t closeFuncCalled = 0u;
 int closeFuncArgPassed = 0;
 constexpr int fakeFileDescriptor = 123;
 uint32_t vmId = 0;
+bool makeFakeDevicePath = false;
+bool allowFakeDevicePath = false;
 
 int close(int fileDescriptor) {
     closeFuncCalled++;
@@ -55,5 +62,35 @@ int ioctl(int fileDescriptor, unsigned long int request, void *arg) {
     }
     return 0;
 }
+
+int access(const char *pathName, int mode) {
+    if (allowFakeDevicePath || strcmp(pathName, "/sys/dev/char/226:128") == 0) {
+        return 0;
+    }
+    return -1;
+}
+
+int readlink(const char *path, char *buf, size_t bufsize) {
+    if (strcmp(path, "/sys/dev/char/226:128") != 0) {
+        return -1;
+    }
+
+    constexpr size_t sizeofPath = sizeof("../../devices/pci0000:00/0000:00:02.0/drm/renderD128");
+
+    strcpy_s(buf, sizeofPath, "../../devices/pci0000:00/0000:00:02.0/drm/renderD128");
+    return sizeofPath;
+}
+
+int getDevicePath(int deviceFd, char *buf, size_t &bufSize) {
+    if (deviceFd <= 0) {
+        return -1;
+    }
+    constexpr size_t sizeofPath = sizeof("/sys/dev/char/226:128");
+
+    makeFakeDevicePath ? strcpy_s(buf, sizeofPath, "/sys/dev/char/xyzwerq") : strcpy_s(buf, sizeofPath, "/sys/dev/char/226:128");
+    bufSize = sizeofPath;
+
+    return 0;
+}
 } // namespace SysCalls
 } // namespace NEO

opencl/test/unit_test/sharings/va/va_device_tests.cpp

@@ -1,25 +1,6 @@
 /*
- * Copyright (C) 2020 Intel Corporation
+ * Copyright (C) 2020-2021 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
  */
-
-#include "opencl/source/cl_device/cl_device.h"
-#include "opencl/source/platform/platform.h"
-#include "opencl/source/sharings/va/va_device.h"
-#include "opencl/test/unit_test/fixtures/platform_fixture.h"
-#include "test.h"
-
-using namespace NEO;
-
-using VaDeviceTests = Test<PlatformFixture>;
-
-TEST_F(VaDeviceTests, givenVADeviceWhenGetDeviceFromVAIsCalledThenRootDeviceIsReturned) {
-    VADisplay vaDisplay = nullptr;
-
-    VADevice vaDevice{};
-    ClDevice *device = vaDevice.getDeviceFromVA(pPlatform, vaDisplay);
-
-    EXPECT_EQ(pPlatform->getClDevice(0), device);
-}