Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-15 13:01:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Create enum for Ioctl request values

Browse Source 
Related-To: NEO-6852
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2022-05-25 17:05:52 +00:00
committed by Compute-Runtime-Automation
parent 0bf3af37d3
commit b3814e41b4
44 changed files with 606 additions and 464 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
level_zero/tools/source/debug/linux/prelim/debug_session.cpp
View File

@ -49,7 +49,7 @@ DebugSession *DebugSession::create(const zet_debug_config_t &config, Device *dev
open.pid = config.pid;
open.events = 0;
auto debugFd = DrmHelper::ioctl(device, PRELIM_DRM_IOCTL_I915_DEBUGGER_OPEN, &open);
auto debugFd = DrmHelper::ioctl(device, NEO::DrmIoctl::DebuggerOpen, &open);
if (debugFd >= 0) {
PRINT_DEBUGGER_INFO_LOG("PRELIM_DRM_IOCTL_I915_DEBUGGER_OPEN: open.pid: %d, open.events: %d, debugFd: %d\n",
open.pid, open.events, debugFd);

4
level_zero/tools/source/debug/linux/prelim/drm_helper.cpp
View File

@ -9,9 +9,11 @@
#include "shared/source/os_interface/linux/drm_neo.h"
#include "level_zero/core/source/device/device.h"
namespace L0 {
int DrmHelper::ioctl(Device *device, unsigned long request, void *arg) {
int DrmHelper::ioctl(Device *device, NEO::DrmIoctl request, void *arg) {
auto drm = device->getOsInterface().getDriverModel()->as<NEO::Drm>();
return drm->ioctl(request, arg);
}

9
level_zero/tools/source/debug/linux/prelim/drm_helper.h
View File

@ -7,15 +7,18 @@
#include "shared/source/helpers/topology_map.h"
#include "level_zero/core/source/device/device.h"
namespace NEO {
struct EngineClassInstance;
enum class DrmIoctl;
} // namespace NEO
namespace aub_stream {
enum EngineType : uint32_t;
}
namespace L0 {
struct Device;
struct DrmHelper {
static int ioctl(Device *device, unsigned long request, void *arg);
static int ioctl(Device *device, NEO::DrmIoctl request, void *arg);
static int getErrno(Device *device);
static uint32_t getEngineTileIndex(Device *device, const NEO::EngineClassInstance &engine);
static const NEO::EngineClassInstance *getEngineInstance(Device *device, uint32_t tile, aub_stream::EngineType engineType);

14
opencl/test/unit_test/linux/drm_null_device_tests.cpp
View File

@ -55,36 +55,36 @@ TEST_F(DrmNullDeviceTests, GIVENdrmNullDeviceWHENcallGetDeviceIdTHENreturnProper
}
TEST_F(DrmNullDeviceTests, GIVENdrmNullDeviceWHENcallIoctlTHENalwaysSuccess) {
EXPECT_EQ(drmNullDevice->ioctl(0, nullptr), 0);
EXPECT_EQ(drmNullDevice->ioctl(DrmIoctl::GemExecbuffer2, nullptr), 0);
}
TEST_F(DrmNullDeviceTests, GIVENdrmNullDeviceWHENregReadOtherThenTimestampReadTHENalwaysSuccess) {
RegisterRead arg;
arg.offset = 0;
ASSERT_EQ(drmNullDevice->ioctl(DRM_IOCTL_I915_REG_READ, &arg), 0);
ASSERT_EQ(drmNullDevice->ioctl(DrmIoctl::RegRead, &arg), 0);
}
TEST_F(DrmNullDeviceTests, GIVENdrmNullDeviceWHENgetGpuTimestamp32bOr64bTHENerror) {
RegisterRead arg;
arg.offset = REG_GLOBAL_TIMESTAMP_LDW;
ASSERT_EQ(drmNullDevice->ioctl(DRM_IOCTL_I915_REG_READ, &arg), -1);
ASSERT_EQ(drmNullDevice->ioctl(DrmIoctl::RegRead, &arg), -1);
arg.offset = REG_GLOBAL_TIMESTAMP_UN;
ASSERT_EQ(drmNullDevice->ioctl(DRM_IOCTL_I915_REG_READ, &arg), -1);
ASSERT_EQ(drmNullDevice->ioctl(DrmIoctl::RegRead, &arg), -1);
}
TEST_F(DrmNullDeviceTests, GIVENdrmNullDeviceWHENgetGpuTimestamp36bTHENproperValues) {
RegisterRead arg;
arg.offset = REG_GLOBAL_TIMESTAMP_LDW | 1;
ASSERT_EQ(drmNullDevice->ioctl(DRM_IOCTL_I915_REG_READ, &arg), 0);
ASSERT_EQ(drmNullDevice->ioctl(DrmIoctl::RegRead, &arg), 0);
EXPECT_EQ(arg.value, 1000ULL);
ASSERT_EQ(drmNullDevice->ioctl(DRM_IOCTL_I915_REG_READ, &arg), 0);
ASSERT_EQ(drmNullDevice->ioctl(DrmIoctl::RegRead, &arg), 0);
EXPECT_EQ(arg.value, 2000ULL);
ASSERT_EQ(drmNullDevice->ioctl(DRM_IOCTL_I915_REG_READ, &arg), 0);
ASSERT_EQ(drmNullDevice->ioctl(DrmIoctl::RegRead, &arg), 0);
EXPECT_EQ(arg.value, 3000ULL);
}

36
opencl/test/unit_test/linux/main_linux_dll.cpp
View File

@ -283,9 +283,9 @@ TEST_F(DrmSimpleTests, givenPrintIoctlTimesWhenCallIoctlThenStatisticsAreGathere
drm->setLowPriorityContextParam(contextId);
EXPECT_EQ(2u, drm->ioctlStatistics.size());
auto euTotalData = drm->ioctlStatistics.find(DRM_IOCTL_I915_GETPARAM);
auto euTotalData = drm->ioctlStatistics.find(DrmIoctl::Getparam);
ASSERT_TRUE(euTotalData != drm->ioctlStatistics.end());
EXPECT_EQ(static_cast<unsigned long>(DRM_IOCTL_I915_GETPARAM), euTotalData->first);
EXPECT_EQ(DrmIoctl::Getparam, euTotalData->first);
EXPECT_EQ(2u, euTotalData->second.count);
EXPECT_NE(0, euTotalData->second.totalTime);
EXPECT_NE(initialMin, euTotalData->second.minTime);
@ -295,9 +295,9 @@ TEST_F(DrmSimpleTests, givenPrintIoctlTimesWhenCallIoctlThenStatisticsAreGathere
EXPECT_NE(initialMax, euTotalData->second.maxTime);
auto firstTime = euTotalData->second.totalTime;
auto lowPriorityData = drm->ioctlStatistics.find(DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM);
auto lowPriorityData = drm->ioctlStatistics.find(DrmIoctl::GemContextSetparam);
ASSERT_TRUE(lowPriorityData != drm->ioctlStatistics.end());
EXPECT_EQ(static_cast<unsigned long>(DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM), lowPriorityData->first);
EXPECT_EQ(DrmIoctl::GemContextSetparam, lowPriorityData->first);
EXPECT_EQ(1u, lowPriorityData->second.count);
EXPECT_NE(0, lowPriorityData->second.totalTime);
EXPECT_NE(initialMin, lowPriorityData->second.minTime);
@ -308,39 +308,39 @@ TEST_F(DrmSimpleTests, givenPrintIoctlTimesWhenCallIoctlThenStatisticsAreGathere
drm->getEuTotal(euTotal);
EXPECT_EQ(drm->ioctlStatistics.size(), 2u);
euTotalData = drm->ioctlStatistics.find(DRM_IOCTL_I915_GETPARAM);
euTotalData = drm->ioctlStatistics.find(DrmIoctl::Getparam);
ASSERT_TRUE(euTotalData != drm->ioctlStatistics.end());
EXPECT_EQ(static_cast<unsigned long>(DRM_IOCTL_I915_GETPARAM), euTotalData->first);
EXPECT_EQ(DrmIoctl::Getparam, euTotalData->first);
EXPECT_EQ(3u, euTotalData->second.count);
EXPECT_NE(0u, euTotalData->second.totalTime);
auto secondTime = euTotalData->second.totalTime;
EXPECT_GT(secondTime, firstTime);
lowPriorityData = drm->ioctlStatistics.find(DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM);
lowPriorityData = drm->ioctlStatistics.find(DrmIoctl::GemContextSetparam);
ASSERT_TRUE(lowPriorityData != drm->ioctlStatistics.end());
EXPECT_EQ(static_cast<unsigned long>(DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM), lowPriorityData->first);
EXPECT_EQ(DrmIoctl::GemContextSetparam, lowPriorityData->first);
EXPECT_EQ(1u, lowPriorityData->second.count);
EXPECT_NE(0, lowPriorityData->second.totalTime);
drm->destroyDrmContext(contextId);
EXPECT_EQ(3u, drm->ioctlStatistics.size());
euTotalData = drm->ioctlStatistics.find(DRM_IOCTL_I915_GETPARAM);
euTotalData = drm->ioctlStatistics.find(DrmIoctl::Getparam);
ASSERT_TRUE(euTotalData != drm->ioctlStatistics.end());
EXPECT_EQ(static_cast<unsigned long>(DRM_IOCTL_I915_GETPARAM), euTotalData->first);
EXPECT_EQ(DrmIoctl::Getparam, euTotalData->first);
EXPECT_EQ(3u, euTotalData->second.count);
EXPECT_NE(0, euTotalData->second.totalTime);
lowPriorityData = drm->ioctlStatistics.find(DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM);
lowPriorityData = drm->ioctlStatistics.find(DrmIoctl::GemContextSetparam);
ASSERT_TRUE(lowPriorityData != drm->ioctlStatistics.end());
EXPECT_EQ(static_cast<unsigned long>(DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM), lowPriorityData->first);
EXPECT_EQ(DrmIoctl::GemContextSetparam, lowPriorityData->first);
EXPECT_EQ(1u, lowPriorityData->second.count);
EXPECT_NE(0, lowPriorityData->second.totalTime);
auto destroyData = drm->ioctlStatistics.find(DRM_IOCTL_I915_GEM_CONTEXT_DESTROY);
auto destroyData = drm->ioctlStatistics.find(DrmIoctl::GemContextDestroy);
ASSERT_TRUE(destroyData != drm->ioctlStatistics.end());
EXPECT_EQ(static_cast<unsigned long>(DRM_IOCTL_I915_GEM_CONTEXT_DESTROY), destroyData->first);
EXPECT_EQ(DrmIoctl::GemContextDestroy, destroyData->first);
EXPECT_EQ(1u, destroyData->second.count);
EXPECT_NE(0, destroyData->second.totalTime);
@ -481,7 +481,7 @@ TEST_F(DrmTests, GivenErrorCodeWhenCreatingDrmThenDrmCreatedOnlyWithSpecificErro
// check if device works, although there was EINTR error from KMD
getParam.param = I915_PARAM_CHIPSET_ID;
getParam.value = &lDeviceId;
auto ret = drm->ioctl(DRM_IOCTL_I915_GETPARAM, &getParam);
auto ret = drm->ioctl(DrmIoctl::Getparam, &getParam);
EXPECT_EQ(0, ret);
EXPECT_EQ(deviceId, lDeviceId);
@ -491,7 +491,7 @@ TEST_F(DrmTests, GivenErrorCodeWhenCreatingDrmThenDrmCreatedOnlyWithSpecificErro
// check if device works, although there was EAGAIN error from KMD
getParam.param = I915_PARAM_CHIPSET_ID;
getParam.value = &lDeviceId;
ret = drm->ioctl(DRM_IOCTL_I915_GETPARAM, &getParam);
ret = drm->ioctl(DrmIoctl::Getparam, &getParam);
EXPECT_EQ(0, ret);
EXPECT_EQ(deviceId, lDeviceId);
@ -501,7 +501,7 @@ TEST_F(DrmTests, GivenErrorCodeWhenCreatingDrmThenDrmCreatedOnlyWithSpecificErro
// check if device works, although there was EBUSY error from KMD
getParam.param = I915_PARAM_CHIPSET_ID;
getParam.value = &lDeviceId;
ret = drm->ioctl(DRM_IOCTL_I915_GETPARAM, &getParam);
ret = drm->ioctl(DrmIoctl::Getparam, &getParam);
EXPECT_EQ(0, ret);
EXPECT_EQ(deviceId, lDeviceId);
@ -511,7 +511,7 @@ TEST_F(DrmTests, GivenErrorCodeWhenCreatingDrmThenDrmCreatedOnlyWithSpecificErro
// we failed with any other error code
getParam.param = I915_PARAM_CHIPSET_ID;
getParam.value = &lDeviceId;
ret = drm->ioctl(DRM_IOCTL_I915_GETPARAM, &getParam);
ret = drm->ioctl(DrmIoctl::Getparam, &getParam);
EXPECT_EQ(-1, ret);
EXPECT_EQ(deviceId, lDeviceId);
}

10
opencl/test/unit_test/mt_tests/os_interface/linux/drm_memory_manager_mt_tests.cpp
View File

@ -27,8 +27,8 @@ TEST(DrmMemoryManagerTest, givenDrmMemoryManagerWhenSharedAllocationIsCreatedFro
using Drm::setupIoctlHelper;
MockDrm(int fd, RootDeviceEnvironment &rootDeviceEnvironment) : Drm(std::make_unique<HwDeviceIdDrm>(fd, ""), rootDeviceEnvironment) {}
int ioctl(unsigned long request, void *arg) override {
if (request == DRM_IOCTL_PRIME_FD_TO_HANDLE) {
int ioctl(DrmIoctl request, void *arg) override {
if (request == DrmIoctl::PrimeFdToHandle) {
auto *primeToHandleParams = static_cast<PrimeHandle *>(arg);
primeToHandleParams->handle = 10;
}
@ -86,8 +86,8 @@ TEST(DrmMemoryManagerTest, givenMultipleThreadsWhenSharedAllocationIsCreatedThen
std::atomic<int> primeFdHandle;
std::atomic<int> closeHandle;
int ioctl(unsigned long request, void *arg) override {
if (request == DRM_IOCTL_PRIME_FD_TO_HANDLE) {
int ioctl(DrmIoctl request, void *arg) override {
if (request == DrmIoctl::PrimeFdToHandle) {
auto *primeToHandleParams = static_cast<PrimeHandle *>(arg);
primeToHandleParams->handle = primeFdHandle;
@ -96,7 +96,7 @@ TEST(DrmMemoryManagerTest, givenMultipleThreadsWhenSharedAllocationIsCreatedThen
EXPECT_EQ(closeHandle.load(), primeFdHandle.load());
}
else if (request == DRM_IOCTL_GEM_CLOSE) {
else if (request == DrmIoctl::GemClose) {
closeHandle++;
std::this_thread::yield();

9
opencl/test/unit_test/os_interface/linux/drm_gem_close_worker_tests.cpp
View File

@ -39,13 +39,8 @@ class DrmMockForWorker : public Drm {
std::atomic<std::thread::id> ioctl_caller_thread_id;
DrmMockForWorker(RootDeviceEnvironment &rootDeviceEnvironment) : Drm(std::make_unique<HwDeviceIdDrm>(mockFd, mockPciPath), rootDeviceEnvironment) {
}
int ioctl(unsigned long request, void *arg) override {
if (_IOC_TYPE(request) == DRM_IOCTL_BASE) {
//when drm ioctl is called, try acquire mutex
//main thread can hold mutex, to prevent ioctl handling
std::lock_guard<std::mutex> lock(mutex);
}
if (request == DRM_IOCTL_GEM_CLOSE)
int ioctl(DrmIoctl request, void *arg) override {
if (request == DrmIoctl::GemClose)
gem_close_cnt++;
ioctl_caller_thread_id = std::this_thread::get_id();

14
shared/source/os_interface/linux/device_time_drm.cpp
View File

@ -31,10 +31,10 @@ void DeviceTimeDrm::timestampTypeDetect() {
return;
reg.offset = (REG_GLOBAL_TIMESTAMP_LDW | 1);
err = pDrm->ioctl(DRM_IOCTL_I915_REG_READ, &reg);
err = pDrm->ioctl(DrmIoctl::RegRead, &reg);
if (err) {
reg.offset = REG_GLOBAL_TIMESTAMP_UN;
err = pDrm->ioctl(DRM_IOCTL_I915_REG_READ, &reg);
err = pDrm->ioctl(DrmIoctl::RegRead, &reg);
if (err) {
getGpuTime = &DeviceTimeDrm::getGpuTime32;
} else {
@ -50,7 +50,7 @@ bool DeviceTimeDrm::getGpuTime32(uint64_t *timestamp) {
reg.offset = REG_GLOBAL_TIMESTAMP_LDW;
if (pDrm->ioctl(DRM_IOCTL_I915_REG_READ, &reg)) {
if (pDrm->ioctl(DrmIoctl::RegRead, &reg)) {
return false;
}
*timestamp = reg.value >> 32;
@ -62,7 +62,7 @@ bool DeviceTimeDrm::getGpuTime36(uint64_t *timestamp) {
reg.offset = REG_GLOBAL_TIMESTAMP_LDW | 1;
if (pDrm->ioctl(DRM_IOCTL_I915_REG_READ, &reg)) {
if (pDrm->ioctl(DrmIoctl::RegRead, &reg)) {
return false;
}
*timestamp = reg.value;
@ -78,11 +78,11 @@ bool DeviceTimeDrm::getGpuTimeSplitted(uint64_t *timestamp) {
regHi.offset = REG_GLOBAL_TIMESTAMP_UN;
regLo.offset = REG_GLOBAL_TIMESTAMP_LDW;
err += pDrm->ioctl(DRM_IOCTL_I915_REG_READ, &regHi);
err += pDrm->ioctl(DrmIoctl::RegRead, &regHi);
do {
tmpHi = regHi.value;
err += pDrm->ioctl(DRM_IOCTL_I915_REG_READ, &regLo);
err += pDrm->ioctl(DRM_IOCTL_I915_REG_READ, &regHi);
err += pDrm->ioctl(DrmIoctl::RegRead, &regLo);
err += pDrm->ioctl(DrmIoctl::RegRead, &regHi);
} while (err == 0 && regHi.value != tmpHi && --loop);
if (err) {

4
shared/source/os_interface/linux/drm_buffer_object.cpp
View File

@ -67,7 +67,7 @@ bool BufferObject::close() {
PRINT_DEBUG_STRING(DebugManager.flags.PrintBOCreateDestroyResult.get(), stdout, "Calling gem close on handle: BO-%d\n", this->handle);
int ret = this->drm->ioctl(DRM_IOCTL_GEM_CLOSE, &close);
int ret = this->drm->ioctl(DrmIoctl::GemClose, &close);
if (ret != 0) {
int err = errno;
PRINT_DEBUG_STRING(DebugManager.flags.PrintDebugMessages.get(), stderr, "ioctl(GEM_CLOSE) failed with %d. errno=%d(%s)\n", ret, err, strerror(err));
@ -101,7 +101,7 @@ bool BufferObject::setTiling(uint32_t mode, uint32_t stride) {
setTiling.tilingMode = mode;
setTiling.stride = stride;
if (this->drm->ioctl(DRM_IOCTL_I915_GEM_SET_TILING, &setTiling) != 0) {
if (this->drm->ioctl(DrmIoctl::GemSetTiling, &setTiling) != 0) {
return false;
}

1
shared/source/os_interface/linux/drm_gem_close_worker.cpp
View File

@ -16,7 +16,6 @@
#include <atomic>
#include <iostream>
#include <queue>
#include <stdio.h>
namespace NEO {

28
shared/source/os_interface/linux/drm_memory_manager.cpp
View File

@ -247,7 +247,7 @@ NEO::BufferObject *DrmMemoryManager::allocUserptr(uintptr_t address, size_t size
auto &drm = this->getDrm(rootDeviceIndex);
if (drm.ioctl(DRM_IOCTL_I915_GEM_USERPTR, &userptr) != 0) {
if (drm.ioctl(DrmIoctl::GemUserptr, &userptr) != 0) {
return nullptr;
}
@ -518,7 +518,7 @@ GraphicsAllocation *DrmMemoryManager::allocateMemoryByKMD(const AllocationData &
auto &drm = getDrm(allocationData.rootDeviceIndex);
[[maybe_unused]] auto ret = drm.ioctl(DRM_IOCTL_I915_GEM_CREATE, &create);
[[maybe_unused]] auto ret = drm.ioctl(DrmIoctl::GemCreate, &create);
DEBUG_BREAK_IF(ret != 0);
auto patIndex = drm.getPatIndex(gmm.get(), allocationData.type, CacheRegion::Default, CachePolicy::WriteBack, false);
@ -551,7 +551,7 @@ GraphicsAllocation *DrmMemoryManager::allocateGraphicsMemoryForImageImpl(const A
auto &drm = this->getDrm(allocationData.rootDeviceIndex);
[[maybe_unused]] auto ret = drm.ioctl(DRM_IOCTL_I915_GEM_CREATE, &create);
[[maybe_unused]] auto ret = drm.ioctl(DrmIoctl::GemCreate, &create);
DEBUG_BREAK_IF(ret != 0);
auto patIndex = drm.getPatIndex(gmm.get(), allocationData.type, CacheRegion::Default, CachePolicy::WriteBack, false);
@ -681,7 +681,7 @@ GraphicsAllocation *DrmMemoryManager::createGraphicsAllocationFromMultipleShared
PrimeHandle openFd = {0, 0, 0};
openFd.fileDescriptor = handle;
auto ret = this->getDrm(properties.rootDeviceIndex).ioctl(DRM_IOCTL_PRIME_FD_TO_HANDLE, &openFd);
auto ret = this->getDrm(properties.rootDeviceIndex).ioctl(DrmIoctl::PrimeFdToHandle, &openFd);
if (ret != 0) {
[[maybe_unused]] int err = errno;
@ -767,7 +767,7 @@ GraphicsAllocation *DrmMemoryManager::createGraphicsAllocationFromSharedHandle(o
auto &drm = this->getDrm(properties.rootDeviceIndex);
auto ret = drm.ioctl(DRM_IOCTL_PRIME_FD_TO_HANDLE, &openFd);
auto ret = drm.ioctl(DrmIoctl::PrimeFdToHandle, &openFd);
if (ret != 0) {
[[maybe_unused]] int err = errno;
@ -817,7 +817,7 @@ GraphicsAllocation *DrmMemoryManager::createGraphicsAllocationFromSharedHandle(o
if (properties.imgInfo) {
GemGetTiling getTiling{};
getTiling.handle = boHandle;
ret = drm.ioctl(DRM_IOCTL_I915_GEM_GET_TILING, &getTiling);
ret = drm.ioctl(DrmIoctl::GemGetTiling, &getTiling);
if (ret == 0) {
if (getTiling.isTilingDisabled()) {
@ -856,7 +856,7 @@ GraphicsAllocation *DrmMemoryManager::createPaddedAllocation(GraphicsAllocation
GemMmap mmapArg = {};
mmapArg.handle = bo->peekHandle();
mmapArg.size = bo->peekSize();
if (getDrm(rootDeviceIndex).ioctl(DRM_IOCTL_I915_GEM_MMAP, &mmapArg) != 0) {
if (getDrm(rootDeviceIndex).ioctl(DrmIoctl::GemMmap, &mmapArg) != 0) {
return nullptr;
}
srcPtr = addrToPtr(mmapArg.addrPtr);
@ -988,7 +988,7 @@ uint64_t DrmMemoryManager::getSystemSharedMemory(uint32_t rootDeviceIndex) {
GemContextParam getContextParam = {};
getContextParam.param = I915_CONTEXT_PARAM_GTT_SIZE;
[[maybe_unused]] auto ret = getDrm(rootDeviceIndex).ioctl(DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM, &getContextParam);
[[maybe_unused]] auto ret = getDrm(rootDeviceIndex).ioctl(DrmIoctl::GemContextGetparam, &getContextParam);
DEBUG_BREAK_IF(ret != 0);
uint64_t gpuMemorySize = getContextParam.value;
@ -1080,7 +1080,7 @@ bool DrmMemoryManager::setDomainCpu(GraphicsAllocation &graphicsAllocation, bool
setDomain.readDomains = I915_GEM_DOMAIN_CPU;
setDomain.writeDomain = writeEnable ? I915_GEM_DOMAIN_CPU : 0;
return getDrm(graphicsAllocation.getRootDeviceIndex()).ioctl(DRM_IOCTL_I915_GEM_SET_DOMAIN, &setDomain) == 0;
return getDrm(graphicsAllocation.getRootDeviceIndex()).ioctl(DrmIoctl::GemSetDomain, &setDomain) == 0;
}
void *DrmMemoryManager::lockResourceImpl(GraphicsAllocation &graphicsAllocation) {
@ -1102,7 +1102,7 @@ void *DrmMemoryManager::lockResourceImpl(GraphicsAllocation &graphicsAllocation)
GemMmap mmapArg = {};
mmapArg.handle = bo->peekHandle();
mmapArg.size = bo->peekSize();
if (getDrm(graphicsAllocation.getRootDeviceIndex()).ioctl(DRM_IOCTL_I915_GEM_MMAP, &mmapArg) != 0) {
if (getDrm(graphicsAllocation.getRootDeviceIndex()).ioctl(DrmIoctl::GemMmap, &mmapArg) != 0) {
return nullptr;
}
@ -1139,7 +1139,7 @@ int DrmMemoryManager::obtainFdFromHandle(int boHandle, uint32_t rootDeviceindex)
openFd.flags = DRM_CLOEXEC | DRM_RDWR;
openFd.handle = boHandle;
getDrm(rootDeviceindex).ioctl(DRM_IOCTL_PRIME_HANDLE_TO_FD, &openFd);
getDrm(rootDeviceindex).ioctl(DrmIoctl::PrimeHandleToFd, &openFd);
return openFd.fileDescriptor;
}
@ -1638,10 +1638,10 @@ bool DrmMemoryManager::retrieveMmapOffsetForBufferObject(uint32_t rootDeviceInde
mmapOffset.handle = bo.peekHandle();
mmapOffset.flags = isLocalMemorySupported(rootDeviceIndex) ? mmapOffsetFixed : flags;
auto &drm = getDrm(rootDeviceIndex);
auto ret = drm.ioctl(DRM_IOCTL_I915_GEM_MMAP_OFFSET, &mmapOffset);
auto ret = drm.ioctl(DrmIoctl::GemMmapOffset, &mmapOffset);
if (ret != 0 && isLocalMemorySupported(rootDeviceIndex)) {
mmapOffset.flags = flags;
ret = drm.ioctl(DRM_IOCTL_I915_GEM_MMAP_OFFSET, &mmapOffset);
ret = drm.ioctl(DrmIoctl::GemMmapOffset, &mmapOffset);
}
if (ret != 0) {
int err = drm.getErrno();
@ -1884,7 +1884,7 @@ DrmAllocation *DrmMemoryManager::createUSMHostAllocationFromSharedHandle(osHandl
auto &drm = this->getDrm(properties.rootDeviceIndex);
auto patIndex = drm.getPatIndex(nullptr, properties.allocationType, CacheRegion::Default, CachePolicy::WriteBack, false);
auto ret = drm.ioctl(DRM_IOCTL_PRIME_FD_TO_HANDLE, &openFd);
auto ret = drm.ioctl(DrmIoctl::PrimeFdToHandle, &openFd);
if (ret != 0) {
int err = drm.getErrno();
PRINT_DEBUG_STRING(DebugManager.flags.PrintDebugMessages.get(), stderr, "ioctl(PRIME_FD_TO_HANDLE) failed with %d. errno=%d(%s)\n", ret, err, strerror(err));

203
shared/source/os_interface/linux/drm_neo.cpp
View File

@ -70,131 +70,81 @@ std::string getIoctlParamString(int param) {
}
}
std::string getIoctlString(unsigned long request) {
switch (request) {
case DRM_IOCTL_I915_GEM_EXECBUFFER2:
std::string getIoctlString(DrmIoctl ioctlRequest) {
switch (ioctlRequest) {
case DrmIoctl::GemExecbuffer2:
return "DRM_IOCTL_I915_GEM_EXECBUFFER2";
case DRM_IOCTL_I915_GEM_WAIT:
case DrmIoctl::GemWait:
return "DRM_IOCTL_I915_GEM_WAIT";
case DRM_IOCTL_GEM_CLOSE:
case DrmIoctl::GemClose:
return "DRM_IOCTL_GEM_CLOSE";
case DRM_IOCTL_I915_GEM_USERPTR:
case DrmIoctl::GemUserptr:
return "DRM_IOCTL_I915_GEM_USERPTR";
case DRM_IOCTL_I915_INIT:
return "DRM_IOCTL_I915_INIT";
case DRM_IOCTL_I915_FLUSH:
return "DRM_IOCTL_I915_FLUSH";
case DRM_IOCTL_I915_FLIP:
return "DRM_IOCTL_I915_FLIP";
case DRM_IOCTL_I915_BATCHBUFFER:
return "DRM_IOCTL_I915_BATCHBUFFER";
case DRM_IOCTL_I915_IRQ_EMIT:
return "DRM_IOCTL_I915_IRQ_EMIT";
case DRM_IOCTL_I915_IRQ_WAIT:
return "DRM_IOCTL_I915_IRQ_WAIT";
case DRM_IOCTL_I915_GETPARAM:
case DrmIoctl::Getparam:
return "DRM_IOCTL_I915_GETPARAM";
case DRM_IOCTL_I915_SETPARAM:
return "DRM_IOCTL_I915_SETPARAM";
case DRM_IOCTL_I915_ALLOC:
return "DRM_IOCTL_I915_ALLOC";
case DRM_IOCTL_I915_FREE:
return "DRM_IOCTL_I915_FREE";
case DRM_IOCTL_I915_INIT_HEAP:
return "DRM_IOCTL_I915_INIT_HEAP";
case DRM_IOCTL_I915_CMDBUFFER:
return "DRM_IOCTL_I915_CMDBUFFER";
case DRM_IOCTL_I915_DESTROY_HEAP:
return "DRM_IOCTL_I915_DESTROY_HEAP";
case DRM_IOCTL_I915_SET_VBLANK_PIPE:
return "DRM_IOCTL_I915_SET_VBLANK_PIPE";
case DRM_IOCTL_I915_GET_VBLANK_PIPE:
return "DRM_IOCTL_I915_GET_VBLANK_PIPE";
case DRM_IOCTL_I915_VBLANK_SWAP:
return "DRM_IOCTL_I915_VBLANK_SWAP";
case DRM_IOCTL_I915_HWS_ADDR:
return "DRM_IOCTL_I915_HWS_ADDR";
case DRM_IOCTL_I915_GEM_INIT:
return "DRM_IOCTL_I915_GEM_INIT";
case DRM_IOCTL_I915_GEM_EXECBUFFER:
return "DRM_IOCTL_I915_GEM_EXECBUFFER";
case DRM_IOCTL_I915_GEM_EXECBUFFER2_WR:
return "DRM_IOCTL_I915_GEM_EXECBUFFER2_WR";
case DRM_IOCTL_I915_GEM_PIN:
return "DRM_IOCTL_I915_GEM_PIN";
case DRM_IOCTL_I915_GEM_UNPIN:
return "DRM_IOCTL_I915_GEM_UNPIN";
case DRM_IOCTL_I915_GEM_BUSY:
return "DRM_IOCTL_I915_GEM_BUSY";
case DRM_IOCTL_I915_GEM_SET_CACHING:
return "DRM_IOCTL_I915_GEM_SET_CACHING";
case DRM_IOCTL_I915_GEM_GET_CACHING:
return "DRM_IOCTL_I915_GEM_GET_CACHING";
case DRM_IOCTL_I915_GEM_THROTTLE:
return "DRM_IOCTL_I915_GEM_THROTTLE";
case DRM_IOCTL_I915_GEM_ENTERVT:
return "DRM_IOCTL_I915_GEM_ENTERVT";
case DRM_IOCTL_I915_GEM_LEAVEVT:
return "DRM_IOCTL_I915_GEM_LEAVEVT";
case DRM_IOCTL_I915_GEM_CREATE:
case DrmIoctl::GemCreate:
return "DRM_IOCTL_I915_GEM_CREATE";
case DRM_IOCTL_I915_GEM_PREAD:
return "DRM_IOCTL_I915_GEM_PREAD";
case DRM_IOCTL_I915_GEM_PWRITE:
return "DRM_IOCTL_I915_GEM_PWRITE";
case DRM_IOCTL_I915_GEM_SET_DOMAIN:
case DrmIoctl::GemSetDomain:
return "DRM_IOCTL_I915_GEM_SET_DOMAIN";
case DRM_IOCTL_I915_GEM_SW_FINISH:
return "DRM_IOCTL_I915_GEM_SW_FINISH";
case DRM_IOCTL_I915_GEM_SET_TILING:
case DrmIoctl::GemSetTiling:
return "DRM_IOCTL_I915_GEM_SET_TILING";
case DRM_IOCTL_I915_GEM_GET_TILING:
case DrmIoctl::GemGetTiling:
return "DRM_IOCTL_I915_GEM_GET_TILING";
case DRM_IOCTL_I915_GEM_GET_APERTURE:
return "DRM_IOCTL_I915_GEM_GET_APERTURE";
case DRM_IOCTL_I915_GET_PIPE_FROM_CRTC_ID:
return "DRM_IOCTL_I915_GET_PIPE_FROM_CRTC_ID";
case DRM_IOCTL_I915_GEM_MADVISE:
return "DRM_IOCTL_I915_GEM_MADVISE";
case DRM_IOCTL_I915_OVERLAY_PUT_IMAGE:
return "DRM_IOCTL_I915_OVERLAY_PUT_IMAGE";
case DRM_IOCTL_I915_OVERLAY_ATTRS:
return "DRM_IOCTL_I915_OVERLAY_ATTRS";
case DRM_IOCTL_I915_SET_SPRITE_COLORKEY:
return "DRM_IOCTL_I915_SET_SPRITE_COLORKEY";
case DRM_IOCTL_I915_GET_SPRITE_COLORKEY:
return "DRM_IOCTL_I915_GET_SPRITE_COLORKEY";
case DRM_IOCTL_I915_GEM_CONTEXT_CREATE:
return "DRM_IOCTL_I915_GEM_CONTEXT_CREATE";
case DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT:
case DrmIoctl::GemContextCreateExt:
return "DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT";
case DRM_IOCTL_I915_GEM_CONTEXT_DESTROY:
case DrmIoctl::GemContextDestroy:
return "DRM_IOCTL_I915_GEM_CONTEXT_DESTROY";
case DRM_IOCTL_I915_REG_READ:
case DrmIoctl::RegRead:
return "DRM_IOCTL_I915_REG_READ";
case DRM_IOCTL_I915_GET_RESET_STATS:
case DrmIoctl::GetResetStats:
return "DRM_IOCTL_I915_GET_RESET_STATS";
case DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM:
case DrmIoctl::GemContextGetparam:
return "DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM";
case DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM:
case DrmIoctl::GemContextSetparam:
return "DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM";
case DRM_IOCTL_I915_PERF_OPEN:
return "DRM_IOCTL_I915_PERF_OPEN";
case DRM_IOCTL_I915_PERF_ADD_CONFIG:
return "DRM_IOCTL_I915_PERF_ADD_CONFIG";
case DRM_IOCTL_I915_PERF_REMOVE_CONFIG:
return "DRM_IOCTL_I915_PERF_REMOVE_CONFIG";
case DRM_IOCTL_I915_QUERY:
case DrmIoctl::Query:
return "DRM_IOCTL_I915_QUERY";
case DRM_IOCTL_I915_GEM_MMAP:
case DrmIoctl::GemMmap:
return "DRM_IOCTL_I915_GEM_MMAP";
case DRM_IOCTL_PRIME_FD_TO_HANDLE:
case DrmIoctl::PrimeFdToHandle:
return "DRM_IOCTL_PRIME_FD_TO_HANDLE";
case DRM_IOCTL_PRIME_HANDLE_TO_FD:
case DrmIoctl::PrimeHandleToFd:
return "DRM_IOCTL_PRIME_HANDLE_TO_FD";
default:
return getIoctlStringRemaining(request);
case DrmIoctl::GemVmBind:
return "PRELIM_DRM_IOCTL_I915_GEM_VM_BIND";
case DrmIoctl::GemVmUnbind:
return "PRELIM_DRM_IOCTL_I915_GEM_VM_UNBIND";
case DrmIoctl::GemWaitUserFence:
return "PRELIM_DRM_IOCTL_I915_GEM_WAIT_USER_FENCE";
case DrmIoctl::GemCreateExt:
return "DRM_IOCTL_I915_GEM_CREATE_EXT";
case DrmIoctl::DG1GemCreateExt:
return "DG1_DRM_IOCTL_I915_GEM_CREATE_EXT";
case DrmIoctl::GemVmAdvise:
return "PRELIM_DRM_IOCTL_I915_GEM_VM_ADVISE";
case DrmIoctl::GemVmPrefetch:
return "PRELIM_DRM_IOCTL_I915_GEM_VM_PREFETCH";
case DrmIoctl::UuidRegister:
return "PRELIM_DRM_IOCTL_I915_UUID_REGISTER";
case DrmIoctl::UuidUnregister:
return "PRELIM_DRM_IOCTL_I915_UUID_UNREGISTER";
case DrmIoctl::DebuggerOpen:
return "PRELIM_DRM_IOCTL_I915_DEBUGGER_OPEN";
case DrmIoctl::GemClosReserve:
return "PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE";
case DrmIoctl::GemClosFree:
return "PRELIM_DRM_IOCTL_I915_GEM_CLOS_FREE";
case DrmIoctl::GemCacheReserve:
return "PRELIM_DRM_IOCTL_I915_GEM_CACHE_RESERVE";
case DrmIoctl::GemMmapOffset:
return "DRM_IOCTL_I915_GEM_MMAP_OFFSET";
case DrmIoctl::GemVmCreate:
return "DRM_IOCTL_I915_GEM_VM_CREATE";
case DrmIoctl::GemVmDestroy:
return "DRM_IOCTL_I915_GEM_VM_DESTROY";
}
UNRECOVERABLE_IF(true);
return "";
}
} // namespace IoctlToStringHelper
@ -212,7 +162,8 @@ void Drm::queryAndSetVmBindPatIndexProgrammingSupport() {
this->vmBindPatIndexProgrammingSupported = HwInfoConfig::get(hwInfo->platform.eProductFamily)->isVmBindPatIndexProgrammingSupported();
}
int Drm::ioctl(unsigned long request, void *arg) {
int Drm::ioctl(DrmIoctl request, void *arg) {
auto requestValue = getIoctlRequestValue(request, ioctlHelper.get());
int ret;
int returnedErrno;
SYSTEM_ENTER();
@ -230,7 +181,7 @@ int Drm::ioctl(unsigned long request, void *arg) {
if (measureTime) {
start = std::chrono::steady_clock::now();
}
ret = SysCalls::ioctl(getFileDescriptor(), request, arg);
ret = SysCalls::ioctl(getFileDescriptor(), requestValue, arg);
returnedErrno = errno;
@ -272,7 +223,7 @@ int Drm::getParamIoctl(int param, int *dstValue) {
getParam.param = param;
getParam.value = dstValue;
int retVal = ioctl(DRM_IOCTL_I915_GETPARAM, &getParam);
int retVal = ioctl(DrmIoctl::Getparam, &getParam);
if (DebugManager.flags.PrintIoctlEntries.get()) {
printf("DRM_IOCTL_I915_GETPARAM: param: %s, output value: %d, retCode:% d\n",
IoctlToStringHelper::getIoctlParamString(param).c_str(),
@ -299,7 +250,7 @@ int Drm::enableTurboBoost() {
contextParam.param = I915_CONTEXT_PRIVATE_PARAM_BOOST;
contextParam.value = 1;
return ioctl(DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM, &contextParam);
return ioctl(DrmIoctl::GemContextSetparam, &contextParam);
}
int Drm::getEnabledPooledEu(int &enabled) {
@ -322,7 +273,7 @@ int Drm::queryGttSize(uint64_t &gttSizeOutput) {
GemContextParam contextParam = {0};
contextParam.param = I915_CONTEXT_PARAM_GTT_SIZE;
int ret = ioctl(DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM, &contextParam);
int ret = ioctl(DrmIoctl::GemContextGetparam, &contextParam);
if (ret == 0) {
gttSizeOutput = contextParam.value;
}
@ -338,7 +289,7 @@ bool Drm::isGpuHangDetected(OsContext &osContext) {
ResetStats resetStats{};
resetStats.contextId = drmContextId;
const auto retVal{ioctl(DRM_IOCTL_I915_GET_RESET_STATS, &resetStats)};
const auto retVal{ioctl(DrmIoctl::GetResetStats, &resetStats)};
UNRECOVERABLE_IF(retVal != 0);
if (resetStats.batchActive > 0 || resetStats.batchPending > 0) {
@ -366,7 +317,7 @@ void Drm::setLowPriorityContextParam(uint32_t drmContextId) {
gcp.param = I915_CONTEXT_PARAM_PRIORITY;
gcp.value = -1023;
auto retVal = ioctl(DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM, &gcp);
auto retVal = ioctl(DrmIoctl::GemContextSetparam, &gcp);
UNRECOVERABLE_IF(retVal != 0);
}
@ -378,7 +329,7 @@ int Drm::getQueueSliceCount(GemContextParamSseu *sseu) {
contextParam.value = reinterpret_cast<uint64_t>(sseu);
contextParam.size = sizeof(struct GemContextParamSseu);
return ioctl(DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM, &contextParam);
return ioctl(DrmIoctl::GemContextGetparam, &contextParam);
}
uint64_t Drm::getSliceMask(uint64_t sliceCount) {
@ -393,7 +344,7 @@ bool Drm::setQueueSliceCount(uint64_t sliceCount) {
contextParam.contextId = 0;
contextParam.value = reinterpret_cast<uint64_t>(&sseu);
contextParam.size = sizeof(struct GemContextParamSseu);
int retVal = ioctl(DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM, &contextParam);
int retVal = ioctl(DrmIoctl::GemContextSetparam, &contextParam);
if (retVal == 0) {
return true;
}
@ -405,7 +356,7 @@ void Drm::checkNonPersistentContextsSupport() {
GemContextParam contextParam = {};
contextParam.param = I915_CONTEXT_PARAM_PERSISTENCE;
auto retVal = ioctl(DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM, &contextParam);
auto retVal = ioctl(DrmIoctl::GemContextGetparam, &contextParam);
if (retVal == 0 && contextParam.value == 1) {
nonPersistentContextsSupported = true;
} else {
@ -418,7 +369,7 @@ void Drm::setNonPersistentContext(uint32_t drmContextId) {
contextParam.contextId = drmContextId;
contextParam.param = I915_CONTEXT_PARAM_PERSISTENCE;
ioctl(DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM, &contextParam);
ioctl(DrmIoctl::GemContextSetparam, &contextParam);
}
void Drm::setUnrecoverableContext(uint32_t drmContextId) {
@ -428,7 +379,7 @@ void Drm::setUnrecoverableContext(uint32_t drmContextId) {
contextParam.value = 0;
contextParam.size = 0;
ioctl(DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM, &contextParam);
ioctl(DrmIoctl::GemContextSetparam, &contextParam);
}
uint32_t Drm::createDrmContext(uint32_t drmVmId, bool isDirectSubmissionRequested, bool isCooperativeContextRequested) {
@ -461,7 +412,7 @@ uint32_t Drm::createDrmContext(uint32_t drmVmId, bool isDirectSubmissionRequeste
if (isCooperativeContextRequested) {
return ioctlHelper->createCooperativeContext(this, gcc);
}
auto ioctlResult = ioctl(DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT, &gcc);
auto ioctlResult = ioctl(DrmIoctl::GemContextCreateExt, &gcc);
UNRECOVERABLE_IF(ioctlResult != 0);
return gcc.contextId;
@ -470,14 +421,14 @@ uint32_t Drm::createDrmContext(uint32_t drmVmId, bool isDirectSubmissionRequeste
void Drm::destroyDrmContext(uint32_t drmContextId) {
GemContextDestroy destroy{};
destroy.contextId = drmContextId;
auto retVal = ioctl(DRM_IOCTL_I915_GEM_CONTEXT_DESTROY, &destroy);
auto retVal = ioctl(DrmIoctl::GemContextDestroy, &destroy);
UNRECOVERABLE_IF(retVal != 0);
}
void Drm::destroyDrmVirtualMemory(uint32_t drmVmId) {
GemVmControl ctl = {};
ctl.vmId = drmVmId;
auto ret = SysCalls::ioctl(getFileDescriptor(), DRM_IOCTL_I915_GEM_VM_DESTROY, &ctl);
auto ret = SysCalls::ioctl(getFileDescriptor(), ioctlHelper->getIoctlRequestValue(DrmIoctl::GemVmDestroy), &ctl);
UNRECOVERABLE_IF(ret != 0);
}
@ -486,7 +437,7 @@ int Drm::queryVmId(uint32_t drmContextId, uint32_t &vmId) {
param.contextId = drmContextId;
param.value = 0;
param.param = I915_CONTEXT_PARAM_VM;
auto retVal = this->ioctl(DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM, &param);
auto retVal = this->ioctl(DrmIoctl::GemContextGetparam, &param);
vmId = static_cast<uint32_t>(param.value);
@ -682,7 +633,7 @@ std::vector<uint8_t> Drm::query(uint32_t queryId, uint32_t queryItemFlags) {
query.itemsPtr = reinterpret_cast<uint64_t>(&queryItem);
query.numItems = 1;
auto ret = this->ioctl(DRM_IOCTL_I915_QUERY, &query);
auto ret = this->ioctl(DrmIoctl::Query, &query);
if (ret != 0 || queryItem.length <= 0) {
return {};
}
@ -690,7 +641,7 @@ std::vector<uint8_t> Drm::query(uint32_t queryId, uint32_t queryItemFlags) {
auto data = std::vector<uint8_t>(queryItem.length, 0);
queryItem.dataPtr = castToUint64(data.data());
ret = this->ioctl(DRM_IOCTL_I915_QUERY, &query);
ret = this->ioctl(DrmIoctl::Query, &query);
if (ret != 0 || queryItem.length <= 0) {
return {};
}
@ -878,7 +829,7 @@ int Drm::waitHandle(uint32_t waitHandle, int64_t timeout) {
wait.boHandle = waitHandle;
wait.timeoutNs = timeout;
int ret = ioctl(DRM_IOCTL_I915_GEM_WAIT, &wait);
int ret = ioctl(DrmIoctl::GemWait, &wait);
if (ret != 0) {
int err = errno;
PRINT_DEBUG_STRING(DebugManager.flags.PrintDebugMessages.get(), stderr, "ioctl(I915_GEM_WAIT) failed with %d. errno=%d(%s)\n", ret, err, strerror(err));
@ -1322,7 +1273,7 @@ unsigned int Drm::bindDrmContext(uint32_t drmContextId, uint32_t deviceIndex, au
param.param = I915_CONTEXT_PARAM_ENGINES;
param.value = castToUint64(&contextEngines);
auto retVal = ioctl(DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM, &param);
auto retVal = ioctl(DrmIoctl::GemContextSetparam, &param);
UNRECOVERABLE_IF(retVal != 0);
return I915_EXEC_DEFAULT;
@ -1527,7 +1478,7 @@ int Drm::createDrmVirtualMemory(uint32_t &drmVmId) {
ctl.flags = ioctlHelper->getFlagsForVmCreate(disableScratch, enablePageFault, useVmBind);
auto ret = SysCalls::ioctl(getFileDescriptor(), DRM_IOCTL_I915_GEM_VM_CREATE, &ctl);
auto ret = SysCalls::ioctl(getFileDescriptor(), ioctlHelper->getIoctlRequestValue(DrmIoctl::GemVmCreate), &ctl);
if (ret == 0) {
drmVmId = ctl.vmId;

4
shared/source/os_interface/linux/drm_neo.h
View File

@ -80,7 +80,7 @@ class Drm : public DriverModel {
~Drm() override;
virtual int ioctl(unsigned long request, void *arg);
virtual int ioctl(DrmIoctl request, void *arg);
int getDeviceID(int &devId);
unsigned int getDeviceHandle() const override {
@ -306,7 +306,7 @@ class Drm : public DriverModel {
long long minTime = std::numeric_limits<long long>::max();
long long maxTime = 0;
};
std::unordered_map<unsigned long, IoctlStatisticsEntry> ioctlStatistics;
std::unordered_map<DrmIoctl, IoctlStatisticsEntry> ioctlStatistics;
std::mutex bindFenceMutex;
std::array<uint64_t, EngineLimits::maxHandleCount> pagingFence;

6
shared/source/os_interface/linux/drm_null_device.h
View File

@ -20,10 +20,10 @@ namespace NEO {
class DrmNullDevice : public Drm {
public:
int ioctl(unsigned long request, void *arg) override {
if (request == DRM_IOCTL_I915_GETPARAM || request == DRM_IOCTL_I915_QUERY) {
int ioctl(DrmIoctl request, void *arg) override {
if (request == DrmIoctl::Getparam || request == DrmIoctl::Query) {
return Drm::ioctl(request, arg);
} else if (request == DRM_IOCTL_I915_REG_READ) {
} else if (request == DrmIoctl::RegRead) {
auto *regArg = static_cast<RegisterRead *>(arg);
// Handle only 36b timestamp
if (regArg->offset == (REG_GLOBAL_TIMESTAMP_LDW | 1)) {

11
shared/source/os_interface/linux/drm_wrappers.cpp
View File

@ -7,6 +7,8 @@
#include "shared/source/os_interface/linux/drm_wrappers.h"
#include "shared/source/os_interface/linux/ioctl_helper.h"
#include "drm/i915_drm.h"
#include <cstddef>
@ -170,4 +172,13 @@ static_assert(offsetof(DrmVersion, date) == offsetof(drm_version, date));
static_assert(offsetof(DrmVersion, descLen) == offsetof(drm_version, desc_len));
static_assert(offsetof(DrmVersion, desc) == offsetof(drm_version, desc));
unsigned int getIoctlRequestValue(DrmIoctl ioctlRequest, IoctlHelper *ioctlHelper) {
switch (ioctlRequest) {
case DrmIoctl::Getparam:
return DRM_IOCTL_I915_GETPARAM;
default:
UNRECOVERABLE_IF(!ioctlHelper);
return ioctlHelper->getIoctlRequestValue(ioctlRequest);
}
}
} // namespace NEO

41
shared/source/os_interface/linux/drm_wrappers.h
View File

@ -9,6 +9,7 @@
#include <cstddef>
#include <cstdint>
namespace NEO {
class IoctlHelper;
struct RegisterRead {
uint64_t offset;
@ -196,4 +197,44 @@ struct DrmVersion {
size_t descLen;
char *desc;
};
enum class DrmIoctl {
GemExecbuffer2,
GemWait,
GemUserptr,
Getparam,
GemCreate,
GemSetDomain,
GemSetTiling,
GemGetTiling,
GemContextCreateExt,
GemContextDestroy,
RegRead,
GetResetStats,
GemContextGetparam,
GemContextSetparam,
Query,
GemMmap,
GemMmapOffset,
GemVmCreate,
GemVmDestroy,
GemClose,
PrimeFdToHandle,
PrimeHandleToFd,
GemVmBind,
GemVmUnbind,
GemWaitUserFence,
DG1GemCreateExt,
GemCreateExt,
GemVmAdvise,
GemVmPrefetch,
UuidRegister,
UuidUnregister,
DebuggerOpen,
GemClosReserve,
GemClosFree,
GemCacheReserve,
};
unsigned int getIoctlRequestValue(DrmIoctl ioctlRequest, IoctlHelper *ioctlHelper);
} // namespace NEO

2
shared/source/os_interface/linux/ioctl_helper.cpp
View File

@ -18,7 +18,7 @@
namespace NEO {
uint32_t IoctlHelper::ioctl(Drm *drm, unsigned long request, void *arg) {
uint32_t IoctlHelper::ioctl(Drm *drm, DrmIoctl request, void *arg) {
return drm->ioctl(request, arg);
}

6
shared/source/os_interface/linux/ioctl_helper.h
View File

@ -66,7 +66,7 @@ class IoctlHelper {
public:
virtual ~IoctlHelper() {}
static IoctlHelper *get(const PRODUCT_FAMILY productFamily, const std::string &prelimVersion, const std::string &drmVersion);
static uint32_t ioctl(Drm *drm, unsigned long request, void *arg);
static uint32_t ioctl(Drm *drm, DrmIoctl request, void *arg);
virtual IoctlHelper *clone() = 0;
virtual bool isVmBindAvailable(Drm *drm) = 0;
@ -114,6 +114,7 @@ class IoctlHelper {
virtual bool isContextDebugSupported(Drm *drm) = 0;
virtual int setContextDebugFlag(Drm *drm, uint32_t drmContextId) = 0;
virtual bool isDebugAttachAvailable() = 0;
virtual unsigned int getIoctlRequestValue(DrmIoctl ioctlRequest) = 0;
void fillExecObject(ExecObject &execObject, uint32_t handle, uint64_t gpuAddress, uint32_t drmContextId, bool bindInfo, bool isMarkedForCapture);
void logExecObject(const ExecObject &execObject, std::stringstream &logger, size_t size);
@ -171,6 +172,7 @@ class IoctlHelperUpstream : public IoctlHelper {
bool isContextDebugSupported(Drm *drm) override;
int setContextDebugFlag(Drm *drm, uint32_t drmContextId) override;
bool isDebugAttachAvailable() override;
unsigned int getIoctlRequestValue(DrmIoctl ioctlRequest) override;
};
template <PRODUCT_FAMILY gfxProduct>
@ -184,6 +186,7 @@ class IoctlHelperImpl : public IoctlHelperUpstream {
uint32_t createGemExt(Drm *drm, const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle) override;
std::vector<MemoryRegion> translateToMemoryRegions(const std::vector<uint8_t> &regionInfo) override;
unsigned int getIoctlRequestValue(DrmIoctl ioctlRequest) override;
};
class IoctlHelperPrelim20 : public IoctlHelper {
@ -235,6 +238,7 @@ class IoctlHelperPrelim20 : public IoctlHelper {
bool isContextDebugSupported(Drm *drm) override;
int setContextDebugFlag(Drm *drm, uint32_t drmContextId) override;
bool isDebugAttachAvailable() override;
unsigned int getIoctlRequestValue(DrmIoctl ioctlRequest) override;
};
} // namespace NEO

108
shared/source/os_interface/linux/ioctl_helper_prelim.cpp
View File

@ -33,7 +33,7 @@ bool IoctlHelperPrelim20::isVmBindAvailable(Drm *drm) {
GetParam getParam{};
getParam.param = PRELIM_I915_PARAM_HAS_VM_BIND;
getParam.value = &vmBindSupported;
int retVal = IoctlHelper::ioctl(drm, DRM_IOCTL_I915_GETPARAM, &getParam);
int retVal = IoctlHelper::ioctl(drm, DrmIoctl::Getparam, &getParam);
if (retVal) {
return false;
}
@ -72,7 +72,7 @@ uint32_t IoctlHelperPrelim20::createGemExt(Drm *drm, const MemRegionsVec &memCla
printDebugString(DebugManager.flags.PrintBOCreateDestroyResult.get(), stdout, "%s", " }\n");
}
auto ret = IoctlHelper::ioctl(drm, PRELIM_DRM_IOCTL_I915_GEM_CREATE_EXT, &createExt);
auto ret = IoctlHelper::ioctl(drm, DrmIoctl::GemCreateExt, &createExt);
printDebugString(DebugManager.flags.PrintBOCreateDestroyResult.get(), stdout, "GEM_CREATE_EXT has returned: %d BO-%u with size: %lu\n", ret, createExt.handle, createExt.size);
handle = createExt.handle;
@ -94,7 +94,7 @@ std::vector<MemoryRegion> IoctlHelperPrelim20::translateToMemoryRegions(const st
CacheRegion IoctlHelperPrelim20::closAlloc(Drm *drm) {
struct prelim_drm_i915_gem_clos_reserve clos = {};
int ret = IoctlHelper::ioctl(drm, PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE, &clos);
int ret = IoctlHelper::ioctl(drm, DrmIoctl::GemClosReserve, &clos);
if (ret != 0) {
int err = errno;
printDebugString(DebugManager.flags.PrintDebugMessages.get(), stderr, "ioctl(I915_GEM_CLOS_RESERVE) failed with %d. errno=%d(%s)\n", ret, err, strerror(err));
@ -112,7 +112,7 @@ uint16_t IoctlHelperPrelim20::closAllocWays(Drm *drm, CacheRegion closIndex, uin
cache.cache_level = cacheLevel;
cache.num_ways = numWays;
int ret = IoctlHelper::ioctl(drm, PRELIM_DRM_IOCTL_I915_GEM_CACHE_RESERVE, &cache);
int ret = IoctlHelper::ioctl(drm, DrmIoctl::GemCacheReserve, &cache);
if (ret != 0) {
int err = errno;
PRINT_DEBUG_STRING(DebugManager.flags.PrintDebugMessages.get(), stderr, "ioctl(I915_GEM_CACHE_RESERVE) failed with %d. errno=%d(%s)\n", ret, err, strerror(err));
@ -127,7 +127,7 @@ CacheRegion IoctlHelperPrelim20::closFree(Drm *drm, CacheRegion closIndex) {
clos.clos_index = static_cast<uint16_t>(closIndex);
int ret = IoctlHelper::ioctl(drm, PRELIM_DRM_IOCTL_I915_GEM_CLOS_FREE, &clos);
int ret = IoctlHelper::ioctl(drm, DrmIoctl::GemClosFree, &clos);
if (ret != 0) {
int err = errno;
printDebugString(DebugManager.flags.PrintDebugMessages.get(), stderr, "ioctl(I915_GEM_CLOS_FREE) failed with %d. errno=%d(%s)\n", ret, err, strerror(err));
@ -165,7 +165,7 @@ int IoctlHelperPrelim20::waitUserFence(Drm *drm, uint32_t ctxId, uint64_t addres
wait.value = value;
wait.timeout = timeout;
return IoctlHelper::ioctl(drm, PRELIM_DRM_IOCTL_I915_GEM_WAIT_USER_FENCE, &wait);
return IoctlHelper::ioctl(drm, DrmIoctl::GemWaitUserFence, &wait);
}
uint32_t IoctlHelperPrelim20::getHwConfigIoctlVal() {
@ -189,7 +189,7 @@ bool IoctlHelperPrelim20::setVmBoAdvise(Drm *drm, int32_t handle, uint32_t attri
vmAdvise.region = *reinterpret_cast<prelim_drm_i915_gem_memory_class_instance *>(region);
}
int ret = IoctlHelper::ioctl(drm, PRELIM_DRM_IOCTL_I915_GEM_VM_ADVISE, &vmAdvise);
int ret = IoctlHelper::ioctl(drm, DrmIoctl::GemVmAdvise, &vmAdvise);
if (ret != 0) {
int err = errno;
PRINT_DEBUG_STRING(DebugManager.flags.PrintDebugMessages.get(), stderr, "ioctl(PRELIM_DRM_I915_GEM_VM_ADVISE) failed with %d. errno=%d(%s)\n", ret, err, strerror(err));
@ -206,7 +206,7 @@ bool IoctlHelperPrelim20::setVmPrefetch(Drm *drm, uint64_t start, uint64_t lengt
vmPrefetch.region = region;
vmPrefetch.start = start;
int ret = IoctlHelper::ioctl(drm, PRELIM_DRM_IOCTL_I915_GEM_VM_PREFETCH, &vmPrefetch);
int ret = IoctlHelper::ioctl(drm, DrmIoctl::GemVmPrefetch, &vmPrefetch);
if (ret != 0) {
int err = errno;
PRINT_DEBUG_STRING(DebugManager.flags.PrintDebugMessages.get(), stderr, "ioctl(PRELIM_DRM_I915_GEM_VM_PREFETCH) failed with %d. errno=%d(%s)\n", ret, err, strerror(err));
@ -249,7 +249,7 @@ int IoctlHelperPrelim20::execBuffer(Drm *drm, ExecBuffer *execBuffer, uint64_t c
drmExecBuffer.cliprects_ptr = castToUint64(&fenceObject);
}
return IoctlHelper::ioctl(drm, DRM_IOCTL_I915_GEM_EXECBUFFER2, execBuffer);
return IoctlHelper::ioctl(drm, DrmIoctl::GemExecbuffer2, execBuffer);
}
bool IoctlHelperPrelim20::completionFenceExtensionSupported(const bool isVmBindAvailable) {
@ -324,7 +324,7 @@ uint32_t IoctlHelperPrelim20::queryDistances(Drm *drm, std::vector<QueryItem> &q
Query query{};
query.itemsPtr = reinterpret_cast<__u64>(queryItems.data());
query.numItems = static_cast<uint32_t>(queryItems.size());
auto ret = IoctlHelper::ioctl(drm, DRM_IOCTL_I915_QUERY, &query);
auto ret = IoctlHelper::ioctl(drm, DrmIoctl::Query, &query);
for (auto i = 0u; i < i915Distances.size(); i++) {
distanceInfos[i].distance = i915Distances[i].distance;
}
@ -397,7 +397,7 @@ uint32_t gemCreateContextExt(Drm *drm, GemContextCreateExt &gcc, GemContextCreat
extSetparam.base.nextExtension = gcc.extensions;
gcc.extensions = reinterpret_cast<uint64_t>(&extSetparam);
auto ioctlResult = IoctlHelper::ioctl(drm, DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT, &gcc);
auto ioctlResult = IoctlHelper::ioctl(drm, DrmIoctl::GemContextCreateExt, &gcc);
UNRECOVERABLE_IF(ioctlResult != 0);
return gcc.contextId;
}
@ -496,12 +496,12 @@ prelim_drm_i915_gem_vm_bind translateVmBindParamsToPrelimStruct(const VmBindPara
int IoctlHelperPrelim20::vmBind(Drm *drm, const VmBindParams &vmBindParams) {
auto prelimVmBind = translateVmBindParamsToPrelimStruct(vmBindParams);
return IoctlHelper::ioctl(drm, PRELIM_DRM_IOCTL_I915_GEM_VM_BIND, &prelimVmBind);
return IoctlHelper::ioctl(drm, DrmIoctl::GemVmBind, &prelimVmBind);
}
int IoctlHelperPrelim20::vmUnbind(Drm *drm, const VmBindParams &vmBindParams) {
auto prelimVmBind = translateVmBindParamsToPrelimStruct(vmBindParams);
return IoctlHelper::ioctl(drm, PRELIM_DRM_IOCTL_I915_GEM_VM_UNBIND, &prelimVmBind);
return IoctlHelper::ioctl(drm, DrmIoctl::GemVmUnbind, &prelimVmBind);
}
UuidRegisterResult IoctlHelperPrelim20::registerUuid(Drm *drm, const std::string &uuid, uint32_t uuidClass, uint64_t ptr, uint64_t size) {
@ -511,7 +511,7 @@ UuidRegisterResult IoctlHelperPrelim20::registerUuid(Drm *drm, const std::string
uuidControl.ptr = ptr;
uuidControl.size = size;
const auto retVal = IoctlHelper::ioctl(drm, PRELIM_DRM_IOCTL_I915_UUID_REGISTER, &uuidControl);
const auto retVal = IoctlHelper::ioctl(drm, DrmIoctl::UuidRegister, &uuidControl);
return {
retVal,
@ -527,7 +527,7 @@ int IoctlHelperPrelim20::unregisterUuid(Drm *drm, uint32_t handle) {
prelim_drm_i915_uuid_control uuidControl = {};
uuidControl.handle = handle;
return IoctlHelper::ioctl(drm, PRELIM_DRM_IOCTL_I915_UUID_UNREGISTER, &uuidControl);
return IoctlHelper::ioctl(drm, DrmIoctl::UuidUnregister, &uuidControl);
}
bool IoctlHelperPrelim20::isContextDebugSupported(Drm *drm) {
@ -537,7 +537,7 @@ bool IoctlHelperPrelim20::isContextDebugSupported(Drm *drm) {
ctxParam.ctx_id = 0;
ctxParam.value = 0;
const auto retVal = IoctlHelper::ioctl(drm, DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM, &ctxParam);
const auto retVal = IoctlHelper::ioctl(drm, DrmIoctl::GemContextGetparam, &ctxParam);
return retVal == 0 && ctxParam.value == (PRELIM_I915_CONTEXT_PARAM_DEBUG_FLAG_SIP << 32);
}
@ -548,13 +548,87 @@ int IoctlHelperPrelim20::setContextDebugFlag(Drm *drm, uint32_t drmContextId) {
ctxParam.ctx_id = drmContextId;
ctxParam.value = PRELIM_I915_CONTEXT_PARAM_DEBUG_FLAG_SIP << 32 | PRELIM_I915_CONTEXT_PARAM_DEBUG_FLAG_SIP;
return IoctlHelper::ioctl(drm, DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM, &ctxParam);
return IoctlHelper::ioctl(drm, DrmIoctl::GemContextSetparam, &ctxParam);
}
bool IoctlHelperPrelim20::isDebugAttachAvailable() {
return true;
}
unsigned int IoctlHelperPrelim20::getIoctlRequestValue(DrmIoctl ioctlRequest) {
switch (ioctlRequest) {
case DrmIoctl::GemExecbuffer2:
return DRM_IOCTL_I915_GEM_EXECBUFFER2;
case DrmIoctl::GemWait:
return DRM_IOCTL_I915_GEM_WAIT;
case DrmIoctl::GemClose:
return DRM_IOCTL_GEM_CLOSE;
case DrmIoctl::GemUserptr:
return DRM_IOCTL_I915_GEM_USERPTR;
case DrmIoctl::GemCreate:
return DRM_IOCTL_I915_GEM_CREATE;
case DrmIoctl::GemSetDomain:
return DRM_IOCTL_I915_GEM_SET_DOMAIN;
case DrmIoctl::GemSetTiling:
return DRM_IOCTL_I915_GEM_SET_TILING;
case DrmIoctl::GemGetTiling:
return DRM_IOCTL_I915_GEM_GET_TILING;
case DrmIoctl::GemContextCreateExt:
return DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT;
case DrmIoctl::GemContextDestroy:
return DRM_IOCTL_I915_GEM_CONTEXT_DESTROY;
case DrmIoctl::RegRead:
return DRM_IOCTL_I915_REG_READ;
case DrmIoctl::GetResetStats:
return DRM_IOCTL_I915_GET_RESET_STATS;
case DrmIoctl::GemContextGetparam:
return DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM;
case DrmIoctl::GemContextSetparam:
return DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM;
case DrmIoctl::Query:
return DRM_IOCTL_I915_QUERY;
case DrmIoctl::GemMmap:
return DRM_IOCTL_I915_GEM_MMAP;
case DrmIoctl::PrimeFdToHandle:
return DRM_IOCTL_PRIME_FD_TO_HANDLE;
case DrmIoctl::PrimeHandleToFd:
return DRM_IOCTL_PRIME_HANDLE_TO_FD;
case DrmIoctl::GemVmBind:
return PRELIM_DRM_IOCTL_I915_GEM_VM_BIND;
case DrmIoctl::GemVmUnbind:
return PRELIM_DRM_IOCTL_I915_GEM_VM_UNBIND;
case DrmIoctl::GemWaitUserFence:
return PRELIM_DRM_IOCTL_I915_GEM_WAIT_USER_FENCE;
case DrmIoctl::GemCreateExt:
return PRELIM_DRM_IOCTL_I915_GEM_CREATE_EXT;
case DrmIoctl::GemVmAdvise:
return PRELIM_DRM_IOCTL_I915_GEM_VM_ADVISE;
case DrmIoctl::GemVmPrefetch:
return PRELIM_DRM_IOCTL_I915_GEM_VM_PREFETCH;
case DrmIoctl::UuidRegister:
return PRELIM_DRM_IOCTL_I915_UUID_REGISTER;
case DrmIoctl::UuidUnregister:
return PRELIM_DRM_IOCTL_I915_UUID_UNREGISTER;
case DrmIoctl::DebuggerOpen:
return PRELIM_DRM_IOCTL_I915_DEBUGGER_OPEN;
case DrmIoctl::GemClosReserve:
return PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE;
case DrmIoctl::GemClosFree:
return PRELIM_DRM_IOCTL_I915_GEM_CLOS_FREE;
case DrmIoctl::GemCacheReserve:
return PRELIM_DRM_IOCTL_I915_GEM_CACHE_RESERVE;
case DrmIoctl::GemMmapOffset:
return DRM_IOCTL_I915_GEM_MMAP_OFFSET;
case DrmIoctl::GemVmCreate:
return DRM_IOCTL_I915_GEM_VM_CREATE;
case DrmIoctl::GemVmDestroy:
return DRM_IOCTL_I915_GEM_VM_DESTROY;
default:
UNRECOVERABLE_IF(true);
return 0u;
}
}
static_assert(sizeof(MemoryClassInstance) == sizeof(prelim_drm_i915_gem_memory_class_instance));
static_assert(offsetof(MemoryClassInstance, memoryClass) == offsetof(prelim_drm_i915_gem_memory_class_instance, memory_class));
static_assert(offsetof(MemoryClassInstance, memoryInstance) == offsetof(prelim_drm_i915_gem_memory_class_instance, memory_instance));

55
shared/source/os_interface/linux/ioctl_helper_upstream.cpp
View File

@ -51,7 +51,7 @@ uint32_t IoctlHelperUpstream::createGemExt(Drm *drm, const MemRegionsVec &memCla
printDebugString(DebugManager.flags.PrintBOCreateDestroyResult.get(), stdout, "%s", " }\n");
}
auto ret = ioctl(drm, DRM_IOCTL_I915_GEM_CREATE_EXT, &createExt);
auto ret = ioctl(drm, DrmIoctl::GemCreateExt, &createExt);
printDebugString(DebugManager.flags.PrintBOCreateDestroyResult.get(), stdout, "GEM_CREATE_EXT with EXT_MEMORY_REGIONS has returned: %d BO-%u with size: %lu\n", ret, createExt.handle, createExt.size);
handle = createExt.handle;
@ -161,7 +161,7 @@ uint16_t IoctlHelperUpstream::getWaitUserFenceSoftFlag() {
}
int IoctlHelperUpstream::execBuffer(Drm *drm, ExecBuffer *execBuffer, uint64_t completionGpuAddress, uint32_t counterValue) {
return ioctl(drm, DRM_IOCTL_I915_GEM_EXECBUFFER2, execBuffer);
return ioctl(drm, DrmIoctl::GemExecbuffer2, execBuffer);
}
bool IoctlHelperUpstream::completionFenceExtensionSupported(const bool isVmBindAvailable) {
@ -244,4 +244,55 @@ bool IoctlHelperUpstream::isDebugAttachAvailable() {
return false;
}
unsigned int IoctlHelperUpstream::getIoctlRequestValue(DrmIoctl ioctlRequest) {
switch (ioctlRequest) {
case DrmIoctl::GemExecbuffer2:
return DRM_IOCTL_I915_GEM_EXECBUFFER2;
case DrmIoctl::GemWait:
return DRM_IOCTL_I915_GEM_WAIT;
case DrmIoctl::GemClose:
return DRM_IOCTL_GEM_CLOSE;
case DrmIoctl::GemUserptr:
return DRM_IOCTL_I915_GEM_USERPTR;
case DrmIoctl::GemCreate:
return DRM_IOCTL_I915_GEM_CREATE;
case DrmIoctl::GemCreateExt:
return DRM_IOCTL_I915_GEM_CREATE_EXT;
case DrmIoctl::GemSetDomain:
return DRM_IOCTL_I915_GEM_SET_DOMAIN;
case DrmIoctl::GemSetTiling:
return DRM_IOCTL_I915_GEM_SET_TILING;
case DrmIoctl::GemGetTiling:
return DRM_IOCTL_I915_GEM_GET_TILING;
case DrmIoctl::GemContextCreateExt:
return DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT;
case DrmIoctl::GemContextDestroy:
return DRM_IOCTL_I915_GEM_CONTEXT_DESTROY;
case DrmIoctl::RegRead:
return DRM_IOCTL_I915_REG_READ;
case DrmIoctl::GetResetStats:
return DRM_IOCTL_I915_GET_RESET_STATS;
case DrmIoctl::GemContextGetparam:
return DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM;
case DrmIoctl::GemContextSetparam:
return DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM;
case DrmIoctl::Query:
return DRM_IOCTL_I915_QUERY;
case DrmIoctl::GemMmap:
return DRM_IOCTL_I915_GEM_MMAP;
case DrmIoctl::PrimeFdToHandle:
return DRM_IOCTL_PRIME_FD_TO_HANDLE;
case DrmIoctl::PrimeHandleToFd:
return DRM_IOCTL_PRIME_HANDLE_TO_FD;
case DrmIoctl::GemMmapOffset:
return DRM_IOCTL_I915_GEM_MMAP_OFFSET;
case DrmIoctl::GemVmCreate:
return DRM_IOCTL_I915_GEM_VM_CREATE;
case DrmIoctl::GemVmDestroy:
return DRM_IOCTL_I915_GEM_VM_DESTROY;
default:
UNRECOVERABLE_IF(true);
return 0u;
}
}
} // namespace NEO

5
shared/source/os_interface/linux/ioctl_strings.h
View File

@ -7,13 +7,14 @@
#pragma once
#include "shared/source/os_interface/linux/drm_wrappers.h"
#include <string>
namespace NEO {
namespace IoctlToStringHelper {
std::string getIoctlParamString(int param);
std::string getIoctlParamStringRemaining(int param);
std::string getIoctlString(unsigned long request);
std::string getIoctlStringRemaining(unsigned long request);
std::string getIoctlString(DrmIoctl ioctlRequest);
} // namespace IoctlToStringHelper
} // namespace NEO

39
shared/source/os_interface/linux/ioctl_strings_prelim.cpp
View File

@ -13,45 +13,6 @@
namespace NEO {
namespace IoctlToStringHelper {
std::string getIoctlStringRemaining(unsigned long request) {
switch (request) {
case PRELIM_DRM_IOCTL_I915_GEM_VM_BIND:
return "PRELIM_DRM_IOCTL_I915_GEM_VM_BIND";
case PRELIM_DRM_IOCTL_I915_GEM_VM_UNBIND:
return "PRELIM_DRM_IOCTL_I915_GEM_VM_UNBIND";
case PRELIM_DRM_IOCTL_I915_GEM_WAIT_USER_FENCE:
return "PRELIM_DRM_IOCTL_I915_GEM_WAIT_USER_FENCE";
case PRELIM_DRM_IOCTL_I915_GEM_CREATE_EXT:
return "PRELIM_DRM_IOCTL_I915_GEM_CREATE_EXT";
case PRELIM_DRM_IOCTL_I915_GEM_VM_ADVISE:
return "PRELIM_DRM_IOCTL_I915_GEM_VM_ADVISE";
case PRELIM_DRM_IOCTL_I915_GEM_VM_PREFETCH:
return "PRELIM_DRM_IOCTL_I915_GEM_VM_PREFETCH";
case PRELIM_DRM_IOCTL_I915_UUID_REGISTER:
return "PRELIM_DRM_IOCTL_I915_UUID_REGISTER";
case PRELIM_DRM_IOCTL_I915_UUID_UNREGISTER:
return "PRELIM_DRM_IOCTL_I915_UUID_UNREGISTER";
case PRELIM_DRM_IOCTL_I915_DEBUGGER_OPEN:
return "PRELIM_DRM_IOCTL_I915_DEBUGGER_OPEN";
case PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE:
return "PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE";
case PRELIM_DRM_IOCTL_I915_GEM_CLOS_FREE:
return "PRELIM_DRM_IOCTL_I915_GEM_CLOS_FREE";
case PRELIM_DRM_IOCTL_I915_GEM_CACHE_RESERVE:
return "PRELIM_DRM_IOCTL_I915_GEM_CACHE_RESERVE";
case DRM_IOCTL_I915_GEM_MMAP_GTT:
return "DRM_IOCTL_I915_GEM_MMAP_GTT";
case DRM_IOCTL_I915_GEM_MMAP_OFFSET:
return "DRM_IOCTL_I915_GEM_MMAP_OFFSET";
case DRM_IOCTL_I915_GEM_VM_CREATE:
return "DRM_IOCTL_I915_GEM_VM_CREATE";
case DRM_IOCTL_I915_GEM_VM_DESTROY:
return "DRM_IOCTL_I915_GEM_VM_DESTROY";
default:
return std::to_string(request);
}
}
std::string getIoctlParamStringRemaining(int param) {
switch (param) {
case PRELIM_I915_PARAM_HAS_VM_BIND:

4
shared/source/os_interface/linux/ioctl_strings_upstream.cpp
View File

@ -10,10 +10,6 @@
namespace NEO {
namespace IoctlToStringHelper {
std::string getIoctlStringRemaining(unsigned long request) {
return std::to_string(request);
}
std::string getIoctlParamStringRemaining(int param) {
return std::to_string(param);
}

12
shared/source/os_interface/linux/local/dg1/ioctl_helper_dg1.cpp
View File

@ -50,7 +50,7 @@ uint32_t IoctlHelperImpl<gfxProduct>::createGemExt(Drm *drm, const MemRegionsVec
createExt.size = allocSize;
createExt.extensions = reinterpret_cast<uintptr_t>(&setparamRegion);
ret = IoctlHelper::ioctl(drm, DRM_IOCTL_I915_GEM_CREATE_EXT, &createExt);
ret = IoctlHelper::ioctl(drm, DrmIoctl::DG1GemCreateExt, &createExt);
handle = createExt.handle;
printDebugString(DebugManager.flags.PrintBOCreateDestroyResult.get(), stdout, "GEM_CREATE_EXT with EXT_SETPARAM has returned: %d BO-%u with size: %lu\n", ret, createExt.handle, createExt.size);
@ -66,5 +66,15 @@ std::vector<MemoryRegion> IoctlHelperImpl<gfxProduct>::translateToMemoryRegions(
return IoctlHelperUpstream::translateToMemoryRegions(regionInfo);
}
template <>
unsigned int IoctlHelperImpl<gfxProduct>::getIoctlRequestValue(DrmIoctl ioctlRequest) {
switch (ioctlRequest) {
case DrmIoctl::DG1GemCreateExt:
return DRM_IOCTL_I915_GEM_CREATE_EXT;
default:
return IoctlHelperUpstream::getIoctlRequestValue(ioctlRequest);
}
}
template class IoctlHelperImpl<gfxProduct>;
} // namespace NEO

108
shared/test/common/libult/linux/drm_mock.cpp
View File

@ -17,11 +17,11 @@
const int DrmMock::mockFd;
const uint32_t DrmMockResources::registerResourceReturnHandle = 3;
int DrmMock::ioctl(unsigned long request, void *arg) {
int DrmMock::ioctl(DrmIoctl request, void *arg) {
ioctlCallsCount++;
ioctlCount.total++;
if ((request == DRM_IOCTL_I915_GETPARAM) && (arg != nullptr)) {
if ((request == DrmIoctl::Getparam) && (arg != nullptr)) {
ioctlCount.contextGetParam++;
auto gp = static_cast<GetParam *>(arg);
if (gp->param == I915_PARAM_EU_TOTAL) {
@ -74,7 +74,7 @@ int DrmMock::ioctl(unsigned long request, void *arg) {
}
}
if ((request == DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT) && (arg != nullptr)) {
if ((request == DrmIoctl::GemContextCreateExt) && (arg != nullptr)) {
ioctlCount.contextCreate++;
auto create = static_cast<GemContextCreateExt *>(arg);
create->contextId = this->storedDrmContextId;
@ -92,14 +92,14 @@ int DrmMock::ioctl(unsigned long request, void *arg) {
}
}
if ((request == DRM_IOCTL_I915_GEM_CONTEXT_DESTROY) && (arg != nullptr)) {
if ((request == DrmIoctl::GemContextDestroy) && (arg != nullptr)) {
ioctlCount.contextDestroy++;
auto destroy = static_cast<GemContextDestroy *>(arg);
this->receivedDestroyContextId = destroy->contextId;
return this->storedRetVal;
}
if ((request == DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM) && (arg != nullptr)) {
if ((request == DrmIoctl::GemContextSetparam) && (arg != nullptr)) {
ioctlCount.contextSetParam++;
receivedContextParamRequestCount++;
receivedContextParamRequest = *static_cast<GemContextParam *>(arg);
@ -127,7 +127,7 @@ int DrmMock::ioctl(unsigned long request, void *arg) {
}
}
if ((request == DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM) && (arg != nullptr)) {
if ((request == DrmIoctl::GemContextGetparam) && (arg != nullptr)) {
ioctlCount.contextGetParam++;
receivedContextParamRequestCount++;
receivedContextParamRequest = *static_cast<GemContextParam *>(arg);
@ -152,7 +152,7 @@ int DrmMock::ioctl(unsigned long request, void *arg) {
}
}
if (request == DRM_IOCTL_I915_GEM_EXECBUFFER2) {
if (request == DrmIoctl::GemExecbuffer2) {
ioctlCount.execbuffer2++;
auto execbuf = static_cast<NEO::MockExecBuffer *>(arg);
auto execObjects = reinterpret_cast<const MockExecObject *>(execbuf->getBuffersPtr());
@ -162,14 +162,14 @@ int DrmMock::ioctl(unsigned long request, void *arg) {
}
return 0;
}
if (request == DRM_IOCTL_I915_GEM_USERPTR) {
if (request == DrmIoctl::GemUserptr) {
ioctlCount.gemUserptr++;
auto userPtrParams = static_cast<NEO::GemUserPtr *>(arg);
userPtrParams->handle = returnHandle;
returnHandle++;
return 0;
}
if (request == DRM_IOCTL_I915_GEM_CREATE) {
if (request == DrmIoctl::GemCreate) {
ioctlCount.gemCreate++;
auto createParams = static_cast<NEO::GemCreate *>(arg);
this->createParamsSize = createParams->size;
@ -179,7 +179,7 @@ int DrmMock::ioctl(unsigned long request, void *arg) {
}
return 0;
}
if (request == DRM_IOCTL_I915_GEM_SET_TILING) {
if (request == DrmIoctl::GemSetTiling) {
ioctlCount.gemSetTiling++;
auto setTilingParams = static_cast<NEO::GemSetTiling *>(arg);
setTilingMode = setTilingParams->tilingMode;
@ -187,7 +187,7 @@ int DrmMock::ioctl(unsigned long request, void *arg) {
setTilingStride = setTilingParams->stride;
return 0;
}
if (request == DRM_IOCTL_PRIME_FD_TO_HANDLE) {
if (request == DrmIoctl::PrimeFdToHandle) {
ioctlCount.primeFdToHandle++;
auto primeToHandleParams = static_cast<PrimeHandle *>(arg);
//return BO
@ -195,35 +195,28 @@ int DrmMock::ioctl(unsigned long request, void *arg) {
inputFd = primeToHandleParams->fileDescriptor;
return fdToHandleRetVal;
}
if (request == DRM_IOCTL_PRIME_HANDLE_TO_FD) {
if (request == DrmIoctl::PrimeHandleToFd) {
ioctlCount.handleToPrimeFd++;
auto primeToFdParams = static_cast<PrimeHandle *>(arg);
primeToFdParams->fileDescriptor = outputFd;
return 0;
}
if (request == DRM_IOCTL_I915_GEM_GET_APERTURE) {
ioctlCount.gemGetAperture++;
auto aperture = static_cast<drm_i915_gem_get_aperture *>(arg);
aperture->aper_available_size = gpuMemSize;
aperture->aper_size = gpuMemSize;
return 0;
}
if (request == DRM_IOCTL_I915_GEM_MMAP) {
if (request == DrmIoctl::GemMmap) {
ioctlCount.gemMmap++;
auto mmapArg = static_cast<GemMmap *>(arg);
mmapArg->addrPtr = reinterpret_cast<uint64_t>(lockedPtr);
return 0;
}
if (request == DRM_IOCTL_I915_GEM_WAIT) {
if (request == DrmIoctl::GemWait) {
ioctlCount.gemWait++;
receivedGemWait = *static_cast<GemWait *>(arg);
return 0;
}
if (request == DRM_IOCTL_GEM_CLOSE) {
if (request == DrmIoctl::GemClose) {
ioctlCount.gemClose++;
return storedRetValForGemClose;
}
if (request == DRM_IOCTL_I915_GET_RESET_STATS && arg != nullptr) {
if (request == DrmIoctl::GetResetStats && arg != nullptr) {
ioctlCount.gemResetStats++;
auto outResetStats = static_cast<ResetStats *>(arg);
for (const auto &resetStats : resetStatsToReturn) {
@ -236,7 +229,7 @@ int DrmMock::ioctl(unsigned long request, void *arg) {
return -1;
}
if (request == DRM_IOCTL_I915_QUERY && arg != nullptr) {
if (request == DrmIoctl::Query && arg != nullptr) {
ioctlCount.query++;
auto queryArg = static_cast<Query *>(arg);
auto queryItemArg = reinterpret_cast<QueryItem *>(queryArg->itemsPtr);
@ -277,8 +270,8 @@ int DrmMock::waitUserFence(uint32_t ctxIdx, uint64_t address, uint64_t value, Va
waitUserFenceParams.push_back({ctxIdx, address, value, dataWidth, timeout, flags});
return Drm::waitUserFence(ctxIdx, address, value, dataWidth, timeout, flags);
}
int DrmMockEngine::handleRemainingRequests(unsigned long request, void *arg) {
if ((request == DRM_IOCTL_I915_QUERY) && (arg != nullptr)) {
int DrmMockEngine::handleRemainingRequests(DrmIoctl request, void *arg) {
if ((request == DrmIoctl::Query) && (arg != nullptr)) {
if (i915QuerySuccessCount == 0) {
return EINVAL;
}
@ -295,69 +288,6 @@ int DrmMockEngine::handleRemainingRequests(unsigned long request, void *arg) {
return -1;
}
std::map<unsigned long, const char *> ioctlCodeStringMap = {
{DRM_IOCTL_I915_INIT, "DRM_IOCTL_I915_INIT"},
{DRM_IOCTL_I915_FLUSH, "DRM_IOCTL_I915_FLUSH"},
{DRM_IOCTL_I915_FLIP, "DRM_IOCTL_I915_FLIP"},
{DRM_IOCTL_GEM_CLOSE, "DRM_IOCTL_GEM_CLOSE"},
{DRM_IOCTL_I915_BATCHBUFFER, "DRM_IOCTL_I915_BATCHBUFFER"},
{DRM_IOCTL_I915_IRQ_EMIT, "DRM_IOCTL_I915_IRQ_EMIT"},
{DRM_IOCTL_I915_IRQ_WAIT, "DRM_IOCTL_I915_IRQ_WAIT"},
{DRM_IOCTL_I915_GETPARAM, "DRM_IOCTL_I915_GETPARAM"},
{DRM_IOCTL_I915_SETPARAM, "DRM_IOCTL_I915_SETPARAM"},
{DRM_IOCTL_I915_ALLOC, "DRM_IOCTL_I915_ALLOC"},
{DRM_IOCTL_I915_FREE, "DRM_IOCTL_I915_FREE"},
{DRM_IOCTL_I915_INIT_HEAP, "DRM_IOCTL_I915_INIT_HEAP"},
{DRM_IOCTL_I915_CMDBUFFER, "DRM_IOCTL_I915_CMDBUFFER"},
{DRM_IOCTL_I915_DESTROY_HEAP, "DRM_IOCTL_I915_DESTROY_HEAP"},
{DRM_IOCTL_I915_SET_VBLANK_PIPE, "DRM_IOCTL_I915_SET_VBLANK_PIPE"},
{DRM_IOCTL_I915_GET_VBLANK_PIPE, "DRM_IOCTL_I915_GET_VBLANK_PIPE"},
{DRM_IOCTL_I915_VBLANK_SWAP, "DRM_IOCTL_I915_VBLANK_SWAP"},
{DRM_IOCTL_I915_HWS_ADDR, "DRM_IOCTL_I915_HWS_ADDR"},
{DRM_IOCTL_I915_GEM_INIT, "DRM_IOCTL_I915_GEM_INIT"},
{DRM_IOCTL_I915_GEM_EXECBUFFER, "DRM_IOCTL_I915_GEM_EXECBUFFER"},
{DRM_IOCTL_I915_GEM_EXECBUFFER2, "DRM_IOCTL_I915_GEM_EXECBUFFER2"},
{DRM_IOCTL_I915_GEM_EXECBUFFER2_WR, "DRM_IOCTL_I915_GEM_EXECBUFFER2_WR"},
{DRM_IOCTL_I915_GEM_PIN, "DRM_IOCTL_I915_GEM_PIN"},
{DRM_IOCTL_I915_GEM_UNPIN, "DRM_IOCTL_I915_GEM_UNPIN"},
{DRM_IOCTL_I915_GEM_BUSY, "DRM_IOCTL_I915_GEM_BUSY"},
{DRM_IOCTL_I915_GEM_SET_CACHING, "DRM_IOCTL_I915_GEM_SET_CACHING"},
{DRM_IOCTL_I915_GEM_GET_CACHING, "DRM_IOCTL_I915_GEM_GET_CACHING"},
{DRM_IOCTL_I915_GEM_THROTTLE, "DRM_IOCTL_I915_GEM_THROTTLE"},
{DRM_IOCTL_I915_GEM_ENTERVT, "DRM_IOCTL_I915_GEM_ENTERVT"},
{DRM_IOCTL_I915_GEM_LEAVEVT, "DRM_IOCTL_I915_GEM_LEAVEVT"},
{DRM_IOCTL_I915_GEM_CREATE, "DRM_IOCTL_I915_GEM_CREATE"},
{DRM_IOCTL_I915_GEM_PREAD, "DRM_IOCTL_I915_GEM_PREAD"},
{DRM_IOCTL_I915_GEM_PWRITE, "DRM_IOCTL_I915_GEM_PWRITE"},
{DRM_IOCTL_I915_GEM_SET_DOMAIN, "DRM_IOCTL_I915_GEM_SET_DOMAIN"},
{DRM_IOCTL_I915_GEM_SW_FINISH, "DRM_IOCTL_I915_GEM_SW_FINISH"},
{DRM_IOCTL_I915_GEM_SET_TILING, "DRM_IOCTL_I915_GEM_SET_TILING"},
{DRM_IOCTL_I915_GEM_GET_TILING, "DRM_IOCTL_I915_GEM_GET_TILING"},
{DRM_IOCTL_I915_GEM_GET_APERTURE, "DRM_IOCTL_I915_GEM_GET_APERTURE"},
{DRM_IOCTL_I915_GET_PIPE_FROM_CRTC_ID, "DRM_IOCTL_I915_GET_PIPE_FROM_CRTC_ID"},
{DRM_IOCTL_I915_GEM_MADVISE, "DRM_IOCTL_I915_GEM_MADVISE"},
{DRM_IOCTL_I915_OVERLAY_PUT_IMAGE, "DRM_IOCTL_I915_OVERLAY_PUT_IMAGE"},
{DRM_IOCTL_I915_OVERLAY_ATTRS, "DRM_IOCTL_I915_OVERLAY_ATTRS"},
{DRM_IOCTL_I915_SET_SPRITE_COLORKEY, "DRM_IOCTL_I915_SET_SPRITE_COLORKEY"},
{DRM_IOCTL_I915_GET_SPRITE_COLORKEY, "DRM_IOCTL_I915_GET_SPRITE_COLORKEY"},
{DRM_IOCTL_I915_GEM_WAIT, "DRM_IOCTL_I915_GEM_WAIT"},
{DRM_IOCTL_I915_GEM_CONTEXT_CREATE, "DRM_IOCTL_I915_GEM_CONTEXT_CREATE"},
{DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT, "DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT"},
{DRM_IOCTL_I915_GEM_CONTEXT_DESTROY, "DRM_IOCTL_I915_GEM_CONTEXT_DESTROY"},
{DRM_IOCTL_I915_REG_READ, "DRM_IOCTL_I915_REG_READ"},
{DRM_IOCTL_I915_GET_RESET_STATS, "DRM_IOCTL_I915_GET_RESET_STATS"},
{DRM_IOCTL_I915_GEM_USERPTR, "DRM_IOCTL_I915_GEM_USERPTR"},
{DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM, "DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM"},
{DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM, "DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM"},
{DRM_IOCTL_I915_PERF_OPEN, "DRM_IOCTL_I915_PERF_OPEN"},
{DRM_IOCTL_I915_PERF_ADD_CONFIG, "DRM_IOCTL_I915_PERF_ADD_CONFIG"},
{DRM_IOCTL_I915_PERF_REMOVE_CONFIG, "DRM_IOCTL_I915_PERF_REMOVE_CONFIG"},
{DRM_IOCTL_I915_QUERY, "DRM_IOCTL_I915_QUERY"},
{DRM_IOCTL_I915_GEM_MMAP, "DRM_IOCTL_I915_GEM_MMAP"},
{DRM_IOCTL_PRIME_FD_TO_HANDLE, "DRM_IOCTL_PRIME_FD_TO_HANDLE"},
{DRM_IOCTL_PRIME_HANDLE_TO_FD, "DRM_IOCTL_PRIME_HANDLE_TO_FD"},
{static_cast<unsigned long>(101010101), "101010101"}};
std::map<int, const char *> ioctlParamCodeStringMap = {
{I915_PARAM_CHIPSET_ID, "I915_PARAM_CHIPSET_ID"},
{I915_PARAM_REVISION, "I915_PARAM_REVISION"},

12
shared/test/common/libult/linux/drm_mock.h
View File

@ -74,7 +74,7 @@ class DrmMock : public Drm {
}
}
int ioctl(unsigned long request, void *arg) override;
int ioctl(DrmIoctl request, void *arg) override;
int getErrno() override {
if (baseErrno) {
return Drm::getErrno();
@ -249,7 +249,7 @@ class DrmMock : public Drm {
bool expectIoctlCallsOnDestruction = false;
uint32_t expectedIoctlCallsOnDestruction = 0u;
virtual int handleRemainingRequests(unsigned long request, void *arg) { return -1; }
virtual int handleRemainingRequests(DrmIoctl request, void *arg) { return -1; }
struct WaitUserFenceParams {
uint32_t ctxId;
@ -265,14 +265,14 @@ class DrmMock : public Drm {
class DrmMockNonFailing : public DrmMock {
public:
using DrmMock::DrmMock;
int handleRemainingRequests(unsigned long request, void *arg) override { return 0; }
int handleRemainingRequests(DrmIoctl request, void *arg) override { return 0; }
};
class DrmMockReturnErrorNotSupported : public DrmMock {
public:
using DrmMock::DrmMock;
int ioctl(unsigned long request, void *arg) override {
if (request == DRM_IOCTL_I915_GEM_EXECBUFFER2) {
int ioctl(DrmIoctl request, void *arg) override {
if (request == DrmIoctl::GemExecbuffer2) {
return -1;
}
return 0;
@ -289,7 +289,7 @@ class DrmMockEngine : public DrmMock {
rootDeviceEnvironment.setHwInfo(defaultHwInfo.get());
}
int handleRemainingRequests(unsigned long request, void *arg) override;
int handleRemainingRequests(DrmIoctl request, void *arg) override;
void handleQueryItem(QueryItem *queryItem);
bool failQueryDeviceBlob = false;

34
shared/test/common/libult/linux/drm_mock_prelim_context.cpp
View File

@ -37,9 +37,9 @@ constexpr std::array<uint64_t, 9> copyEnginesCapsMap = {{
} // namespace
int DrmMockPrelimContext::handlePrelimRequest(unsigned long request, void *arg) {
int DrmMockPrelimContext::handlePrelimRequest(DrmIoctl request, void *arg) {
switch (request) {
case DRM_IOCTL_I915_GETPARAM: {
case DrmIoctl::Getparam: {
auto gp = static_cast<GetParam *>(arg);
if (gp->param == PRELIM_I915_PARAM_HAS_PAGE_FAULT) {
*gp->value = hasPageFaultQueryValue;
@ -50,14 +50,14 @@ int DrmMockPrelimContext::handlePrelimRequest(unsigned long request, void *arg)
return vmBindQueryReturn;
}
} break;
case DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM: {
case DrmIoctl::GemContextGetparam: {
auto gp = static_cast<GemContextParam *>(arg);
if (gp->param == PRELIM_I915_CONTEXT_PARAM_DEBUG_FLAGS) {
gp->value = contextDebugSupported ? PRELIM_I915_CONTEXT_PARAM_DEBUG_FLAG_SIP << 32 : 0;
return 0;
}
} break;
case DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT: {
case DrmIoctl::GemContextCreateExt: {
auto create = static_cast<GemContextCreateExt *>(arg);
auto setParam = reinterpret_cast<GemContextCreateExtSetParam *>(create->extensions);
if (setParam->param.param == PRELIM_I915_CONTEXT_PARAM_ACC) {
@ -68,12 +68,12 @@ int DrmMockPrelimContext::handlePrelimRequest(unsigned long request, void *arg)
}
return 0;
} break;
case DRM_IOCTL_I915_GEM_MMAP_OFFSET: {
case DrmIoctl::GemMmapOffset: {
auto mmapArg = static_cast<GemMmapOffset *>(arg);
mmapArg->offset = 0;
return mmapOffsetReturn;
} break;
case PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE: {
case DrmIoctl::GemClosReserve: {
auto closReserveArg = static_cast<prelim_drm_i915_gem_clos_reserve *>(arg);
closIndex++;
if (closIndex == 0) {
@ -82,7 +82,7 @@ int DrmMockPrelimContext::handlePrelimRequest(unsigned long request, void *arg)
closReserveArg->clos_index = closIndex;
return 0;
} break;
case PRELIM_DRM_IOCTL_I915_GEM_CLOS_FREE: {
case DrmIoctl::GemClosFree: {
auto closFreeArg = static_cast<prelim_drm_i915_gem_clos_free *>(arg);
if (closFreeArg->clos_index > closIndex) {
return EINVAL;
@ -90,7 +90,7 @@ int DrmMockPrelimContext::handlePrelimRequest(unsigned long request, void *arg)
closIndex--;
return 0;
} break;
case PRELIM_DRM_IOCTL_I915_GEM_CACHE_RESERVE: {
case DrmIoctl::GemCacheReserve: {
auto cacheReserveArg = static_cast<prelim_drm_i915_gem_cache_reserve *>(arg);
if (cacheReserveArg->clos_index > closIndex) {
return EINVAL;
@ -106,7 +106,7 @@ int DrmMockPrelimContext::handlePrelimRequest(unsigned long request, void *arg)
allocNumWays += cacheReserveArg->num_ways;
return 0;
} break;
case PRELIM_DRM_IOCTL_I915_GEM_VM_BIND: {
case DrmIoctl::GemVmBind: {
vmBindCalled++;
const auto vmBind = reinterpret_cast<prelim_drm_i915_gem_vm_bind *>(arg);
receivedVmBind = VmBindParams{
@ -121,7 +121,7 @@ int DrmMockPrelimContext::handlePrelimRequest(unsigned long request, void *arg)
storeVmBindExtensions(vmBind->extensions, true);
return vmBindReturn;
} break;
case PRELIM_DRM_IOCTL_I915_GEM_VM_UNBIND: {
case DrmIoctl::GemVmUnbind: {
vmUnbindCalled++;
const auto vmBind = reinterpret_cast<prelim_drm_i915_gem_vm_bind *>(arg);
receivedVmUnbind = VmBindParams{
@ -136,7 +136,7 @@ int DrmMockPrelimContext::handlePrelimRequest(unsigned long request, void *arg)
storeVmBindExtensions(vmBind->extensions, false);
return vmUnbindReturn;
} break;
case PRELIM_DRM_IOCTL_I915_GEM_CREATE_EXT: {
case DrmIoctl::GemCreateExt: {
auto createExt = static_cast<prelim_drm_i915_gem_create_ext *>(arg);
if (createExt->size == 0) {
return EINVAL;
@ -178,7 +178,7 @@ int DrmMockPrelimContext::handlePrelimRequest(unsigned long request, void *arg)
return gemCreateExtReturn;
} break;
case PRELIM_DRM_IOCTL_I915_GEM_WAIT_USER_FENCE: {
case DrmIoctl::GemWaitUserFence: {
waitUserFenceCalled++;
const auto wait = reinterpret_cast<prelim_drm_i915_gem_wait_user_fence *>(arg);
receivedWaitUserFence = WaitUserFence{
@ -193,7 +193,7 @@ int DrmMockPrelimContext::handlePrelimRequest(unsigned long request, void *arg)
};
return 0;
} break;
case DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM: {
case DrmIoctl::GemContextSetparam: {
const auto req = reinterpret_cast<GemContextParam *>(arg);
if (req->param == PRELIM_I915_CONTEXT_PARAM_DEBUG_FLAGS) {
receivedSetContextParamValue = req->value;
@ -202,12 +202,12 @@ int DrmMockPrelimContext::handlePrelimRequest(unsigned long request, void *arg)
return !contextDebugSupported ? EINVAL : 0;
} break;
case PRELIM_DRM_IOCTL_I915_GEM_VM_ADVISE: {
case DrmIoctl::GemVmAdvise: {
const auto req = reinterpret_cast<prelim_drm_i915_gem_vm_advise *>(arg);
receivedVmAdvise = VmAdvise{req->handle, req->attribute};
return vmAdviseReturn;
} break;
case PRELIM_DRM_IOCTL_I915_UUID_REGISTER: {
case DrmIoctl::UuidRegister: {
auto uuidControl = reinterpret_cast<prelim_drm_i915_uuid_control *>(arg);
if (uuidControl->uuid_class != uint32_t(PRELIM_I915_UUID_CLASS_STRING) && uuidControl->uuid_class > uuidHandle) {
@ -228,7 +228,7 @@ int DrmMockPrelimContext::handlePrelimRequest(unsigned long request, void *arg)
memcpy_s(receivedRegisterUuid->uuid, sizeof(receivedRegisterUuid->uuid), uuidControl->uuid, sizeof(uuidControl->uuid));
return uuidControlReturn;
} break;
case PRELIM_DRM_IOCTL_I915_UUID_UNREGISTER: {
case DrmIoctl::UuidUnregister: {
auto uuidControl = reinterpret_cast<prelim_drm_i915_uuid_control *>(arg);
receivedUnregisterUuid = UuidControl{
{},
@ -243,7 +243,7 @@ int DrmMockPrelimContext::handlePrelimRequest(unsigned long request, void *arg)
return uuidControlReturn;
} break;
case PRELIM_DRM_IOCTL_I915_DEBUGGER_OPEN: {
case DrmIoctl::DebuggerOpen: {
auto debuggerOpen = reinterpret_cast<prelim_drm_i915_debugger_open_param *>(arg);
if (debuggerOpen->pid != 0 && debuggerOpen->events == 0) {
return debuggerOpenRetval;

2
shared/test/common/libult/linux/drm_mock_prelim_context.h
View File

@ -138,7 +138,7 @@ struct DrmMockPrelimContext {
// Debugger ioctls
int debuggerOpenRetval = 10; // debugFd
int handlePrelimRequest(unsigned long request, void *arg);
int handlePrelimRequest(DrmIoctl request, void *arg);
bool handlePrelimQueryItem(void *arg);
void storeVmBindExtensions(uint64_t ptr, bool bind);
};

6
shared/test/common/libult/linux/drm_query_mock.cpp
View File

@ -11,8 +11,8 @@
#include "gtest/gtest.h"
int DrmQueryMock::handleRemainingRequests(unsigned long request, void *arg) {
if (request == DRM_IOCTL_I915_QUERY && arg) {
int DrmQueryMock::handleRemainingRequests(DrmIoctl request, void *arg) {
if (request == DrmIoctl::Query && arg) {
if (i915QuerySuccessCount == 0) {
return EINVAL;
}
@ -31,7 +31,7 @@ int DrmQueryMock::handleRemainingRequests(unsigned long request, void *arg) {
}
return 0;
} else if (request == DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM && receivedContextParamRequest.param == I915_CONTEXT_PARAM_ENGINES) {
} else if (request == DrmIoctl::GemContextSetparam && receivedContextParamRequest.param == I915_CONTEXT_PARAM_ENGINES) {
EXPECT_LE(receivedContextParamRequest.size, sizeof(receivedContextParamEngines));
memcpy(&receivedContextParamEngines, reinterpret_cast<const void *>(receivedContextParamRequest.value), receivedContextParamRequest.size);
auto srcBalancer = reinterpret_cast<const i915_context_engines_load_balance *>(receivedContextParamEngines.extensions);

2
shared/test/common/libult/linux/drm_query_mock.h
View File

@ -55,6 +55,6 @@ class DrmQueryMock : public DrmMock {
uint32_t i915QuerySuccessCount = std::numeric_limits<uint32_t>::max();
int storedRetValForSetParamEngines{0};
int handleRemainingRequests(unsigned long request, void *arg) override;
int handleRemainingRequests(DrmIoctl request, void *arg) override;
virtual bool handleQueryItem(void *queryItem);
};

38
shared/test/common/os_interface/linux/device_command_stream_fixture.cpp
View File

@ -63,12 +63,12 @@ void DrmMockCustom::testIoctls() {
#undef NEO_IOCTL_EXPECT_EQ
}
int DrmMockCustom::ioctl(unsigned long request, void *arg) {
int DrmMockCustom::ioctl(DrmIoctl request, void *arg) {
auto ext = ioctl_res_ext.load();
//store flags
switch (request) {
case DRM_IOCTL_I915_GEM_EXECBUFFER2: {
case DrmIoctl::GemExecbuffer2: {
auto execbuf = static_cast<NEO::MockExecBuffer *>(arg);
this->execBuffer = *execbuf;
this->execBufferBufferObjects =
@ -77,33 +77,33 @@ int DrmMockCustom::ioctl(unsigned long request, void *arg) {
execBufferExtensions(execbuf);
} break;
case DRM_IOCTL_I915_GEM_USERPTR: {
case DrmIoctl::GemUserptr: {
auto *userPtrParams = static_cast<NEO::GemUserPtr *>(arg);
userPtrParams->handle = returnHandle;
returnHandle++;
ioctl_cnt.gemUserptr++;
} break;
case DRM_IOCTL_I915_GEM_CREATE: {
case DrmIoctl::GemCreate: {
auto *createParams = static_cast<NEO::GemCreate *>(arg);
this->createParamsSize = createParams->size;
this->createParamsHandle = createParams->handle = 1u;
ioctl_cnt.gemCreate++;
} break;
case DRM_IOCTL_I915_GEM_SET_TILING: {
case DrmIoctl::GemSetTiling: {
auto *setTilingParams = static_cast<NEO::GemSetTiling *>(arg);
setTilingMode = setTilingParams->tilingMode;
setTilingHandle = setTilingParams->handle;
setTilingStride = setTilingParams->stride;
ioctl_cnt.gemSetTiling++;
} break;
case DRM_IOCTL_I915_GEM_GET_TILING: {
case DrmIoctl::GemGetTiling: {
auto *getTilingParams = static_cast<NEO::GemGetTiling *>(arg);
getTilingParams->tilingMode = getTilingModeOut;
getTilingHandleIn = getTilingParams->handle;
ioctl_cnt.gemGetTiling++;
} break;
case DRM_IOCTL_PRIME_FD_TO_HANDLE: {
case DrmIoctl::PrimeFdToHandle: {
auto *primeToHandleParams = static_cast<NEO::PrimeHandle *>(arg);
//return BO
primeToHandleParams->handle = outputHandle;
@ -113,7 +113,7 @@ int DrmMockCustom::ioctl(unsigned long request, void *arg) {
return -1;
}
} break;
case DRM_IOCTL_PRIME_HANDLE_TO_FD: {
case DrmIoctl::PrimeHandleToFd: {
auto *handleToPrimeParams = static_cast<NEO::PrimeHandle *>(arg);
//return FD
inputHandle = handleToPrimeParams->handle;
@ -121,7 +121,7 @@ int DrmMockCustom::ioctl(unsigned long request, void *arg) {
handleToPrimeParams->fileDescriptor = outputFd;
ioctl_cnt.handleToPrimeFd++;
} break;
case DRM_IOCTL_I915_GEM_MMAP: {
case DrmIoctl::GemMmap: {
auto mmapParams = static_cast<NEO::GemMmap *>(arg);
mmapHandle = mmapParams->handle;
mmapPad = mmapParams->pad;
@ -131,7 +131,7 @@ int DrmMockCustom::ioctl(unsigned long request, void *arg) {
mmapParams->addrPtr = mmapAddrPtr;
ioctl_cnt.gemMmap++;
} break;
case DRM_IOCTL_I915_GEM_SET_DOMAIN: {
case DrmIoctl::GemSetDomain: {
auto setDomainParams = static_cast<NEO::GemSetDomain *>(arg);
setDomainHandle = setDomainParams->handle;
setDomainReadDomains = setDomainParams->readDomains;
@ -139,45 +139,45 @@ int DrmMockCustom::ioctl(unsigned long request, void *arg) {
ioctl_cnt.gemSetDomain++;
} break;
case DRM_IOCTL_I915_GEM_WAIT: {
case DrmIoctl::GemWait: {
auto gemWaitParams = static_cast<NEO::GemWait *>(arg);
gemWaitTimeout = gemWaitParams->timeoutNs;
ioctl_cnt.gemWait++;
} break;
case DRM_IOCTL_GEM_CLOSE:
case DrmIoctl::GemClose:
ioctl_cnt.gemClose++;
break;
case DRM_IOCTL_I915_REG_READ:
case DrmIoctl::RegRead:
ioctl_cnt.regRead++;
break;
case DRM_IOCTL_I915_GETPARAM: {
case DrmIoctl::Getparam: {
ioctl_cnt.contextGetParam++;
auto getParam = static_cast<NEO::GetParam *>(arg);
recordedGetParam = *getParam;
*getParam->value = getParamRetValue;
} break;
case DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM: {
case DrmIoctl::GemContextSetparam: {
} break;
case DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM: {
case DrmIoctl::GemContextGetparam: {
ioctl_cnt.contextGetParam++;
auto getContextParam = static_cast<NEO::GemContextParam *>(arg);
recordedGetContextParam = *getContextParam;
getContextParam->value = getContextParamRetValue;
} break;
case DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT: {
case DrmIoctl::GemContextCreateExt: {
auto contextCreateParam = static_cast<NEO::GemContextCreateExt *>(arg);
contextCreateParam->contextId = ++ioctl_cnt.contextCreate;
} break;
case DRM_IOCTL_I915_GEM_CONTEXT_DESTROY: {
case DrmIoctl::GemContextDestroy: {
ioctl_cnt.contextDestroy++;
} break;
case DRM_IOCTL_I915_GEM_MMAP_OFFSET: {
case DrmIoctl::GemMmapOffset: {
auto mmapOffsetParams = reinterpret_cast<NEO::GemMmapOffset *>(arg);
mmapOffsetParams->handle = mmapOffsetHandle;
mmapOffsetParams->offset = mmapOffsetExpected;

11
shared/test/common/os_interface/linux/device_command_stream_fixture.h
View File

@ -20,6 +20,7 @@
#include <cstdint>
using NEO::Drm;
using NEO::DrmIoctl;
using NEO::HwDeviceIdDrm;
using NEO::RootDeviceEnvironment;
@ -61,20 +62,20 @@ class DrmMockSuccess : public Drm {
using Drm::setupIoctlHelper;
DrmMockSuccess(int fd, RootDeviceEnvironment &rootDeviceEnvironment) : Drm(std::make_unique<HwDeviceIdDrm>(fd, mockPciPath), rootDeviceEnvironment) {}
int ioctl(unsigned long request, void *arg) override { return 0; };
int ioctl(DrmIoctl request, void *arg) override { return 0; };
};
class DrmMockFail : public Drm {
public:
DrmMockFail(RootDeviceEnvironment &rootDeviceEnvironment) : Drm(std::make_unique<HwDeviceIdDrm>(mockFd, mockPciPath), rootDeviceEnvironment) {}
int ioctl(unsigned long request, void *arg) override { return -1; };
int ioctl(DrmIoctl request, void *arg) override { return -1; };
};
class DrmMockTime : public DrmMockSuccess {
public:
using DrmMockSuccess::DrmMockSuccess;
int ioctl(unsigned long request, void *arg) override {
int ioctl(DrmIoctl request, void *arg) override {
auto *reg = reinterpret_cast<NEO::RegisterRead *>(arg);
reg->value = getVal() << 32;
return 0;
@ -130,9 +131,9 @@ class DrmMockCustom : public Drm {
void testIoctls();
int ioctl(unsigned long request, void *arg) override;
int ioctl(DrmIoctl request, void *arg) override;
virtual int ioctlExtra(unsigned long request, void *arg) {
virtual int ioctlExtra(DrmIoctl request, void *arg) {
return -1;
}

14
shared/test/common/os_interface/linux/device_command_stream_fixture_context.cpp
View File

@ -11,21 +11,19 @@
#include "third_party/uapi/prelim/drm/i915_drm.h"
#include <iostream>
int DrmMockCustomPrelimContext::ioctlExtra(unsigned long request, void *arg) {
int DrmMockCustomPrelimContext::ioctlExtra(DrmIoctl request, void *arg) {
switch (request) {
case PRELIM_DRM_IOCTL_I915_GEM_CREATE_EXT: {
case DrmIoctl::GemCreateExt: {
auto createExtParams = reinterpret_cast<prelim_drm_i915_gem_create_ext *>(arg);
createExtSize = createExtParams->size;
createExtHandle = createExtParams->handle;
createExtExtensions = createExtParams->extensions;
} break;
case PRELIM_DRM_IOCTL_I915_GEM_VM_BIND: {
case DrmIoctl::GemVmBind: {
} break;
case PRELIM_DRM_IOCTL_I915_GEM_VM_UNBIND: {
case DrmIoctl::GemVmUnbind: {
} break;
case PRELIM_DRM_IOCTL_I915_GEM_WAIT_USER_FENCE: {
case DrmIoctl::GemWaitUserFence: {
const auto wait = reinterpret_cast<prelim_drm_i915_gem_wait_user_fence *>(arg);
receivedGemWaitUserFence = WaitUserFence{
wait->extensions,
@ -40,8 +38,6 @@ int DrmMockCustomPrelimContext::ioctlExtra(unsigned long request, void *arg) {
gemWaitUserFenceCalled++;
} break;
default: {
std::cout << std::hex << DRM_IOCTL_I915_GEM_WAIT << std::endl;
std::cout << "unexpected IOCTL: " << std::hex << request << std::endl;
UNRECOVERABLE_IF(true);
} break;
}

2
shared/test/common/os_interface/linux/device_command_stream_fixture_context.h
View File

@ -23,6 +23,6 @@ struct DrmMockCustomPrelimContext {
uint64_t completionAddress = 0;
uint64_t completionValue = 0;
int ioctlExtra(unsigned long request, void *arg);
int ioctlExtra(DrmIoctl request, void *arg);
void execBufferExtensions(void *arg);
};

5
shared/test/common/os_interface/linux/device_command_stream_fixture_impl.h
View File

@ -40,9 +40,9 @@ class DrmMockCustomImpl : public DrmMockCustom {
__u32 createExtHandle = 0;
__u64 createExtExtensions = 0;
int ioctlExtra(unsigned long request, void *arg) override {
int ioctlExtra(DrmIoctl request, void *arg) override {
switch (request) {
case DRM_IOCTL_I915_GEM_CREATE_EXT: {
case DrmIoctl::GemCreateExt: {
auto createExtParams = reinterpret_cast<drm_i915_gem_create_ext *>(arg);
createExtSize = createExtParams->size;
createExtHandle = createExtParams->handle;
@ -50,7 +50,6 @@ class DrmMockCustomImpl : public DrmMockCustom {
ioctlImpl_cnt.gemCreateExt++;
} break;
default: {
std::cout << "unexpected IOCTL: " << NEO::IoctlToStringHelper::getIoctlString(request) << std::endl;
UNRECOVERABLE_IF(true);
} break;
}

2
shared/test/common/os_interface/linux/device_command_stream_fixture_prelim.h
View File

@ -24,7 +24,7 @@ class DrmMockCustomPrelim : public DrmMockCustom {
prelimVersion = "2.0";
}
int ioctlExtra(unsigned long request, void *arg) override {
int ioctlExtra(DrmIoctl request, void *arg) override {
return context.ioctlExtra(request, arg);
}

10
shared/test/unit_test/os_interface/linux/drm_mock_impl.h
View File

@ -41,8 +41,8 @@ class DrmTipMock : public DrmMock {
prelimVersion = "";
}
int handleRemainingRequests(unsigned long request, void *arg) override {
if ((request == DRM_IOCTL_I915_QUERY) && (arg != nullptr)) {
int handleRemainingRequests(DrmIoctl request, void *arg) override {
if ((request == DrmIoctl::Query) && (arg != nullptr)) {
if (i915QuerySuccessCount == 0) {
return EINVAL;
}
@ -55,7 +55,7 @@ class DrmTipMock : public DrmMock {
handleQueryItem(reinterpret_cast<QueryItem *>(query->itemsPtr) + i);
}
return 0;
} else if (request == DRM_IOCTL_I915_GEM_MMAP_OFFSET) {
} else if (request == DrmIoctl::GemMmapOffset) {
auto mmapArg = static_cast<GemMmapOffset *>(arg);
mmapOffsetFlagsReceived = mmapArg->flags;
mmapArg->offset = offset;
@ -93,8 +93,8 @@ class DrmTipMock : public DrmMock {
}
}
virtual int handleKernelSpecificRequests(unsigned long request, void *arg) {
if (request == DRM_IOCTL_I915_GEM_CREATE_EXT) {
virtual int handleKernelSpecificRequests(DrmIoctl request, void *arg) {
if (request == DrmIoctl::GemCreateExt) {
auto createExtParams = static_cast<drm_i915_gem_create_ext *>(arg);
if (createExtParams->size == 0) {
return EINVAL;

4
shared/test/unit_test/os_interface/linux/drm_mock_prod_dg1.h
View File

@ -53,8 +53,8 @@ class DrmMockProdDg1 : public DrmTipMock {
}
}
int handleKernelSpecificRequests(unsigned long request, void *arg) override {
if (request == DRM_IOCTL_I915_GEM_CREATE_EXT) {
int handleKernelSpecificRequests(DrmIoctl request, void *arg) override {
if (request == DrmIoctl::DG1GemCreateExt) {
auto createExtParams = static_cast<drm_i915_gem_create_ext *>(arg);
if (createExtParams->size == 0) {
return EINVAL;

48
shared/test/unit_test/os_interface/linux/drm_tests.cpp
View File

@ -8,6 +8,7 @@
#include "shared/source/helpers/file_io.h"
#include "shared/source/helpers/hw_info.h"
#include "shared/source/os_interface/device_factory.h"
#include "shared/source/os_interface/linux/ioctl_strings.h"
#include "shared/source/os_interface/linux/os_context_linux.h"
#include "shared/source/os_interface/linux/os_inc.h"
#include "shared/source/os_interface/os_interface.h"
@ -1173,3 +1174,50 @@ TEST(DrmTest, givenSetupIoctlHelperThenIoctlHelperNotNull) {
EXPECT_NE(nullptr, drm.ioctlHelper.get());
}
TEST(DrmWrapperTest, WhenGettingDrmIoctlGetparamValueThenIoctlHelperIsNotNeeded) {
EXPECT_EQ(getIoctlRequestValue(DrmIoctl::Getparam, nullptr), static_cast<unsigned int>(DRM_IOCTL_I915_GETPARAM));
EXPECT_THROW(getIoctlRequestValue(DrmIoctl::DG1GemCreateExt, nullptr), std::runtime_error);
}
TEST(DrmWrapperTest, WhenGettingIoctlStringValueThenProperStringIsReturned) {
std::map<DrmIoctl, const char *> ioctlCodeStringMap = {
{DrmIoctl::GemClose, "DRM_IOCTL_GEM_CLOSE"},
{DrmIoctl::Getparam, "DRM_IOCTL_I915_GETPARAM"},
{DrmIoctl::GemExecbuffer2, "DRM_IOCTL_I915_GEM_EXECBUFFER2"},
{DrmIoctl::GemCreate, "DRM_IOCTL_I915_GEM_CREATE"},
{DrmIoctl::GemSetDomain, "DRM_IOCTL_I915_GEM_SET_DOMAIN"},
{DrmIoctl::GemSetTiling, "DRM_IOCTL_I915_GEM_SET_TILING"},
{DrmIoctl::GemGetTiling, "DRM_IOCTL_I915_GEM_GET_TILING"},
{DrmIoctl::GemWait, "DRM_IOCTL_I915_GEM_WAIT"},
{DrmIoctl::GemContextCreateExt, "DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT"},
{DrmIoctl::GemContextDestroy, "DRM_IOCTL_I915_GEM_CONTEXT_DESTROY"},
{DrmIoctl::RegRead, "DRM_IOCTL_I915_REG_READ"},
{DrmIoctl::GetResetStats, "DRM_IOCTL_I915_GET_RESET_STATS"},
{DrmIoctl::GemUserptr, "DRM_IOCTL_I915_GEM_USERPTR"},
{DrmIoctl::GemContextGetparam, "DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM"},
{DrmIoctl::GemContextSetparam, "DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM"},
{DrmIoctl::Query, "DRM_IOCTL_I915_QUERY"},
{DrmIoctl::GemMmap, "DRM_IOCTL_I915_GEM_MMAP"},
{DrmIoctl::PrimeFdToHandle, "DRM_IOCTL_PRIME_FD_TO_HANDLE"},
{DrmIoctl::GemVmBind, "PRELIM_DRM_IOCTL_I915_GEM_VM_BIND"},
{DrmIoctl::GemVmUnbind, "PRELIM_DRM_IOCTL_I915_GEM_VM_UNBIND"},
{DrmIoctl::GemWaitUserFence, "PRELIM_DRM_IOCTL_I915_GEM_WAIT_USER_FENCE"},
{DrmIoctl::GemCreateExt, "DRM_IOCTL_I915_GEM_CREATE_EXT"},
{DrmIoctl::DG1GemCreateExt, "DG1_DRM_IOCTL_I915_GEM_CREATE_EXT"},
{DrmIoctl::GemVmAdvise, "PRELIM_DRM_IOCTL_I915_GEM_VM_ADVISE"},
{DrmIoctl::GemVmPrefetch, "PRELIM_DRM_IOCTL_I915_GEM_VM_PREFETCH"},
{DrmIoctl::UuidRegister, "PRELIM_DRM_IOCTL_I915_UUID_REGISTER"},
{DrmIoctl::UuidUnregister, "PRELIM_DRM_IOCTL_I915_UUID_UNREGISTER"},
{DrmIoctl::DebuggerOpen, "PRELIM_DRM_IOCTL_I915_DEBUGGER_OPEN"},
{DrmIoctl::GemClosReserve, "PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE"},
{DrmIoctl::GemClosFree, "PRELIM_DRM_IOCTL_I915_GEM_CLOS_FREE"},
{DrmIoctl::GemCacheReserve, "PRELIM_DRM_IOCTL_I915_GEM_CACHE_RESERVE"},
{DrmIoctl::GemMmapOffset, "DRM_IOCTL_I915_GEM_MMAP_OFFSET"},
{DrmIoctl::GemVmCreate, "DRM_IOCTL_I915_GEM_VM_CREATE"},
{DrmIoctl::GemVmDestroy, "DRM_IOCTL_I915_GEM_VM_DESTROY"},
{DrmIoctl::PrimeHandleToFd, "DRM_IOCTL_PRIME_HANDLE_TO_FD"}};
for (auto &ioctlCodeString : ioctlCodeStringMap) {
EXPECT_STREQ(IoctlToStringHelper::getIoctlString(ioctlCodeString.first).c_str(), ioctlCodeString.second);
}
}

6
shared/test/unit_test/os_interface/linux/drm_with_prelim_tests.cpp
View File

@ -18,7 +18,7 @@
using namespace NEO;
extern int handlePrelimRequests(unsigned long request, void *arg, int ioctlRetVal, int queryDistanceIoctlRetVal);
extern int handlePrelimRequests(DrmIoctl request, void *arg, int ioctlRetVal, int queryDistanceIoctlRetVal);
class DrmPrelimMock : public DrmMock {
public:
@ -35,7 +35,7 @@ class DrmPrelimMock : public DrmMock {
prelimVersion = "2.0";
}
int handleRemainingRequests(unsigned long request, void *arg) override {
int handleRemainingRequests(DrmIoctl request, void *arg) override {
return handlePrelimRequests(request, arg, ioctlRetVal, queryDistanceIoctlRetVal);
}
};
@ -135,7 +135,7 @@ TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenCreateGemExtWithDebugFlagThenPr
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenCallIoctlThenProperIoctlRegistered) {
GemContextCreateExt arg{};
auto ret = IoctlHelper::ioctl(drm.get(), DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT, &arg);
auto ret = IoctlHelper::ioctl(drm.get(), DrmIoctl::GemContextCreateExt, &arg);
EXPECT_EQ(0u, ret);
EXPECT_EQ(1u, drm->ioctlCallsCount);
}

36
shared/test/unit_test/os_interface/linux/ioctl_helper_tests_dg1.cpp
View File

@ -9,6 +9,7 @@
#include "shared/source/os_interface/linux/ioctl_helper.h"
#include "shared/source/os_interface/linux/memory_info.h"
#include "shared/test/common/helpers/debug_manager_state_restore.h"
#include "shared/test/common/mocks/mock_execution_environment.h"
#include "shared/test/common/test_macros/test.h"
#include "shared/test/unit_test/os_interface/linux/drm_mock_prod_dg1.h"
@ -58,8 +59,7 @@ DG1TEST_F(IoctlHelperTestsDg1, givenDg1WhenCreateGemExtWithDebugFlagThenPrintDeb
DebugManagerStateRestore stateRestore;
DebugManager.flags.PrintBOCreateDestroyResult.set(true);
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
auto drm = std::make_unique<DrmMockProdDg1>(*executionEnvironment->rootDeviceEnvironments[0]);
testing::internal::CaptureStdout();
@ -92,3 +92,35 @@ DG1TEST_F(IoctlHelperTestsDg1, givenDg1AndMemoryRegionQuerySupportedWhenQuerying
ASSERT_NE(nullptr, memoryInfo);
EXPECT_EQ(2u, memoryInfo->getDrmRegionInfos().size());
}
DG1TEST_F(IoctlHelperTestsDg1, whenGettingIoctlRequestValueThenPropertValueIsReturned) {
auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
auto drm = std::make_unique<DrmMockProdDg1>(*executionEnvironment->rootDeviceEnvironments[0]);
auto &ioctlHelper = *drm->getIoctlHelper();
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemExecbuffer2), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_EXECBUFFER2));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemWait), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_WAIT));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemClose), static_cast<unsigned int>(DRM_IOCTL_GEM_CLOSE));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemUserptr), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_USERPTR));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemCreate), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CREATE));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemSetDomain), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_SET_DOMAIN));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemSetTiling), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_SET_TILING));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemGetTiling), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_GET_TILING));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemContextDestroy), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CONTEXT_DESTROY));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::RegRead), static_cast<unsigned int>(DRM_IOCTL_I915_REG_READ));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GetResetStats), static_cast<unsigned int>(DRM_IOCTL_I915_GET_RESET_STATS));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemContextGetparam), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemContextSetparam), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::Query), static_cast<unsigned int>(DRM_IOCTL_I915_QUERY));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemMmap), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_MMAP));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::PrimeFdToHandle), static_cast<unsigned int>(DRM_IOCTL_PRIME_FD_TO_HANDLE));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::PrimeHandleToFd), static_cast<unsigned int>(DRM_IOCTL_PRIME_HANDLE_TO_FD));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemContextCreateExt), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemMmapOffset), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_MMAP_OFFSET));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemVmCreate), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_VM_CREATE));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemVmDestroy), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_VM_DESTROY));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::DG1GemCreateExt), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CREATE_EXT));
EXPECT_NE(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemCreateExt), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CREATE_EXT));
EXPECT_THROW(ioctlHelper.getIoctlRequestValue(DrmIoctl::Getparam), std::runtime_error);
}

59
shared/test/unit_test/os_interface/linux/ioctl_helper_tests_prelim.cpp
View File

@ -15,7 +15,6 @@
using namespace NEO;
extern std::map<unsigned long, const char *> ioctlCodeStringMap;
extern std::map<int, const char *> ioctlParamCodeStringMap;
extern std::vector<uint8_t> getRegionInfo(const std::vector<MemoryRegion> &inputRegions);
extern std::vector<uint8_t> getEngineInfo(const std::vector<EngineCapabilities> &inputEngines);
@ -24,27 +23,43 @@ struct IoctlPrelimHelperTests : ::testing::Test {
IoctlHelperPrelim20 ioctlHelper{};
};
TEST_F(IoctlPrelimHelperTests, givenIoctlWhenParseToStringThenProperStringIsReturned) {
for (auto &ioctlCodeString : ioctlCodeStringMap) {
EXPECT_STREQ(IoctlToStringHelper::getIoctlString(ioctlCodeString.first).c_str(), ioctlCodeString.second);
}
EXPECT_STREQ(IoctlToStringHelper::getIoctlString(PRELIM_DRM_IOCTL_I915_GEM_VM_BIND).c_str(), "PRELIM_DRM_IOCTL_I915_GEM_VM_BIND");
EXPECT_STREQ(IoctlToStringHelper::getIoctlString(PRELIM_DRM_IOCTL_I915_GEM_VM_UNBIND).c_str(), "PRELIM_DRM_IOCTL_I915_GEM_VM_UNBIND");
EXPECT_STREQ(IoctlToStringHelper::getIoctlString(PRELIM_DRM_IOCTL_I915_GEM_WAIT_USER_FENCE).c_str(), "PRELIM_DRM_IOCTL_I915_GEM_WAIT_USER_FENCE");
EXPECT_STREQ(IoctlToStringHelper::getIoctlString(PRELIM_DRM_IOCTL_I915_GEM_CREATE_EXT).c_str(), "PRELIM_DRM_IOCTL_I915_GEM_CREATE_EXT");
EXPECT_STREQ(IoctlToStringHelper::getIoctlString(PRELIM_DRM_IOCTL_I915_GEM_VM_ADVISE).c_str(), "PRELIM_DRM_IOCTL_I915_GEM_VM_ADVISE");
EXPECT_STREQ(IoctlToStringHelper::getIoctlString(PRELIM_DRM_IOCTL_I915_GEM_VM_PREFETCH).c_str(), "PRELIM_DRM_IOCTL_I915_GEM_VM_PREFETCH");
EXPECT_STREQ(IoctlToStringHelper::getIoctlString(PRELIM_DRM_IOCTL_I915_UUID_REGISTER).c_str(), "PRELIM_DRM_IOCTL_I915_UUID_REGISTER");
EXPECT_STREQ(IoctlToStringHelper::getIoctlString(PRELIM_DRM_IOCTL_I915_UUID_UNREGISTER).c_str(), "PRELIM_DRM_IOCTL_I915_UUID_UNREGISTER");
EXPECT_STREQ(IoctlToStringHelper::getIoctlString(PRELIM_DRM_IOCTL_I915_DEBUGGER_OPEN).c_str(), "PRELIM_DRM_IOCTL_I915_DEBUGGER_OPEN");
EXPECT_STREQ(IoctlToStringHelper::getIoctlString(PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE).c_str(), "PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE");
EXPECT_STREQ(IoctlToStringHelper::getIoctlString(PRELIM_DRM_IOCTL_I915_GEM_CLOS_FREE).c_str(), "PRELIM_DRM_IOCTL_I915_GEM_CLOS_FREE");
EXPECT_STREQ(IoctlToStringHelper::getIoctlString(PRELIM_DRM_IOCTL_I915_GEM_CACHE_RESERVE).c_str(), "PRELIM_DRM_IOCTL_I915_GEM_CACHE_RESERVE");
EXPECT_STREQ(IoctlToStringHelper::getIoctlString(DRM_IOCTL_I915_GEM_MMAP_GTT).c_str(), "DRM_IOCTL_I915_GEM_MMAP_GTT");
EXPECT_STREQ(IoctlToStringHelper::getIoctlString(DRM_IOCTL_I915_GEM_MMAP_OFFSET).c_str(), "DRM_IOCTL_I915_GEM_MMAP_OFFSET");
EXPECT_STREQ(IoctlToStringHelper::getIoctlString(DRM_IOCTL_I915_GEM_VM_CREATE).c_str(), "DRM_IOCTL_I915_GEM_VM_CREATE");
EXPECT_STREQ(IoctlToStringHelper::getIoctlString(DRM_IOCTL_I915_GEM_VM_DESTROY).c_str(), "DRM_IOCTL_I915_GEM_VM_DESTROY");
EXPECT_STREQ(IoctlToStringHelper::getIoctlString(DRM_IOCTL_I915_GEM_VM_DESTROY).c_str(), "DRM_IOCTL_I915_GEM_VM_DESTROY");
TEST_F(IoctlPrelimHelperTests, whenGettingIoctlRequestValueThenPropertValueIsReturned) {
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemExecbuffer2), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_EXECBUFFER2));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemWait), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_WAIT));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemClose), static_cast<unsigned int>(DRM_IOCTL_GEM_CLOSE));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemUserptr), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_USERPTR));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemCreate), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CREATE));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemSetDomain), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_SET_DOMAIN));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemSetTiling), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_SET_TILING));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemGetTiling), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_GET_TILING));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemContextCreateExt), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemContextDestroy), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CONTEXT_DESTROY));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::RegRead), static_cast<unsigned int>(DRM_IOCTL_I915_REG_READ));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GetResetStats), static_cast<unsigned int>(DRM_IOCTL_I915_GET_RESET_STATS));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemContextGetparam), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemContextSetparam), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::Query), static_cast<unsigned int>(DRM_IOCTL_I915_QUERY));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemMmap), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_MMAP));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::PrimeFdToHandle), static_cast<unsigned int>(DRM_IOCTL_PRIME_FD_TO_HANDLE));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::PrimeHandleToFd), static_cast<unsigned int>(DRM_IOCTL_PRIME_HANDLE_TO_FD));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemVmBind), static_cast<unsigned int>(PRELIM_DRM_IOCTL_I915_GEM_VM_BIND));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemVmUnbind), static_cast<unsigned int>(PRELIM_DRM_IOCTL_I915_GEM_VM_UNBIND));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemWaitUserFence), static_cast<unsigned int>(PRELIM_DRM_IOCTL_I915_GEM_WAIT_USER_FENCE));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemCreateExt), static_cast<unsigned int>(PRELIM_DRM_IOCTL_I915_GEM_CREATE_EXT));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemVmAdvise), static_cast<unsigned int>(PRELIM_DRM_IOCTL_I915_GEM_VM_ADVISE));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemVmPrefetch), static_cast<unsigned int>(PRELIM_DRM_IOCTL_I915_GEM_VM_PREFETCH));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::UuidRegister), static_cast<unsigned int>(PRELIM_DRM_IOCTL_I915_UUID_REGISTER));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::UuidUnregister), static_cast<unsigned int>(PRELIM_DRM_IOCTL_I915_UUID_UNREGISTER));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::DebuggerOpen), static_cast<unsigned int>(PRELIM_DRM_IOCTL_I915_DEBUGGER_OPEN));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemClosReserve), static_cast<unsigned int>(PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemClosFree), static_cast<unsigned int>(PRELIM_DRM_IOCTL_I915_GEM_CLOS_FREE));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemCacheReserve), static_cast<unsigned int>(PRELIM_DRM_IOCTL_I915_GEM_CACHE_RESERVE));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemMmapOffset), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_MMAP_OFFSET));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemVmCreate), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_VM_CREATE));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemVmDestroy), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_VM_DESTROY));
EXPECT_THROW(ioctlHelper.getIoctlRequestValue(DrmIoctl::Getparam), std::runtime_error);
EXPECT_THROW(ioctlHelper.getIoctlRequestValue(DrmIoctl::DG1GemCreateExt), std::runtime_error);
}
TEST_F(IoctlPrelimHelperTests, givenIoctlParamWhenParseToStringThenProperStringIsReturned) {

36
shared/test/unit_test/os_interface/linux/ioctl_helper_tests_upstream.cpp
View File

@ -14,7 +14,6 @@
#include "shared/test/unit_test/os_interface/linux/drm_mock_impl.h"
using namespace NEO;
extern std::map<unsigned long, const char *> ioctlCodeStringMap;
extern std::map<int, const char *> ioctlParamCodeStringMap;
TEST(IoctlHelperUpstreamTest, whenGettingVmBindAvailabilityThenFalseIsReturned) {
@ -24,18 +23,41 @@ TEST(IoctlHelperUpstreamTest, whenGettingVmBindAvailabilityThenFalseIsReturned)
EXPECT_FALSE(ioctlHelper.isVmBindAvailable(drm.get()));
}
TEST(IoctlHelperUpstreamTest, givenIoctlWhenParseToStringThenProperStringIsReturned) {
for (auto ioctlCodeString : ioctlCodeStringMap) {
EXPECT_STREQ(IoctlToStringHelper::getIoctlString(ioctlCodeString.first).c_str(), ioctlCodeString.second);
}
}
TEST(IoctlHelperUpstreamTest, givenIoctlParamWhenParseToStringThenProperStringIsReturned) {
for (auto ioctlParamCodeString : ioctlParamCodeStringMap) {
EXPECT_STREQ(IoctlToStringHelper::getIoctlParamString(ioctlParamCodeString.first).c_str(), ioctlParamCodeString.second);
}
}
TEST(IoctlHelperUpstreamTest, whenGettingIoctlRequestValueThenPropertValueIsReturned) {
IoctlHelperUpstream ioctlHelper{};
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemExecbuffer2), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_EXECBUFFER2));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemWait), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_WAIT));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemClose), static_cast<unsigned int>(DRM_IOCTL_GEM_CLOSE));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemUserptr), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_USERPTR));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemCreate), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CREATE));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemSetDomain), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_SET_DOMAIN));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemSetTiling), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_SET_TILING));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemGetTiling), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_GET_TILING));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemContextCreateExt), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemContextDestroy), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CONTEXT_DESTROY));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::RegRead), static_cast<unsigned int>(DRM_IOCTL_I915_REG_READ));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GetResetStats), static_cast<unsigned int>(DRM_IOCTL_I915_GET_RESET_STATS));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemContextGetparam), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemContextSetparam), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::Query), static_cast<unsigned int>(DRM_IOCTL_I915_QUERY));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemMmap), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_MMAP));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::PrimeFdToHandle), static_cast<unsigned int>(DRM_IOCTL_PRIME_FD_TO_HANDLE));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::PrimeHandleToFd), static_cast<unsigned int>(DRM_IOCTL_PRIME_HANDLE_TO_FD));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemCreateExt), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_CREATE_EXT));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemMmapOffset), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_MMAP_OFFSET));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemVmCreate), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_VM_CREATE));
EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::GemVmDestroy), static_cast<unsigned int>(DRM_IOCTL_I915_GEM_VM_DESTROY));
EXPECT_THROW(ioctlHelper.getIoctlRequestValue(DrmIoctl::Getparam), std::runtime_error);
EXPECT_THROW(ioctlHelper.getIoctlRequestValue(DrmIoctl::DG1GemCreateExt), std::runtime_error);
}
TEST(IoctlHelperUpstreamTest, whenCreatingVmControlRegionExtThenNullptrIsReturned) {
IoctlHelperUpstream ioctlHelper{};
std::optional<MemoryClassInstance> regionInstanceClass = MemoryClassInstance{};

8
shared/test/unit_test/os_interface/linux/prelim_helper_func.cpp
View File

@ -16,8 +16,8 @@
using namespace NEO;
int handlePrelimRequests(unsigned long request, void *arg, int ioctlRetVal, int queryDistanceIoctlRetVal) {
if (request == PRELIM_DRM_IOCTL_I915_GEM_CREATE_EXT) {
int handlePrelimRequests(DrmIoctl request, void *arg, int ioctlRetVal, int queryDistanceIoctlRetVal) {
if (request == DrmIoctl::GemCreateExt) {
auto createExtParams = static_cast<prelim_drm_i915_gem_create_ext *>(arg);
if (createExtParams->size == 0) {
return EINVAL;
@ -43,10 +43,10 @@ int handlePrelimRequests(unsigned long request, void *arg, int ioctlRetVal, int
if ((data->memoryClass != PRELIM_I915_MEMORY_CLASS_SYSTEM) && (data->memoryClass != PRELIM_I915_MEMORY_CLASS_DEVICE)) {
return EINVAL;
}
} else if (request == PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE) {
} else if (request == DrmIoctl::GemClosReserve) {
auto closReserveArg = static_cast<prelim_drm_i915_gem_clos_reserve *>(arg);
closReserveArg->clos_index = 1u;
} else if (request == DRM_IOCTL_I915_QUERY) {
} else if (request == DrmIoctl::Query) {
auto query = static_cast<Query *>(arg);
if (query->itemsPtr == 0) {
return EINVAL;