intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-19 16:24:18 +08:00
Code Issues Packages Projects Releases Wiki Activity

Dont pass drm to ioctl helper methods - use Ioctl Helper's member instead

Browse Source 
Related-To: NEO-6999
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2022-06-29 16:49:29 +00:00
committed by Compute-Runtime-Automation
parent 28edaa9a2d
commit e88bad79a6
18 changed files with 232 additions and 232 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -15,7 +15,7 @@ namespace L0 {
int DrmHelper::ioctl(Device *device, NEO::DrmIoctl request, void *arg) {
auto drm = device->getOsInterface().getDriverModel()->as<NEO::Drm>();
return drm->getIoctlHelper()->ioctl(drm, request, arg);
return drm->getIoctlHelper()->ioctl(request, arg);
}
int DrmHelper::getErrno(Device *device) {

6
shared/source/os_interface/linux/clos_cache.cpp
View File

@@ -38,15 +38,15 @@ CacheRegion ClosCacheReservation::freeCache(CacheLevel cacheLevel, CacheRegion c
}
CacheRegion ClosCacheReservation::allocEntry() {
return drm.getIoctlHelper()->closAlloc(&drm);
return drm.getIoctlHelper()->closAlloc();
}
CacheRegion ClosCacheReservation::freeEntry(CacheRegion closIndex) {
return drm.getIoctlHelper()->closFree(&drm, closIndex);
return drm.getIoctlHelper()->closFree(closIndex);
}
uint16_t ClosCacheReservation::allocCacheWay(CacheRegion closIndex, CacheLevel cacheLevel, uint16_t numWays) {
return drm.getIoctlHelper()->closAllocWays(&drm, closIndex, static_cast<uint16_t>(cacheLevel), numWays);
return drm.getIoctlHelper()->closAllocWays(closIndex, static_cast<uint16_t>(cacheLevel), numWays);
}
} // namespace NEO

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

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

6
shared/source/os_interface/linux/drm_allocation.cpp
View File

@@ -272,7 +272,7 @@ bool DrmAllocation::setMemAdvise(Drm *drm, MemAdviseFlags flags) {
if (flags.non_atomic != enabledMemAdviseFlags.non_atomic) {
for (auto bo : bufferObjects) {
if (bo != nullptr) {
success &= ioctlHelper->setVmBoAdvise(drm, bo->peekHandle(), ioctlHelper->getAtomicAdvise(flags.non_atomic), nullptr);
success &= ioctlHelper->setVmBoAdvise(bo->peekHandle(), ioctlHelper->getAtomicAdvise(flags.non_atomic), nullptr);
}
}
}
@@ -289,7 +289,7 @@ bool DrmAllocation::setMemAdvise(Drm *drm, MemAdviseFlags flags) {
region.memoryClass = -1;
region.memoryInstance = 0;
}
success &= ioctlHelper->setVmBoAdvise(drm, bo->peekHandle(), ioctlHelper->getPreferredLocationAdvise(), &region);
success &= ioctlHelper->setVmBoAdvise(bo->peekHandle(), ioctlHelper->getPreferredLocationAdvise(), &region);
}
}
}
@@ -309,7 +309,7 @@ bool DrmAllocation::setMemPrefetch(Drm *drm, uint32_t subDeviceId) {
for (auto bo : bufferObjects) {
if (bo != nullptr) {
auto region = static_cast<uint32_t>((memoryClassDevice << 16u) | subDeviceId);
success &= ioctlHelper->setVmPrefetch(drm, bo->peekAddress(), bo->peekSize(), region);
success &= ioctlHelper->setVmPrefetch(bo->peekAddress(), bo->peekSize(), region);
}
}

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

@@ -69,7 +69,7 @@ bool BufferObject::close() {
PRINT_DEBUG_STRING(DebugManager.flags.PrintBOCreateDestroyResult.get(), stdout, "Calling gem close on handle: BO-%d\n", this->handle);
auto ioctlHelper = this->drm->getIoctlHelper();
int ret = ioctlHelper->ioctl(drm, DrmIoctl::GemClose, &close);
int ret = ioctlHelper->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));
@@ -104,7 +104,7 @@ bool BufferObject::setTiling(uint32_t mode, uint32_t stride) {
setTiling.stride = stride;
auto ioctlHelper = this->drm->getIoctlHelper();
if (ioctlHelper->ioctl(drm, DrmIoctl::GemSetTiling, &setTiling) != 0) {
if (ioctlHelper->ioctl(DrmIoctl::GemSetTiling, &setTiling) != 0) {
return false;
}
@@ -144,7 +144,7 @@ int BufferObject::exec(uint32_t used, size_t startOffset, unsigned int flags, bo
printExecutionBuffer(execbuf, residencyCount, execObjectsStorage, residency);
}
int ret = ioctlHelper->execBuffer(drm, &execbuf, completionGpuAddress, completionValue);
int ret = ioctlHelper->execBuffer(&execbuf, completionGpuAddress, completionValue);
if (ret != 0) {
int err = this->drm->getErrno();
@@ -154,7 +154,7 @@ int BufferObject::exec(uint32_t used, size_t startOffset, unsigned int flags, bo
}
evictUnusedAllocations(false, true);
ret = ioctlHelper->execBuffer(drm, &execbuf, completionGpuAddress, completionValue);
ret = ioctlHelper->execBuffer(&execbuf, completionGpuAddress, completionValue);
}
if (ret != 0) {
@@ -164,7 +164,7 @@ int BufferObject::exec(uint32_t used, size_t startOffset, unsigned int flags, bo
return gpuHangDetected;
}
ret = ioctlHelper->execBuffer(drm, &execbuf, completionGpuAddress, completionValue);
ret = ioctlHelper->execBuffer(&execbuf, completionGpuAddress, completionValue);
}
if (ret == 0) {

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

@@ -21,7 +21,7 @@ bool Drm::registerResourceClasses() {
auto className = classNameUUID.first;
auto uuid = classNameUUID.second;
const auto result = ioctlHelper->registerStringClassUuid(this, uuid, (uintptr_t)className, strnlen_s(className, 100));
const auto result = ioctlHelper->registerStringClassUuid(uuid, (uintptr_t)className, strnlen_s(className, 100));
if (result.retVal != 0) {
return false;
}
@@ -45,7 +45,7 @@ uint32_t Drm::registerResource(DrmResourceClass classType, const void *data, siz
const auto uuidClass = classHandles[static_cast<uint32_t>(classType)];
const auto ptr = size > 0 ? (uintptr_t)data : 0;
const auto result = ioctlHelper->registerUuid(this, uuid, uuidClass, ptr, size);
const auto result = ioctlHelper->registerUuid(uuid, uuidClass, ptr, size);
PRINT_DEBUGGER_INFO_LOG("PRELIM_DRM_IOCTL_I915_UUID_REGISTER: classType = %d, uuid = %s, data = %p, handle = %lu, ret = %d\n", (int)classType, std::string(uuid, 36).c_str(), ptr, result.handle, result.retVal);
DEBUG_BREAK_IF(result.retVal != 0);
@@ -56,7 +56,7 @@ uint32_t Drm::registerResource(DrmResourceClass classType, const void *data, siz
uint32_t Drm::registerIsaCookie(uint32_t isaHandle) {
auto uuid = generateUUID();
const auto result = ioctlHelper->registerUuid(this, uuid, isaHandle, 0, 0);
const auto result = ioctlHelper->registerUuid(uuid, isaHandle, 0, 0);
PRINT_DEBUGGER_INFO_LOG("PRELIM_DRM_IOCTL_I915_UUID_REGISTER: isa handle = %lu, uuid = %s, data = %p, handle = %lu, ret = %d\n", isaHandle, std::string(uuid, 36).c_str(), 0, result.handle, result.retVal);
DEBUG_BREAK_IF(result.retVal != 0);
@@ -66,7 +66,7 @@ uint32_t Drm::registerIsaCookie(uint32_t isaHandle) {
void Drm::unregisterResource(uint32_t handle) {
PRINT_DEBUGGER_INFO_LOG("PRELIM_DRM_IOCTL_I915_UUID_UNREGISTER: handle = %lu\n", handle);
[[maybe_unused]] const auto ret = ioctlHelper->unregisterUuid(this, handle);
[[maybe_unused]] const auto ret = ioctlHelper->unregisterUuid(handle);
DEBUG_BREAK_IF(ret != 0);
}
@@ -101,16 +101,16 @@ std::string Drm::generateElfUUID(const void *data) {
}
void Drm::checkContextDebugSupport() {
contextDebugSupported = ioctlHelper->isContextDebugSupported(this);
contextDebugSupported = ioctlHelper->isContextDebugSupported();
}
void Drm::setContextDebugFlag(uint32_t drmContextId) {
[[maybe_unused]] const auto retVal = ioctlHelper->setContextDebugFlag(this, drmContextId);
[[maybe_unused]] const auto retVal = ioctlHelper->setContextDebugFlag(drmContextId);
DEBUG_BREAK_IF(retVal != 0 && contextDebugSupported);
}
uint32_t Drm::notifyFirstCommandQueueCreated() {
const auto result = ioctlHelper->registerStringClassUuid(this, uuidL0CommandQueueHash, (uintptr_t)uuidL0CommandQueueName, strnlen_s(uuidL0CommandQueueName, 100));
const auto result = ioctlHelper->registerStringClassUuid(uuidL0CommandQueueHash, (uintptr_t)uuidL0CommandQueueName, strnlen_s(uuidL0CommandQueueName, 100));
DEBUG_BREAK_IF(result.retVal);
return result.handle;
}

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

@@ -248,7 +248,7 @@ NEO::BufferObject *DrmMemoryManager::allocUserptr(uintptr_t address, size_t size
auto &drm = this->getDrm(rootDeviceIndex);
auto ioctlHelper = drm.getIoctlHelper();
if (ioctlHelper->ioctl(&drm, DrmIoctl::GemUserptr, &userptr) != 0) {
if (ioctlHelper->ioctl(DrmIoctl::GemUserptr, &userptr) != 0) {
return nullptr;
}
@@ -523,7 +523,7 @@ GraphicsAllocation *DrmMemoryManager::allocateMemoryByKMD(const AllocationData &
auto &drm = getDrm(allocationData.rootDeviceIndex);
auto ioctlHelper = drm.getIoctlHelper();
[[maybe_unused]] auto ret = ioctlHelper->ioctl(&drm, DrmIoctl::GemCreate, &create);
[[maybe_unused]] auto ret = ioctlHelper->ioctl(DrmIoctl::GemCreate, &create);
DEBUG_BREAK_IF(ret != 0);
auto patIndex = drm.getPatIndex(gmm.get(), allocationData.type, CacheRegion::Default, CachePolicy::WriteBack, false);
@@ -557,7 +557,7 @@ GraphicsAllocation *DrmMemoryManager::allocateGraphicsMemoryForImageImpl(const A
auto &drm = this->getDrm(allocationData.rootDeviceIndex);
auto ioctlHelper = drm.getIoctlHelper();
[[maybe_unused]] auto ret = ioctlHelper->ioctl(&drm, DrmIoctl::GemCreate, &create);
[[maybe_unused]] auto ret = ioctlHelper->ioctl(DrmIoctl::GemCreate, &create);
DEBUG_BREAK_IF(ret != 0);
auto patIndex = drm.getPatIndex(gmm.get(), allocationData.type, CacheRegion::Default, CachePolicy::WriteBack, false);
@@ -690,7 +690,7 @@ GraphicsAllocation *DrmMemoryManager::createGraphicsAllocationFromMultipleShared
PrimeHandle openFd = {0, 0, 0};
openFd.fileDescriptor = handle;
auto ret = ioctlHelper->ioctl(&drm, DrmIoctl::PrimeFdToHandle, &openFd);
auto ret = ioctlHelper->ioctl(DrmIoctl::PrimeFdToHandle, &openFd);
if (ret != 0) {
[[maybe_unused]] int err = errno;
@@ -777,7 +777,7 @@ GraphicsAllocation *DrmMemoryManager::createGraphicsAllocationFromSharedHandle(o
auto &drm = this->getDrm(properties.rootDeviceIndex);
auto ioctlHelper = drm.getIoctlHelper();
auto ret = ioctlHelper->ioctl(&drm, DrmIoctl::PrimeFdToHandle, &openFd);
auto ret = ioctlHelper->ioctl(DrmIoctl::PrimeFdToHandle, &openFd);
if (ret != 0) {
[[maybe_unused]] int err = errno;
@@ -830,7 +830,7 @@ GraphicsAllocation *DrmMemoryManager::createGraphicsAllocationFromSharedHandle(o
GemGetTiling getTiling{};
getTiling.handle = boHandle;
auto ioctlHelper = drm.getIoctlHelper();
ret = ioctlHelper->ioctl(&drm, DrmIoctl::GemGetTiling, &getTiling);
ret = ioctlHelper->ioctl(DrmIoctl::GemGetTiling, &getTiling);
if (ret == 0) {
auto ioctlHelper = drm.getIoctlHelper();
@@ -1052,7 +1052,7 @@ bool DrmMemoryManager::setDomainCpu(GraphicsAllocation &graphicsAllocation, bool
auto &drm = this->getDrm(graphicsAllocation.getRootDeviceIndex());
auto ioctlHelper = drm.getIoctlHelper();
return ioctlHelper->ioctl(&drm, DrmIoctl::GemSetDomain, &setDomain) == 0;
return ioctlHelper->ioctl(DrmIoctl::GemSetDomain, &setDomain) == 0;
}
void *DrmMemoryManager::lockResourceImpl(GraphicsAllocation &graphicsAllocation) {
@@ -1091,7 +1091,7 @@ int DrmMemoryManager::obtainFdFromHandle(int boHandle, uint32_t rootDeviceIndex)
auto &drm = this->getDrm(rootDeviceIndex);
auto ioctlHelper = drm.getIoctlHelper();
ioctlHelper->ioctl(&drm, DrmIoctl::PrimeHandleToFd, &openFd);
ioctlHelper->ioctl(DrmIoctl::PrimeHandleToFd, &openFd);
return openFd.fileDescriptor;
}
@@ -1589,10 +1589,10 @@ bool DrmMemoryManager::retrieveMmapOffsetForBufferObject(uint32_t rootDeviceInde
mmapOffset.flags = isLocalMemorySupported(rootDeviceIndex) ? mmapOffsetFixed : flags;
auto &drm = this->getDrm(rootDeviceIndex);
auto ioctlHelper = drm.getIoctlHelper();
auto ret = ioctlHelper->ioctl(&drm, DrmIoctl::GemMmapOffset, &mmapOffset);
auto ret = ioctlHelper->ioctl(DrmIoctl::GemMmapOffset, &mmapOffset);
if (ret != 0 && isLocalMemorySupported(rootDeviceIndex)) {
mmapOffset.flags = flags;
ret = ioctlHelper->ioctl(&drm, DrmIoctl::GemMmapOffset, &mmapOffset);
ret = ioctlHelper->ioctl(DrmIoctl::GemMmapOffset, &mmapOffset);
}
if (ret != 0) {
int err = drm.getErrno();
@@ -1793,7 +1793,7 @@ GraphicsAllocation *DrmMemoryManager::createSharedUnifiedMemoryAllocation(const
std::unique_ptr<BufferObject, BufferObject::Deleter> bo(new BufferObject(&drm, patIndex, handle, size, maxOsContextCount));
if (!drm.getIoctlHelper()->setVmBoAdvise(&drm, bo->peekHandle(), vmAdviseAttribute, nullptr)) {
if (!drm.getIoctlHelper()->setVmBoAdvise(bo->peekHandle(), vmAdviseAttribute, nullptr)) {
return nullptr;
}
@@ -1840,7 +1840,7 @@ DrmAllocation *DrmMemoryManager::createUSMHostAllocationFromSharedHandle(osHandl
auto patIndex = drm.getPatIndex(nullptr, properties.allocationType, CacheRegion::Default, CachePolicy::WriteBack, false);
auto ioctlHelper = drm.getIoctlHelper();
auto ret = ioctlHelper->ioctl(&drm, DrmIoctl::PrimeFdToHandle, &openFd);
auto ret = ioctlHelper->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));

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

@@ -119,7 +119,7 @@ int Drm::getParamIoctl(DrmParam param, int *dstValue) {
getParam.param = getDrmParamValue(param, ioctlHelper.get());
getParam.value = dstValue;
int retVal = ioctlHelper ? ioctlHelper->ioctl(this, DrmIoctl::Getparam, &getParam) : ioctl(DrmIoctl::Getparam, &getParam);
int retVal = ioctlHelper ? ioctlHelper->ioctl(DrmIoctl::Getparam, &getParam) : ioctl(DrmIoctl::Getparam, &getParam);
if (DebugManager.flags.PrintIoctlEntries.get()) {
printf("DRM_IOCTL_I915_GETPARAM: param: %s, output value: %d, retCode:% d\n",
getDrmParamString(param).c_str(),
@@ -152,7 +152,7 @@ int Drm::enableTurboBoost() {
contextParam.param = I915_CONTEXT_PRIVATE_PARAM_BOOST;
contextParam.value = 1;
return ioctlHelper->ioctl(this, DrmIoctl::GemContextSetparam, &contextParam);
return ioctlHelper->ioctl(DrmIoctl::GemContextSetparam, &contextParam);
}
int Drm::getEnabledPooledEu(int &enabled) {
@@ -175,7 +175,7 @@ int Drm::queryGttSize(uint64_t &gttSizeOutput) {
GemContextParam contextParam = {0};
contextParam.param = I915_CONTEXT_PARAM_GTT_SIZE;
int ret = ioctlHelper->ioctl(this, DrmIoctl::GemContextGetparam, &contextParam);
int ret = ioctlHelper->ioctl(DrmIoctl::GemContextGetparam, &contextParam);
if (ret == 0) {
gttSizeOutput = contextParam.value;
}
@@ -191,7 +191,7 @@ bool Drm::isGpuHangDetected(OsContext &osContext) {
ResetStats resetStats{};
resetStats.contextId = drmContextId;
const auto retVal{ioctlHelper->ioctl(this, DrmIoctl::GetResetStats, &resetStats)};
const auto retVal{ioctlHelper->ioctl(DrmIoctl::GetResetStats, &resetStats)};
UNRECOVERABLE_IF(retVal != 0);
if (resetStats.batchActive > 0 || resetStats.batchPending > 0) {
@@ -219,7 +219,7 @@ void Drm::setLowPriorityContextParam(uint32_t drmContextId) {
gcp.param = I915_CONTEXT_PARAM_PRIORITY;
gcp.value = -1023;
auto retVal = ioctlHelper->ioctl(this, DrmIoctl::GemContextSetparam, &gcp);
auto retVal = ioctlHelper->ioctl(DrmIoctl::GemContextSetparam, &gcp);
UNRECOVERABLE_IF(retVal != 0);
}
@@ -231,7 +231,7 @@ int Drm::getQueueSliceCount(GemContextParamSseu *sseu) {
contextParam.value = reinterpret_cast<uint64_t>(sseu);
contextParam.size = sizeof(struct GemContextParamSseu);
return ioctlHelper->ioctl(this, DrmIoctl::GemContextGetparam, &contextParam);
return ioctlHelper->ioctl(DrmIoctl::GemContextGetparam, &contextParam);
}
uint64_t Drm::getSliceMask(uint64_t sliceCount) {
@@ -246,7 +246,7 @@ bool Drm::setQueueSliceCount(uint64_t sliceCount) {
contextParam.contextId = 0;
contextParam.value = reinterpret_cast<uint64_t>(&sseu);
contextParam.size = sizeof(struct GemContextParamSseu);
int retVal = ioctlHelper->ioctl(this, DrmIoctl::GemContextSetparam, &contextParam);
int retVal = ioctlHelper->ioctl(DrmIoctl::GemContextSetparam, &contextParam);
if (retVal == 0) {
return true;
}
@@ -258,7 +258,7 @@ void Drm::checkNonPersistentContextsSupport() {
GemContextParam contextParam = {};
contextParam.param = I915_CONTEXT_PARAM_PERSISTENCE;
auto retVal = ioctlHelper->ioctl(this, DrmIoctl::GemContextGetparam, &contextParam);
auto retVal = ioctlHelper->ioctl(DrmIoctl::GemContextGetparam, &contextParam);
if (retVal == 0 && contextParam.value == 1) {
nonPersistentContextsSupported = true;
} else {
@@ -271,7 +271,7 @@ void Drm::setNonPersistentContext(uint32_t drmContextId) {
contextParam.contextId = drmContextId;
contextParam.param = I915_CONTEXT_PARAM_PERSISTENCE;
ioctlHelper->ioctl(this, DrmIoctl::GemContextSetparam, &contextParam);
ioctlHelper->ioctl(DrmIoctl::GemContextSetparam, &contextParam);
}
void Drm::setUnrecoverableContext(uint32_t drmContextId) {
@@ -281,7 +281,7 @@ void Drm::setUnrecoverableContext(uint32_t drmContextId) {
contextParam.value = 0;
contextParam.size = 0;
ioctlHelper->ioctl(this, DrmIoctl::GemContextSetparam, &contextParam);
ioctlHelper->ioctl(DrmIoctl::GemContextSetparam, &contextParam);
}
uint32_t Drm::createDrmContext(uint32_t drmVmId, bool isDirectSubmissionRequested, bool isCooperativeContextRequested) {
@@ -305,16 +305,16 @@ uint32_t Drm::createDrmContext(uint32_t drmVmId, bool isDirectSubmissionRequeste
}
if (DebugManager.flags.CreateContextWithAccessCounters.get() != -1) {
return ioctlHelper->createContextWithAccessCounters(this, gcc);
return ioctlHelper->createContextWithAccessCounters(gcc);
}
if (DebugManager.flags.ForceRunAloneContext.get() != -1) {
isCooperativeContextRequested = DebugManager.flags.ForceRunAloneContext.get();
}
if (isCooperativeContextRequested) {
return ioctlHelper->createCooperativeContext(this, gcc);
return ioctlHelper->createCooperativeContext(gcc);
}
auto ioctlResult = ioctlHelper->ioctl(this, DrmIoctl::GemContextCreateExt, &gcc);
auto ioctlResult = ioctlHelper->ioctl(DrmIoctl::GemContextCreateExt, &gcc);
UNRECOVERABLE_IF(ioctlResult != 0);
return gcc.contextId;
@@ -323,7 +323,7 @@ uint32_t Drm::createDrmContext(uint32_t drmVmId, bool isDirectSubmissionRequeste
void Drm::destroyDrmContext(uint32_t drmContextId) {
GemContextDestroy destroy{};
destroy.contextId = drmContextId;
auto retVal = ioctlHelper->ioctl(this, DrmIoctl::GemContextDestroy, &destroy);
auto retVal = ioctlHelper->ioctl(DrmIoctl::GemContextDestroy, &destroy);
UNRECOVERABLE_IF(retVal != 0);
}
@@ -339,7 +339,7 @@ int Drm::queryVmId(uint32_t drmContextId, uint32_t &vmId) {
param.contextId = drmContextId;
param.value = 0;
param.param = I915_CONTEXT_PARAM_VM;
auto retVal = ioctlHelper->ioctl(this, DrmIoctl::GemContextGetparam, &param);
auto retVal = ioctlHelper->ioctl(DrmIoctl::GemContextGetparam, &param);
vmId = static_cast<uint32_t>(param.value);
@@ -538,7 +538,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 = ioctlHelper->ioctl(this, DrmIoctl::Query, &query);
auto ret = ioctlHelper->ioctl(DrmIoctl::Query, &query);
if (ret != 0 || queryItem.length <= 0) {
return {};
}
@@ -546,7 +546,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 = ioctlHelper->ioctl(this, DrmIoctl::Query, &query);
ret = ioctlHelper->ioctl(DrmIoctl::Query, &query);
if (ret != 0 || queryItem.length <= 0) {
return {};
}
@@ -734,7 +734,7 @@ int Drm::waitHandle(uint32_t waitHandle, int64_t timeout) {
wait.boHandle = waitHandle;
wait.timeoutNs = timeout;
int ret = ioctlHelper->ioctl(this, DrmIoctl::GemWait, &wait);
int ret = ioctlHelper->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));
@@ -867,7 +867,7 @@ void Drm::getPrelimVersion(std::string &prelimVersion) {
}
int Drm::waitUserFence(uint32_t ctxId, uint64_t address, uint64_t value, ValueWidth dataWidth, int64_t timeout, uint16_t flags) {
return ioctlHelper->waitUserFence(this, ctxId, address, value, static_cast<uint32_t>(dataWidth), timeout, flags);
return ioctlHelper->waitUserFence(ctxId, address, value, static_cast<uint32_t>(dataWidth), timeout, flags);
}
bool Drm::querySystemInfo() {
@@ -946,7 +946,7 @@ bool Drm::queryEngineInfo(bool isSysmanEnabled) {
}
std::vector<QueryItem> queryItems{distanceInfos.size()};
auto ret = ioctlHelper->queryDistances(this, queryItems, distanceInfos);
auto ret = ioctlHelper->queryDistances(queryItems, distanceInfos);
if (ret != 0) {
return false;
}
@@ -1178,7 +1178,7 @@ unsigned int Drm::bindDrmContext(uint32_t drmContextId, uint32_t deviceIndex, au
param.param = I915_CONTEXT_PARAM_ENGINES;
param.value = castToUint64(&contextEngines);
auto ioctlValue = ioctlHelper->ioctl(this, DrmIoctl::GemContextSetparam, &param);
auto ioctlValue = ioctlHelper->ioctl(DrmIoctl::GemContextSetparam, &param);
UNRECOVERABLE_IF(ioctlValue != 0);
retVal = static_cast<unsigned int>(ioctlHelper->getDrmParamValue(DrmParam::ExecDefault));
@@ -1211,7 +1211,7 @@ void Drm::waitForBind(uint32_t vmHandleId) {
bool Drm::isVmBindAvailable() {
std::call_once(checkBindOnce, [this]() {
int ret = ioctlHelper->isVmBindAvailable(this);
int ret = ioctlHelper->isVmBindAvailable();
auto hwInfo = this->getRootDeviceEnvironment().getHardwareInfo();
auto hwInfoConfig = HwInfoConfig::get(hwInfo->platform.eProductFamily);
@@ -1340,7 +1340,7 @@ int changeBufferObjectBinding(Drm *drm, OsContext *osContext, uint32_t vmHandleI
}
}
ret = ioctlHelper->vmBind(drm, vmBind);
ret = ioctlHelper->vmBind(vmBind);
if (ret) {
break;
@@ -1349,7 +1349,7 @@ int changeBufferObjectBinding(Drm *drm, OsContext *osContext, uint32_t vmHandleI
drm->setNewResourceBoundToVM(vmHandleId);
} else {
vmBind.handle = 0u;
ret = ioctlHelper->vmUnbind(drm, vmBind);
ret = ioctlHelper->vmUnbind(vmBind);
if (ret) {
break;
@@ -1400,7 +1400,7 @@ int Drm::createDrmVirtualMemory(uint32_t &drmVmId) {
ctl.flags = ioctlHelper->getFlagsForVmCreate(disableScratch, enablePageFault, useVmBind);
auto ret = ioctlHelper->ioctl(this, DrmIoctl::GemVmCreate, &ctl);
auto ret = ioctlHelper->ioctl(DrmIoctl::GemVmCreate, &ctl);
if (ret == 0) {
drmVmId = ctl.vmId;

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

@@ -22,8 +22,8 @@
namespace NEO {
uint32_t IoctlHelper::ioctl(Drm *drm, DrmIoctl request, void *arg) {
return drm->ioctl(request, arg);
uint32_t IoctlHelper::ioctl(DrmIoctl request, void *arg) {
return drm.ioctl(request, arg);
}
void IoctlHelper::fillExecObject(ExecObject &execObject, uint32_t handle, uint64_t gpuAddress, uint32_t drmContextId, bool bindInfo, bool isMarkedForCapture) {

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

@@ -66,46 +66,46 @@ class IoctlHelper {
IoctlHelper(Drm &drmArg) : drm(drmArg){};
virtual ~IoctlHelper() {}
static std::unique_ptr<IoctlHelper> get(const PRODUCT_FAMILY productFamily, const std::string &prelimVersion, const std::string &drmVersion, Drm &drm);
uint32_t ioctl(Drm *drm, DrmIoctl request, void *arg);
uint32_t ioctl(DrmIoctl request, void *arg);
virtual bool isVmBindAvailable(Drm *drm) = 0;
virtual uint32_t createGemExt(Drm *drm, const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle, std::optional<uint32_t> vmId) = 0;
virtual CacheRegion closAlloc(Drm *drm) = 0;
virtual uint16_t closAllocWays(Drm *drm, CacheRegion closIndex, uint16_t cacheLevel, uint16_t numWays) = 0;
virtual CacheRegion closFree(Drm *drm, CacheRegion closIndex) = 0;
virtual int waitUserFence(Drm *drm, uint32_t ctxId, uint64_t address,
virtual bool isVmBindAvailable() = 0;
virtual uint32_t createGemExt(const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle, std::optional<uint32_t> vmId) = 0;
virtual CacheRegion closAlloc() = 0;
virtual uint16_t closAllocWays(CacheRegion closIndex, uint16_t cacheLevel, uint16_t numWays) = 0;
virtual CacheRegion closFree(CacheRegion closIndex) = 0;
virtual int waitUserFence(uint32_t ctxId, uint64_t address,
uint64_t value, uint32_t dataWidth, int64_t timeout, uint16_t flags) = 0;
virtual uint32_t getAtomicAdvise(bool isNonAtomic) = 0;
virtual uint32_t getPreferredLocationAdvise() = 0;
virtual bool setVmBoAdvise(Drm *drm, int32_t handle, uint32_t attribute, void *region) = 0;
virtual bool setVmPrefetch(Drm *drm, uint64_t start, uint64_t length, uint32_t region) = 0;
virtual bool setVmBoAdvise(int32_t handle, uint32_t attribute, void *region) = 0;
virtual bool setVmPrefetch(uint64_t start, uint64_t length, uint32_t region) = 0;
virtual uint32_t getDirectSubmissionFlag() = 0;
virtual std::unique_ptr<uint8_t[]> prepareVmBindExt(const StackVec<uint32_t, 2> &bindExtHandles) = 0;
virtual uint64_t getFlagsForVmBind(bool bindCapture, bool bindImmediate, bool bindMakeResident) = 0;
virtual uint32_t queryDistances(Drm *drm, std::vector<QueryItem> &queryItems, std::vector<DistanceInfo> &distanceInfos) = 0;
virtual uint32_t queryDistances(std::vector<QueryItem> &queryItems, std::vector<DistanceInfo> &distanceInfos) = 0;
virtual uint16_t getWaitUserFenceSoftFlag() = 0;
virtual int execBuffer(Drm *drm, ExecBuffer *execBuffer, uint64_t completionGpuAddress, uint32_t counterValue) = 0;
virtual int execBuffer(ExecBuffer *execBuffer, uint64_t completionGpuAddress, uint32_t counterValue) = 0;
virtual bool completionFenceExtensionSupported(const bool isVmBindAvailable) = 0;
virtual std::optional<DrmParam> getHasPageFaultParamId() = 0;
virtual std::unique_ptr<uint8_t[]> createVmControlExtRegion(const std::optional<MemoryClassInstance> &regionInstanceClass) = 0;
virtual uint32_t getFlagsForVmCreate(bool disableScratch, bool enablePageFault, bool useVmBind) = 0;
virtual uint32_t createContextWithAccessCounters(Drm *drm, GemContextCreateExt &gcc) = 0;
virtual uint32_t createCooperativeContext(Drm *drm, GemContextCreateExt &gcc) = 0;
virtual uint32_t createContextWithAccessCounters(GemContextCreateExt &gcc) = 0;
virtual uint32_t createCooperativeContext(GemContextCreateExt &gcc) = 0;
virtual void fillVmBindExtSetPat(VmBindExtSetPatT &vmBindExtSetPat, uint64_t patIndex, uint64_t nextExtension) = 0;
virtual void fillVmBindExtUserFence(VmBindExtUserFenceT &vmBindExtUserFence, uint64_t fenceAddress, uint64_t fenceValue, uint64_t nextExtension) = 0;
virtual std::optional<uint64_t> getCopyClassSaturatePCIECapability() = 0;
virtual std::optional<uint64_t> getCopyClassSaturateLinkCapability() = 0;
virtual uint32_t getVmAdviseAtomicAttribute() = 0;
virtual int vmBind(Drm *drm, const VmBindParams &vmBindParams) = 0;
virtual int vmUnbind(Drm *drm, const VmBindParams &vmBindParams) = 0;
virtual int vmBind(const VmBindParams &vmBindParams) = 0;
virtual int vmUnbind(const VmBindParams &vmBindParams) = 0;
virtual bool getEuStallProperties(std::array<uint64_t, 12u> &properties, uint64_t dssBufferSize,
uint64_t samplingRate, uint64_t pollPeriod, uint64_t engineInstance, uint64_t notifyNReports) = 0;
virtual uint32_t getEuStallFdParameter() = 0;
virtual UuidRegisterResult registerUuid(Drm *drm, const std::string &uuid, uint32_t uuidClass, uint64_t ptr, uint64_t size) = 0;
virtual UuidRegisterResult registerStringClassUuid(Drm *drm, const std::string &uuid, uint64_t ptr, uint64_t size) = 0;
virtual int unregisterUuid(Drm *drm, uint32_t handle) = 0;
virtual bool isContextDebugSupported(Drm *drm) = 0;
virtual int setContextDebugFlag(Drm *drm, uint32_t drmContextId) = 0;
virtual UuidRegisterResult registerUuid(const std::string &uuid, uint32_t uuidClass, uint64_t ptr, uint64_t size) = 0;
virtual UuidRegisterResult registerStringClassUuid(const std::string &uuid, uint64_t ptr, uint64_t size) = 0;
virtual int unregisterUuid(uint32_t handle) = 0;
virtual bool isContextDebugSupported() = 0;
virtual int setContextDebugFlag(uint32_t drmContextId) = 0;
virtual bool isDebugAttachAvailable() = 0;
virtual unsigned int getIoctlRequestValue(DrmIoctl ioctlRequest) const = 0;
virtual int getDrmParamValue(DrmParam drmParam) const = 0;
@@ -131,44 +131,44 @@ class IoctlHelperUpstream : public IoctlHelper {
public:
using IoctlHelper::IoctlHelper;
bool isVmBindAvailable(Drm *drm) override;
uint32_t createGemExt(Drm *drm, const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle, std::optional<uint32_t> vmId) override;
CacheRegion closAlloc(Drm *drm) override;
uint16_t closAllocWays(Drm *drm, CacheRegion closIndex, uint16_t cacheLevel, uint16_t numWays) override;
CacheRegion closFree(Drm *drm, CacheRegion closIndex) override;
int waitUserFence(Drm *drm, uint32_t ctxId, uint64_t address,
bool isVmBindAvailable() override;
uint32_t createGemExt(const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle, std::optional<uint32_t> vmId) override;
CacheRegion closAlloc() override;
uint16_t closAllocWays(CacheRegion closIndex, uint16_t cacheLevel, uint16_t numWays) override;
CacheRegion closFree(CacheRegion closIndex) override;
int waitUserFence(uint32_t ctxId, uint64_t address,
uint64_t value, uint32_t dataWidth, int64_t timeout, uint16_t flags) override;
uint32_t getAtomicAdvise(bool isNonAtomic) override;
uint32_t getPreferredLocationAdvise() override;
bool setVmBoAdvise(Drm *drm, int32_t handle, uint32_t attribute, void *region) override;
bool setVmPrefetch(Drm *drm, uint64_t start, uint64_t length, uint32_t region) override;
bool setVmBoAdvise(int32_t handle, uint32_t attribute, void *region) override;
bool setVmPrefetch(uint64_t start, uint64_t length, uint32_t region) override;
uint32_t getDirectSubmissionFlag() override;
std::unique_ptr<uint8_t[]> prepareVmBindExt(const StackVec<uint32_t, 2> &bindExtHandles) override;
uint64_t getFlagsForVmBind(bool bindCapture, bool bindImmediate, bool bindMakeResident) override;
uint32_t queryDistances(Drm *drm, std::vector<QueryItem> &queryItems, std::vector<DistanceInfo> &distanceInfos) override;
uint32_t queryDistances(std::vector<QueryItem> &queryItems, std::vector<DistanceInfo> &distanceInfos) override;
uint16_t getWaitUserFenceSoftFlag() override;
int execBuffer(Drm *drm, ExecBuffer *execBuffer, uint64_t completionGpuAddress, uint32_t counterValue) override;
int execBuffer(ExecBuffer *execBuffer, uint64_t completionGpuAddress, uint32_t counterValue) override;
bool completionFenceExtensionSupported(const bool isVmBindAvailable) override;
std::optional<DrmParam> getHasPageFaultParamId() override;
std::unique_ptr<uint8_t[]> createVmControlExtRegion(const std::optional<MemoryClassInstance> &regionInstanceClass) override;
uint32_t getFlagsForVmCreate(bool disableScratch, bool enablePageFault, bool useVmBind) override;
uint32_t createContextWithAccessCounters(Drm *drm, GemContextCreateExt &gcc) override;
uint32_t createCooperativeContext(Drm *drm, GemContextCreateExt &gcc) override;
uint32_t createContextWithAccessCounters(GemContextCreateExt &gcc) override;
uint32_t createCooperativeContext(GemContextCreateExt &gcc) override;
void fillVmBindExtSetPat(VmBindExtSetPatT &vmBindExtSetPat, uint64_t patIndex, uint64_t nextExtension) override;
void fillVmBindExtUserFence(VmBindExtUserFenceT &vmBindExtUserFence, uint64_t fenceAddress, uint64_t fenceValue, uint64_t nextExtension) override;
std::optional<uint64_t> getCopyClassSaturatePCIECapability() override;
std::optional<uint64_t> getCopyClassSaturateLinkCapability() override;
uint32_t getVmAdviseAtomicAttribute() override;
int vmBind(Drm *drm, const VmBindParams &vmBindParams) override;
int vmUnbind(Drm *drm, const VmBindParams &vmBindParams) override;
int vmBind(const VmBindParams &vmBindParams) override;
int vmUnbind(const VmBindParams &vmBindParams) override;
bool getEuStallProperties(std::array<uint64_t, 12u> &properties, uint64_t dssBufferSize, uint64_t samplingRate,
uint64_t pollPeriod, uint64_t engineInstance, uint64_t notifyNReports) override;
uint32_t getEuStallFdParameter() override;
UuidRegisterResult registerUuid(Drm *drm, const std::string &uuid, uint32_t uuidClass, uint64_t ptr, uint64_t size) override;
UuidRegisterResult registerStringClassUuid(Drm *drm, const std::string &uuid, uint64_t ptr, uint64_t size) override;
int unregisterUuid(Drm *drm, uint32_t handle) override;
bool isContextDebugSupported(Drm *drm) override;
int setContextDebugFlag(Drm *drm, uint32_t drmContextId) override;
UuidRegisterResult registerUuid(const std::string &uuid, uint32_t uuidClass, uint64_t ptr, uint64_t size) override;
UuidRegisterResult registerStringClassUuid(const std::string &uuid, uint64_t ptr, uint64_t size) override;
int unregisterUuid(uint32_t handle) override;
bool isContextDebugSupported() override;
int setContextDebugFlag(uint32_t drmContextId) override;
bool isDebugAttachAvailable() override;
unsigned int getIoctlRequestValue(DrmIoctl ioctlRequest) const override;
int getDrmParamValue(DrmParam drmParam) const override;
@@ -182,7 +182,7 @@ class IoctlHelperImpl : public IoctlHelperUpstream {
return std::make_unique<IoctlHelperImpl<gfxProduct>>(drm);
}
uint32_t createGemExt(Drm *drm, const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle, std::optional<uint32_t> vmId) override;
uint32_t createGemExt(const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle, std::optional<uint32_t> vmId) override;
std::vector<MemoryRegion> translateToMemoryRegions(const std::vector<uint8_t> &regionInfo) override;
unsigned int getIoctlRequestValue(DrmIoctl ioctlRequest) const override;
};
@@ -191,44 +191,44 @@ class IoctlHelperPrelim20 : public IoctlHelper {
public:
using IoctlHelper::IoctlHelper;
bool isVmBindAvailable(Drm *drm) override;
uint32_t createGemExt(Drm *drm, const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle, std::optional<uint32_t> vmId) override;
CacheRegion closAlloc(Drm *drm) override;
uint16_t closAllocWays(Drm *drm, CacheRegion closIndex, uint16_t cacheLevel, uint16_t numWays) override;
CacheRegion closFree(Drm *drm, CacheRegion closIndex) override;
int waitUserFence(Drm *drm, uint32_t ctxId, uint64_t address,
bool isVmBindAvailable() override;
uint32_t createGemExt(const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle, std::optional<uint32_t> vmId) override;
CacheRegion closAlloc() override;
uint16_t closAllocWays(CacheRegion closIndex, uint16_t cacheLevel, uint16_t numWays) override;
CacheRegion closFree(CacheRegion closIndex) override;
int waitUserFence(uint32_t ctxId, uint64_t address,
uint64_t value, uint32_t dataWidth, int64_t timeout, uint16_t flags) override;
uint32_t getAtomicAdvise(bool isNonAtomic) override;
uint32_t getPreferredLocationAdvise() override;
bool setVmBoAdvise(Drm *drm, int32_t handle, uint32_t attribute, void *region) override;
bool setVmPrefetch(Drm *drm, uint64_t start, uint64_t length, uint32_t region) override;
bool setVmBoAdvise(int32_t handle, uint32_t attribute, void *region) override;
bool setVmPrefetch(uint64_t start, uint64_t length, uint32_t region) override;
uint32_t getDirectSubmissionFlag() override;
std::unique_ptr<uint8_t[]> prepareVmBindExt(const StackVec<uint32_t, 2> &bindExtHandles) override;
uint64_t getFlagsForVmBind(bool bindCapture, bool bindImmediate, bool bindMakeResident) override;
uint32_t queryDistances(Drm *drm, std::vector<QueryItem> &queryItems, std::vector<DistanceInfo> &distanceInfos) override;
uint32_t queryDistances(std::vector<QueryItem> &queryItems, std::vector<DistanceInfo> &distanceInfos) override;
uint16_t getWaitUserFenceSoftFlag() override;
int execBuffer(Drm *drm, ExecBuffer *execBuffer, uint64_t completionGpuAddress, uint32_t counterValue) override;
int execBuffer(ExecBuffer *execBuffer, uint64_t completionGpuAddress, uint32_t counterValue) override;
bool completionFenceExtensionSupported(const bool isVmBindAvailable) override;
std::optional<DrmParam> getHasPageFaultParamId() override;
std::unique_ptr<uint8_t[]> createVmControlExtRegion(const std::optional<MemoryClassInstance> &regionInstanceClass) override;
uint32_t getFlagsForVmCreate(bool disableScratch, bool enablePageFault, bool useVmBind) override;
uint32_t createContextWithAccessCounters(Drm *drm, GemContextCreateExt &gcc) override;
uint32_t createCooperativeContext(Drm *drm, GemContextCreateExt &gcc) override;
uint32_t createContextWithAccessCounters(GemContextCreateExt &gcc) override;
uint32_t createCooperativeContext(GemContextCreateExt &gcc) override;
void fillVmBindExtSetPat(VmBindExtSetPatT &vmBindExtSetPat, uint64_t patIndex, uint64_t nextExtension) override;
void fillVmBindExtUserFence(VmBindExtUserFenceT &vmBindExtUserFence, uint64_t fenceAddress, uint64_t fenceValue, uint64_t nextExtension) override;
std::optional<uint64_t> getCopyClassSaturatePCIECapability() override;
std::optional<uint64_t> getCopyClassSaturateLinkCapability() override;
uint32_t getVmAdviseAtomicAttribute() override;
int vmBind(Drm *drm, const VmBindParams &vmBindParams) override;
int vmUnbind(Drm *drm, const VmBindParams &vmBindParams) override;
int vmBind(const VmBindParams &vmBindParams) override;
int vmUnbind(const VmBindParams &vmBindParams) override;
bool getEuStallProperties(std::array<uint64_t, 12u> &properties, uint64_t dssBufferSize, uint64_t samplingRate,
uint64_t pollPeriod, uint64_t engineInstance, uint64_t notifyNReports) override;
uint32_t getEuStallFdParameter() override;
UuidRegisterResult registerUuid(Drm *drm, const std::string &uuid, uint32_t uuidClass, uint64_t ptr, uint64_t size) override;
UuidRegisterResult registerStringClassUuid(Drm *drm, const std::string &uuid, uint64_t ptr, uint64_t size) override;
int unregisterUuid(Drm *drm, uint32_t handle) override;
bool isContextDebugSupported(Drm *drm) override;
int setContextDebugFlag(Drm *drm, uint32_t drmContextId) override;
UuidRegisterResult registerUuid(const std::string &uuid, uint32_t uuidClass, uint64_t ptr, uint64_t size) override;
UuidRegisterResult registerStringClassUuid(const std::string &uuid, uint64_t ptr, uint64_t size) override;
int unregisterUuid(uint32_t handle) override;
bool isContextDebugSupported() override;
int setContextDebugFlag(uint32_t drmContextId) override;
bool isDebugAttachAvailable() override;
unsigned int getIoctlRequestValue(DrmIoctl ioctlRequest) const override;
int getDrmParamValue(DrmParam drmParam) const override;

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

@@ -24,19 +24,19 @@
namespace NEO {
bool IoctlHelperPrelim20::isVmBindAvailable(Drm *drm) {
bool IoctlHelperPrelim20::isVmBindAvailable() {
int vmBindSupported = 0;
GetParam getParam{};
getParam.param = PRELIM_I915_PARAM_HAS_VM_BIND;
getParam.value = &vmBindSupported;
int retVal = IoctlHelper::ioctl(drm, DrmIoctl::Getparam, &getParam);
int retVal = IoctlHelper::ioctl(DrmIoctl::Getparam, &getParam);
if (retVal) {
return false;
}
return vmBindSupported;
}
uint32_t IoctlHelperPrelim20::createGemExt(Drm *drm, const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle, std::optional<uint32_t> vmId) {
uint32_t IoctlHelperPrelim20::createGemExt(const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle, std::optional<uint32_t> vmId) {
uint32_t regionsSize = static_cast<uint32_t>(memClassInstances.size());
std::vector<prelim_drm_i915_gem_memory_class_instance> regions(regionsSize);
for (uint32_t i = 0; i < regionsSize; i++) {
@@ -75,17 +75,17 @@ uint32_t IoctlHelperPrelim20::createGemExt(Drm *drm, const MemRegionsVec &memCla
printDebugString(DebugManager.flags.PrintBOCreateDestroyResult.get(), stdout, "%s", " }\n");
}
auto ret = IoctlHelper::ioctl(drm, DrmIoctl::GemCreateExt, &createExt);
auto ret = IoctlHelper::ioctl(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;
return ret;
}
CacheRegion IoctlHelperPrelim20::closAlloc(Drm *drm) {
CacheRegion IoctlHelperPrelim20::closAlloc() {
struct prelim_drm_i915_gem_clos_reserve clos = {};
int ret = IoctlHelper::ioctl(drm, DrmIoctl::GemClosReserve, &clos);
int ret = IoctlHelper::ioctl(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));
@@ -96,14 +96,14 @@ CacheRegion IoctlHelperPrelim20::closAlloc(Drm *drm) {
return static_cast<CacheRegion>(clos.clos_index);
}
uint16_t IoctlHelperPrelim20::closAllocWays(Drm *drm, CacheRegion closIndex, uint16_t cacheLevel, uint16_t numWays) {
uint16_t IoctlHelperPrelim20::closAllocWays(CacheRegion closIndex, uint16_t cacheLevel, uint16_t numWays) {
struct prelim_drm_i915_gem_cache_reserve cache = {};
cache.clos_index = static_cast<uint16_t>(closIndex);
cache.cache_level = cacheLevel;
cache.num_ways = numWays;
int ret = IoctlHelper::ioctl(drm, DrmIoctl::GemCacheReserve, &cache);
int ret = IoctlHelper::ioctl(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));
@@ -113,12 +113,12 @@ uint16_t IoctlHelperPrelim20::closAllocWays(Drm *drm, CacheRegion closIndex, uin
return cache.num_ways;
}
CacheRegion IoctlHelperPrelim20::closFree(Drm *drm, CacheRegion closIndex) {
CacheRegion IoctlHelperPrelim20::closFree(CacheRegion closIndex) {
struct prelim_drm_i915_gem_clos_free clos = {};
clos.clos_index = static_cast<uint16_t>(closIndex);
int ret = IoctlHelper::ioctl(drm, DrmIoctl::GemClosFree, &clos);
int ret = IoctlHelper::ioctl(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));
@@ -129,7 +129,7 @@ CacheRegion IoctlHelperPrelim20::closFree(Drm *drm, CacheRegion closIndex) {
return closIndex;
}
int IoctlHelperPrelim20::waitUserFence(Drm *drm, uint32_t ctxId, uint64_t address,
int IoctlHelperPrelim20::waitUserFence(uint32_t ctxId, uint64_t address,
uint64_t value, uint32_t dataWidth, int64_t timeout, uint16_t flags) {
prelim_drm_i915_gem_wait_user_fence wait = {};
@@ -156,7 +156,7 @@ int IoctlHelperPrelim20::waitUserFence(Drm *drm, uint32_t ctxId, uint64_t addres
wait.value = value;
wait.timeout = timeout;
return IoctlHelper::ioctl(drm, DrmIoctl::GemWaitUserFence, &wait);
return IoctlHelper::ioctl(DrmIoctl::GemWaitUserFence, &wait);
}
uint32_t IoctlHelperPrelim20::getAtomicAdvise(bool isNonAtomic) {
@@ -167,7 +167,7 @@ uint32_t IoctlHelperPrelim20::getPreferredLocationAdvise() {
return PRELIM_I915_VM_ADVISE_PREFERRED_LOCATION;
}
bool IoctlHelperPrelim20::setVmBoAdvise(Drm *drm, int32_t handle, uint32_t attribute, void *region) {
bool IoctlHelperPrelim20::setVmBoAdvise(int32_t handle, uint32_t attribute, void *region) {
prelim_drm_i915_gem_vm_advise vmAdvise{};
vmAdvise.handle = handle;
@@ -176,7 +176,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, DrmIoctl::GemVmAdvise, &vmAdvise);
int ret = IoctlHelper::ioctl(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));
@@ -186,14 +186,14 @@ bool IoctlHelperPrelim20::setVmBoAdvise(Drm *drm, int32_t handle, uint32_t attri
return true;
}
bool IoctlHelperPrelim20::setVmPrefetch(Drm *drm, uint64_t start, uint64_t length, uint32_t region) {
bool IoctlHelperPrelim20::setVmPrefetch(uint64_t start, uint64_t length, uint32_t region) {
prelim_drm_i915_gem_vm_prefetch vmPrefetch{};
vmPrefetch.length = length;
vmPrefetch.region = region;
vmPrefetch.start = start;
int ret = IoctlHelper::ioctl(drm, DrmIoctl::GemVmPrefetch, &vmPrefetch);
int ret = IoctlHelper::ioctl(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));
@@ -211,7 +211,7 @@ uint16_t IoctlHelperPrelim20::getWaitUserFenceSoftFlag() {
return PRELIM_I915_UFENCE_WAIT_SOFT;
};
int IoctlHelperPrelim20::execBuffer(Drm *drm, ExecBuffer *execBuffer, uint64_t completionGpuAddress, uint32_t counterValue) {
int IoctlHelperPrelim20::execBuffer(ExecBuffer *execBuffer, uint64_t completionGpuAddress, uint32_t counterValue) {
prelim_drm_i915_gem_execbuffer_ext_user_fence fenceObject = {};
if (completionGpuAddress != 0) {
fenceObject.base.name = PRELIM_DRM_I915_GEM_EXECBUFFER_EXT_USER_FENCE;
@@ -224,7 +224,7 @@ int IoctlHelperPrelim20::execBuffer(Drm *drm, ExecBuffer *execBuffer, uint64_t c
drmExecBuffer.cliprects_ptr = castToUint64(&fenceObject);
}
return IoctlHelper::ioctl(drm, DrmIoctl::GemExecbuffer2, execBuffer);
return IoctlHelper::ioctl(DrmIoctl::GemExecbuffer2, execBuffer);
}
bool IoctlHelperPrelim20::completionFenceExtensionSupported(const bool isVmBindAvailable) {
@@ -271,7 +271,7 @@ prelim_drm_i915_query_distance_info translateToi915(const DistanceInfo &distance
return dist;
}
uint32_t IoctlHelperPrelim20::queryDistances(Drm *drm, std::vector<QueryItem> &queryItems, std::vector<DistanceInfo> &distanceInfos) {
uint32_t IoctlHelperPrelim20::queryDistances(std::vector<QueryItem> &queryItems, std::vector<DistanceInfo> &distanceInfos) {
std::vector<prelim_drm_i915_query_distance_info> i915Distances(distanceInfos.size());
std::transform(distanceInfos.begin(), distanceInfos.end(), i915Distances.begin(), translateToi915);
@@ -285,7 +285,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, DrmIoctl::Query, &query);
auto ret = IoctlHelper::ioctl(DrmIoctl::Query, &query);
for (auto i = 0u; i < i915Distances.size(); i++) {
distanceInfos[i].distance = i915Distances[i].distance;
}
@@ -352,17 +352,17 @@ uint32_t IoctlHelperPrelim20::getFlagsForVmCreate(bool disableScratch, bool enab
return flags;
}
uint32_t gemCreateContextExt(IoctlHelper &ioctlHelper, Drm *drm, GemContextCreateExt &gcc, GemContextCreateExtSetParam &extSetparam) {
uint32_t gemCreateContextExt(IoctlHelper &ioctlHelper, GemContextCreateExt &gcc, GemContextCreateExtSetParam &extSetparam) {
gcc.flags |= I915_CONTEXT_CREATE_FLAGS_USE_EXTENSIONS;
extSetparam.base.nextExtension = gcc.extensions;
gcc.extensions = reinterpret_cast<uint64_t>(&extSetparam);
auto ioctlResult = ioctlHelper.ioctl(drm, DrmIoctl::GemContextCreateExt, &gcc);
auto ioctlResult = ioctlHelper.ioctl(DrmIoctl::GemContextCreateExt, &gcc);
UNRECOVERABLE_IF(ioctlResult != 0);
return gcc.contextId;
}
uint32_t gemCreateContextAcc(IoctlHelper &ioctlHelper, Drm *drm, GemContextCreateExt &gcc, uint16_t trigger, uint8_t granularity) {
uint32_t gemCreateContextAcc(IoctlHelper &ioctlHelper, GemContextCreateExt &gcc, uint16_t trigger, uint8_t granularity) {
prelim_drm_i915_gem_context_param_acc paramAcc = {};
paramAcc.trigger = trigger;
paramAcc.notify = 1;
@@ -381,9 +381,9 @@ uint32_t gemCreateContextAcc(IoctlHelper &ioctlHelper, Drm *drm, GemContextCreat
extSetparam.base = userExt;
extSetparam.param = ctxParam;
return gemCreateContextExt(ioctlHelper, drm, gcc, extSetparam);
return gemCreateContextExt(ioctlHelper, gcc, extSetparam);
}
uint32_t IoctlHelperPrelim20::createContextWithAccessCounters(Drm *drm, GemContextCreateExt &gcc) {
uint32_t IoctlHelperPrelim20::createContextWithAccessCounters(GemContextCreateExt &gcc) {
uint16_t trigger = 0;
if (DebugManager.flags.AccessCountersTrigger.get() != -1) {
trigger = static_cast<uint16_t>(DebugManager.flags.AccessCountersTrigger.get());
@@ -392,14 +392,14 @@ uint32_t IoctlHelperPrelim20::createContextWithAccessCounters(Drm *drm, GemConte
if (DebugManager.flags.AccessCountersGranularity.get() != -1) {
granularity = static_cast<uint8_t>(DebugManager.flags.AccessCountersGranularity.get());
}
return gemCreateContextAcc(*this, drm, gcc, trigger, granularity);
return gemCreateContextAcc(*this, gcc, trigger, granularity);
}
uint32_t IoctlHelperPrelim20::createCooperativeContext(Drm *drm, GemContextCreateExt &gcc) {
uint32_t IoctlHelperPrelim20::createCooperativeContext(GemContextCreateExt &gcc) {
GemContextCreateExtSetParam extSetparam{};
extSetparam.base.name = I915_CONTEXT_CREATE_EXT_SETPARAM;
extSetparam.param.param = PRELIM_I915_CONTEXT_PARAM_RUNALONE;
return gemCreateContextExt(*this, drm, gcc, extSetparam);
return gemCreateContextExt(*this, gcc, extSetparam);
}
static_assert(sizeof(VmBindExtSetPatT) == sizeof(prelim_drm_i915_vm_bind_ext_set_pat), "Invalid size for VmBindExtSetPat");
@@ -454,24 +454,24 @@ prelim_drm_i915_gem_vm_bind translateVmBindParamsToPrelimStruct(const VmBindPara
return vmBind;
}
int IoctlHelperPrelim20::vmBind(Drm *drm, const VmBindParams &vmBindParams) {
int IoctlHelperPrelim20::vmBind(const VmBindParams &vmBindParams) {
auto prelimVmBind = translateVmBindParamsToPrelimStruct(vmBindParams);
return IoctlHelper::ioctl(drm, DrmIoctl::GemVmBind, &prelimVmBind);
return IoctlHelper::ioctl(DrmIoctl::GemVmBind, &prelimVmBind);
}
int IoctlHelperPrelim20::vmUnbind(Drm *drm, const VmBindParams &vmBindParams) {
int IoctlHelperPrelim20::vmUnbind(const VmBindParams &vmBindParams) {
auto prelimVmBind = translateVmBindParamsToPrelimStruct(vmBindParams);
return IoctlHelper::ioctl(drm, DrmIoctl::GemVmUnbind, &prelimVmBind);
return IoctlHelper::ioctl(DrmIoctl::GemVmUnbind, &prelimVmBind);
}
UuidRegisterResult IoctlHelperPrelim20::registerUuid(Drm *drm, const std::string &uuid, uint32_t uuidClass, uint64_t ptr, uint64_t size) {
UuidRegisterResult IoctlHelperPrelim20::registerUuid(const std::string &uuid, uint32_t uuidClass, uint64_t ptr, uint64_t size) {
prelim_drm_i915_uuid_control uuidControl = {};
memcpy_s(uuidControl.uuid, sizeof(uuidControl.uuid), uuid.c_str(), uuid.size());
uuidControl.uuid_class = uuidClass;
uuidControl.ptr = ptr;
uuidControl.size = size;
const auto retVal = IoctlHelper::ioctl(drm, DrmIoctl::UuidRegister, &uuidControl);
const auto retVal = IoctlHelper::ioctl(DrmIoctl::UuidRegister, &uuidControl);
return {
retVal,
@@ -479,36 +479,36 @@ UuidRegisterResult IoctlHelperPrelim20::registerUuid(Drm *drm, const std::string
};
}
UuidRegisterResult IoctlHelperPrelim20::registerStringClassUuid(Drm *drm, const std::string &uuid, uint64_t ptr, uint64_t size) {
return registerUuid(drm, uuid, PRELIM_I915_UUID_CLASS_STRING, ptr, size);
UuidRegisterResult IoctlHelperPrelim20::registerStringClassUuid(const std::string &uuid, uint64_t ptr, uint64_t size) {
return registerUuid(uuid, PRELIM_I915_UUID_CLASS_STRING, ptr, size);
}
int IoctlHelperPrelim20::unregisterUuid(Drm *drm, uint32_t handle) {
int IoctlHelperPrelim20::unregisterUuid(uint32_t handle) {
prelim_drm_i915_uuid_control uuidControl = {};
uuidControl.handle = handle;
return IoctlHelper::ioctl(drm, DrmIoctl::UuidUnregister, &uuidControl);
return IoctlHelper::ioctl(DrmIoctl::UuidUnregister, &uuidControl);
}
bool IoctlHelperPrelim20::isContextDebugSupported(Drm *drm) {
bool IoctlHelperPrelim20::isContextDebugSupported() {
drm_i915_gem_context_param ctxParam = {};
ctxParam.size = 0;
ctxParam.param = PRELIM_I915_CONTEXT_PARAM_DEBUG_FLAGS;
ctxParam.ctx_id = 0;
ctxParam.value = 0;
const auto retVal = IoctlHelper::ioctl(drm, DrmIoctl::GemContextGetparam, &ctxParam);
const auto retVal = IoctlHelper::ioctl(DrmIoctl::GemContextGetparam, &ctxParam);
return retVal == 0 && ctxParam.value == (PRELIM_I915_CONTEXT_PARAM_DEBUG_FLAG_SIP << 32);
}
int IoctlHelperPrelim20::setContextDebugFlag(Drm *drm, uint32_t drmContextId) {
int IoctlHelperPrelim20::setContextDebugFlag(uint32_t drmContextId) {
drm_i915_gem_context_param ctxParam = {};
ctxParam.size = 0;
ctxParam.param = PRELIM_I915_CONTEXT_PARAM_DEBUG_FLAGS;
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, DrmIoctl::GemContextSetparam, &ctxParam);
return IoctlHelper::ioctl(DrmIoctl::GemContextSetparam, &ctxParam);
}
bool IoctlHelperPrelim20::isDebugAttachAvailable() {

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

@@ -15,11 +15,11 @@
namespace NEO {
bool IoctlHelperUpstream::isVmBindAvailable(Drm *drm) {
bool IoctlHelperUpstream::isVmBindAvailable() {
return false;
}
uint32_t IoctlHelperUpstream::createGemExt(Drm *drm, const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle, std::optional<uint32_t> vmId) {
uint32_t IoctlHelperUpstream::createGemExt(const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle, std::optional<uint32_t> vmId) {
uint32_t regionsSize = static_cast<uint32_t>(memClassInstances.size());
std::vector<drm_i915_gem_memory_class_instance> regions(regionsSize);
for (uint32_t i = 0; i < regionsSize; i++) {
@@ -47,26 +47,26 @@ uint32_t IoctlHelperUpstream::createGemExt(Drm *drm, const MemRegionsVec &memCla
printDebugString(DebugManager.flags.PrintBOCreateDestroyResult.get(), stdout, "%s", " }\n");
}
auto ret = ioctl(drm, DrmIoctl::GemCreateExt, &createExt);
auto ret = ioctl(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;
return ret;
}
CacheRegion IoctlHelperUpstream::closAlloc(Drm *drm) {
CacheRegion IoctlHelperUpstream::closAlloc() {
return CacheRegion::None;
}
uint16_t IoctlHelperUpstream::closAllocWays(Drm *drm, CacheRegion closIndex, uint16_t cacheLevel, uint16_t numWays) {
uint16_t IoctlHelperUpstream::closAllocWays(CacheRegion closIndex, uint16_t cacheLevel, uint16_t numWays) {
return 0;
}
CacheRegion IoctlHelperUpstream::closFree(Drm *drm, CacheRegion closIndex) {
CacheRegion IoctlHelperUpstream::closFree(CacheRegion closIndex) {
return CacheRegion::None;
}
int IoctlHelperUpstream::waitUserFence(Drm *drm, uint32_t ctxId, uint64_t address,
int IoctlHelperUpstream::waitUserFence(uint32_t ctxId, uint64_t address,
uint64_t value, uint32_t dataWidth, int64_t timeout, uint16_t flags) {
return 0;
}
@@ -79,11 +79,11 @@ uint32_t IoctlHelperUpstream::getPreferredLocationAdvise() {
return 0;
}
bool IoctlHelperUpstream::setVmBoAdvise(Drm *drm, int32_t handle, uint32_t attribute, void *region) {
bool IoctlHelperUpstream::setVmBoAdvise(int32_t handle, uint32_t attribute, void *region) {
return true;
}
bool IoctlHelperUpstream::setVmPrefetch(Drm *drm, uint64_t start, uint64_t length, uint32_t region) {
bool IoctlHelperUpstream::setVmPrefetch(uint64_t start, uint64_t length, uint32_t region) {
return true;
}
@@ -99,7 +99,7 @@ uint64_t IoctlHelperUpstream::getFlagsForVmBind(bool bindCapture, bool bindImmed
return 0u;
}
uint32_t IoctlHelperUpstream::queryDistances(Drm *drm, std::vector<QueryItem> &queryItems, std::vector<DistanceInfo> &distanceInfos) {
uint32_t IoctlHelperUpstream::queryDistances(std::vector<QueryItem> &queryItems, std::vector<DistanceInfo> &distanceInfos) {
for (auto &query : queryItems) {
query.length = -EINVAL;
}
@@ -110,8 +110,8 @@ uint16_t IoctlHelperUpstream::getWaitUserFenceSoftFlag() {
return 0;
}
int IoctlHelperUpstream::execBuffer(Drm *drm, ExecBuffer *execBuffer, uint64_t completionGpuAddress, uint32_t counterValue) {
return ioctl(drm, DrmIoctl::GemExecbuffer2, execBuffer);
int IoctlHelperUpstream::execBuffer(ExecBuffer *execBuffer, uint64_t completionGpuAddress, uint32_t counterValue) {
return ioctl(DrmIoctl::GemExecbuffer2, execBuffer);
}
bool IoctlHelperUpstream::completionFenceExtensionSupported(const bool isVmBindAvailable) {
@@ -140,11 +140,11 @@ uint32_t IoctlHelperUpstream::getFlagsForVmCreate(bool disableScratch, bool enab
return 0u;
}
uint32_t IoctlHelperUpstream::createContextWithAccessCounters(Drm *drm, GemContextCreateExt &gcc) {
uint32_t IoctlHelperUpstream::createContextWithAccessCounters(GemContextCreateExt &gcc) {
return EINVAL;
}
uint32_t IoctlHelperUpstream::createCooperativeContext(Drm *drm, GemContextCreateExt &gcc) {
uint32_t IoctlHelperUpstream::createCooperativeContext(GemContextCreateExt &gcc) {
return EINVAL;
}
@@ -164,31 +164,31 @@ uint32_t IoctlHelperUpstream::getVmAdviseAtomicAttribute() {
return 0;
}
int IoctlHelperUpstream::vmBind(Drm *drm, const VmBindParams &vmBindParams) {
int IoctlHelperUpstream::vmBind(const VmBindParams &vmBindParams) {
return 0;
}
int IoctlHelperUpstream::vmUnbind(Drm *drm, const VmBindParams &vmBindParams) {
int IoctlHelperUpstream::vmUnbind(const VmBindParams &vmBindParams) {
return 0;
}
UuidRegisterResult IoctlHelperUpstream::registerUuid(Drm *drm, const std::string &uuid, uint32_t uuidClass, uint64_t ptr, uint64_t size) {
UuidRegisterResult IoctlHelperUpstream::registerUuid(const std::string &uuid, uint32_t uuidClass, uint64_t ptr, uint64_t size) {
return {0, 0};
}
UuidRegisterResult IoctlHelperUpstream::registerStringClassUuid(Drm *drm, const std::string &uuid, uint64_t ptr, uint64_t size) {
UuidRegisterResult IoctlHelperUpstream::registerStringClassUuid(const std::string &uuid, uint64_t ptr, uint64_t size) {
return {0, 0};
}
int IoctlHelperUpstream::unregisterUuid(Drm *drm, uint32_t handle) {
int IoctlHelperUpstream::unregisterUuid(uint32_t handle) {
return 0;
}
bool IoctlHelperUpstream::isContextDebugSupported(Drm *drm) {
bool IoctlHelperUpstream::isContextDebugSupported() {
return false;
}
int IoctlHelperUpstream::setContextDebugFlag(Drm *drm, uint32_t drmContextId) {
int IoctlHelperUpstream::setContextDebugFlag(uint32_t drmContextId) {
return 0;
}

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

@@ -18,8 +18,8 @@ extern bool isQueryDrmTip(const std::vector<uint8_t> &queryInfo);
extern std::vector<uint8_t> translateToDrmTip(const uint8_t *dataQuery);
template <>
uint32_t IoctlHelperImpl<gfxProduct>::createGemExt(Drm *drm, const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle, std::optional<uint32_t> vmId) {
auto ret = IoctlHelperUpstream::createGemExt(drm, memClassInstances, allocSize, handle, vmId);
uint32_t IoctlHelperImpl<gfxProduct>::createGemExt(const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle, std::optional<uint32_t> vmId) {
auto ret = IoctlHelperUpstream::createGemExt(memClassInstances, allocSize, handle, vmId);
if (ret == 0) {
return ret;
}
@@ -45,7 +45,7 @@ uint32_t IoctlHelperImpl<gfxProduct>::createGemExt(Drm *drm, const MemRegionsVec
createExt.size = allocSize;
createExt.extensions = reinterpret_cast<uintptr_t>(&setparamRegion);
ret = IoctlHelper::ioctl(drm, DrmIoctl::DG1GemCreateExt, &createExt);
ret = IoctlHelper::ioctl(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);

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

@@ -56,7 +56,7 @@ void MemoryInfo::assignRegionsFromDistances(const std::vector<DistanceInfo> &dis
}
uint32_t MemoryInfo::createGemExt(Drm *drm, const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle, std::optional<uint32_t> vmId) {
return drm->getIoctlHelper()->createGemExt(drm, memClassInstances, allocSize, handle, vmId);
return drm->getIoctlHelper()->createGemExt(memClassInstances, allocSize, handle, vmId);
}
uint32_t MemoryInfo::getTileIndex(uint32_t memoryBank, const HardwareInfo &hwInfo) {

2
shared/test/unit_test/os_interface/linux/drm_bind_tests.cpp
View File

@@ -59,5 +59,5 @@ TEST(DrmBindTest, whenCheckingVmBindAvailabilityThenIoctlHelperSupportIsUsed) {
DrmMock drm{*executionEnvironment->rootDeviceEnvironments[0]};
drm.callBaseIsVmBindAvailable = true;
EXPECT_EQ(drm.isVmBindAvailable(), drm.getIoctlHelper()->isVmBindAvailable(&drm));
EXPECT_EQ(drm.isVmBindAvailable(), drm.getIoctlHelper()->isVmBindAvailable());
}

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

@@ -66,9 +66,9 @@ TEST(IoctlHelperPrelimTest, whenGettingVmBindAvailabilityThenProperValueIsReturn
drm.context.vmBindQueryCalled = 0u;
if (ioctlValue == 0) {
EXPECT_EQ(hasVmBind, ioctlHelper.isVmBindAvailable(&drm));
EXPECT_EQ(hasVmBind, ioctlHelper.isVmBindAvailable());
} else {
EXPECT_FALSE(ioctlHelper.isVmBindAvailable(&drm));
EXPECT_FALSE(ioctlHelper.isVmBindAvailable());
}
EXPECT_EQ(1u, drm.context.vmBindQueryCalled);
}
@@ -86,7 +86,7 @@ TEST(IoctlHelperPrelimTest, whenVmBindIsCalledThenProperValueIsReturnedBasedOnIo
for (auto &ioctlValue : {0, EINVAL}) {
drm.context.vmBindReturn = ioctlValue;
drm.context.vmBindCalled = 0u;
EXPECT_EQ(ioctlValue, ioctlHelper.vmBind(&drm, vmBindParams));
EXPECT_EQ(ioctlValue, ioctlHelper.vmBind(vmBindParams));
EXPECT_EQ(1u, drm.context.vmBindCalled);
}
}
@@ -102,7 +102,7 @@ TEST(IoctlHelperPrelimTest, whenVmUnbindIsCalledThenProperValueIsReturnedBasedOn
for (auto &ioctlValue : {0, EINVAL}) {
drm.context.vmUnbindReturn = ioctlValue;
drm.context.vmUnbindCalled = 0u;
EXPECT_EQ(ioctlValue, ioctlHelper.vmUnbind(&drm, vmBindParams));
EXPECT_EQ(ioctlValue, ioctlHelper.vmUnbind(vmBindParams));
EXPECT_EQ(1u, drm.context.vmUnbindCalled);
}
}
@@ -112,7 +112,7 @@ TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenCreateGemExtThenReturnSuccess)
auto ioctlHelper = drm->getIoctlHelper();
uint32_t handle = 0;
MemRegionsVec memClassInstance = {{I915_MEMORY_CLASS_DEVICE, 0}};
auto ret = ioctlHelper->createGemExt(drm.get(), memClassInstance, 1024, handle, {});
auto ret = ioctlHelper->createGemExt(memClassInstance, 1024, handle, {});
EXPECT_EQ(1u, handle);
EXPECT_EQ(0u, ret);
@@ -127,7 +127,7 @@ TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenCreateGemExtWithDebugFlagThenPr
auto ioctlHelper = drm->getIoctlHelper();
uint32_t handle = 0;
MemRegionsVec memClassInstance = {{I915_MEMORY_CLASS_DEVICE, 0}};
ioctlHelper->createGemExt(drm.get(), memClassInstance, 1024, handle, {});
ioctlHelper->createGemExt(memClassInstance, 1024, handle, {});
std::string output = testing::internal::GetCapturedStdout();
std::string expectedOutput("Performing GEM_CREATE_EXT with { size: 1024, param: 0x1000000010001, memory class: 1, memory instance: 0 }\nGEM_CREATE_EXT has returned: 0 BO-1 with size: 1024\n");
@@ -137,7 +137,7 @@ TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenCreateGemExtWithDebugFlagThenPr
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenCallIoctlThenProperIoctlRegistered) {
GemContextCreateExt arg{};
drm->ioctlCallsCount = 0;
auto ret = drm->ioctlHelper->ioctl(drm.get(), DrmIoctl::GemContextCreateExt, &arg);
auto ret = drm->ioctlHelper->ioctl(DrmIoctl::GemContextCreateExt, &arg);
EXPECT_EQ(0u, ret);
EXPECT_EQ(1u, drm->ioctlCallsCount);
}
@@ -145,7 +145,7 @@ TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenCallIoctlThenProperIoctlRegiste
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenClosAllocThenReturnCorrectRegion) {
drm->ioctlCallsCount = 0;
auto ioctlHelper = drm->getIoctlHelper();
auto cacheRegion = ioctlHelper->closAlloc(drm.get());
auto cacheRegion = ioctlHelper->closAlloc();
EXPECT_EQ(CacheRegion::Region1, cacheRegion);
EXPECT_EQ(1u, drm->ioctlCallsCount);
@@ -155,7 +155,7 @@ TEST_F(IoctlHelperPrelimFixture, givenPrelimsAndInvalidIoctlReturnValWhenClosAll
drm->ioctlRetVal = -1;
drm->ioctlCallsCount = 0;
auto ioctlHelper = drm->getIoctlHelper();
auto cacheRegion = ioctlHelper->closAlloc(drm.get());
auto cacheRegion = ioctlHelper->closAlloc();
EXPECT_EQ(CacheRegion::None, cacheRegion);
EXPECT_EQ(1u, drm->ioctlCallsCount);
@@ -164,7 +164,7 @@ TEST_F(IoctlHelperPrelimFixture, givenPrelimsAndInvalidIoctlReturnValWhenClosAll
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenClosFreeThenReturnCorrectRegion) {
auto ioctlHelper = drm->getIoctlHelper();
drm->ioctlCallsCount = 0;
auto cacheRegion = ioctlHelper->closFree(drm.get(), CacheRegion::Region2);
auto cacheRegion = ioctlHelper->closFree(CacheRegion::Region2);
EXPECT_EQ(CacheRegion::Region2, cacheRegion);
EXPECT_EQ(1u, drm->ioctlCallsCount);
@@ -175,7 +175,7 @@ TEST_F(IoctlHelperPrelimFixture, givenPrelimsAndInvalidIoctlReturnValWhenClosFre
drm->ioctlCallsCount = 0;
auto ioctlHelper = drm->getIoctlHelper();
auto cacheRegion = ioctlHelper->closFree(drm.get(), CacheRegion::Region2);
auto cacheRegion = ioctlHelper->closFree(CacheRegion::Region2);
EXPECT_EQ(CacheRegion::None, cacheRegion);
EXPECT_EQ(1u, drm->ioctlCallsCount);
@@ -184,7 +184,7 @@ TEST_F(IoctlHelperPrelimFixture, givenPrelimsAndInvalidIoctlReturnValWhenClosFre
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenClosAllocWaysThenReturnCorrectRegion) {
drm->ioctlCallsCount = 0;
auto ioctlHelper = drm->getIoctlHelper();
auto numWays = ioctlHelper->closAllocWays(drm.get(), CacheRegion::Region2, 3, 10);
auto numWays = ioctlHelper->closAllocWays(CacheRegion::Region2, 3, 10);
EXPECT_EQ(10u, numWays);
EXPECT_EQ(1u, drm->ioctlCallsCount);
@@ -195,7 +195,7 @@ TEST_F(IoctlHelperPrelimFixture, givenPrelimsAndInvalidIoctlReturnValWhenClosAll
drm->ioctlCallsCount = 0;
auto ioctlHelper = drm->getIoctlHelper();
auto numWays = ioctlHelper->closAllocWays(drm.get(), CacheRegion::Region2, 3, 10);
auto numWays = ioctlHelper->closAllocWays(CacheRegion::Region2, 3, 10);
EXPECT_EQ(0u, numWays);
EXPECT_EQ(1u, drm->ioctlCallsCount);
@@ -206,7 +206,7 @@ TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenWaitUserFenceThenCorrectValueRe
uint64_t value = 0x98765ull;
auto ioctlHelper = drm->getIoctlHelper();
for (uint32_t i = 0u; i < 4; i++) {
auto ret = ioctlHelper->waitUserFence(drm.get(), 10u, gpuAddress, value, i, -1, 0u);
auto ret = ioctlHelper->waitUserFence(10u, gpuAddress, value, i, -1, 0u);
EXPECT_EQ(0, ret);
}
}
@@ -316,7 +316,7 @@ TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenQueryDistancesThenCorrectDistan
distances[2].engine = {static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::EngineClassCopy)), 4};
distances[2].region = {I915_MEMORY_CLASS_DEVICE, 2};
std::vector<QueryItem> queryItems(distances.size());
auto ret = ioctlHelper->queryDistances(drm.get(), queryItems, distances);
auto ret = ioctlHelper->queryDistances(queryItems, distances);
EXPECT_EQ(0u, ret);
EXPECT_EQ(0, distances[0].distance);
EXPECT_EQ(0, distances[1].distance);
@@ -415,7 +415,7 @@ TEST_F(IoctlHelperPrelimFixture, givenIoctlFailureWhenCreateContextWithAccessCou
auto ioctlHelper = drm->getIoctlHelper();
GemContextCreateExt gcc{};
EXPECT_THROW(ioctlHelper->createContextWithAccessCounters(drm.get(), gcc), std::runtime_error);
EXPECT_THROW(ioctlHelper->createContextWithAccessCounters(gcc), std::runtime_error);
EXPECT_EQ(1u, drm->ioctlCallsCount);
}
@@ -425,7 +425,7 @@ TEST_F(IoctlHelperPrelimFixture, givenIoctlSuccessWhenCreateContextWithAccessCou
auto ioctlHelper = drm->getIoctlHelper();
GemContextCreateExt gcc{};
EXPECT_EQ(0u, ioctlHelper->createContextWithAccessCounters(drm.get(), gcc));
EXPECT_EQ(0u, ioctlHelper->createContextWithAccessCounters(gcc));
EXPECT_EQ(1u, drm->ioctlCallsCount);
}
@@ -435,7 +435,7 @@ TEST_F(IoctlHelperPrelimFixture, givenIoctlFailureWhenCreateCooperativeContexIsC
auto ioctlHelper = drm->getIoctlHelper();
GemContextCreateExt gcc{};
EXPECT_THROW(ioctlHelper->createCooperativeContext(drm.get(), gcc), std::runtime_error);
EXPECT_THROW(ioctlHelper->createCooperativeContext(gcc), std::runtime_error);
EXPECT_EQ(1u, drm->ioctlCallsCount);
}
@@ -445,7 +445,7 @@ TEST_F(IoctlHelperPrelimFixture, givenIoctlSuccessWhenCreateCooperativeContexIsC
auto ioctlHelper = drm->getIoctlHelper();
GemContextCreateExt gcc{};
EXPECT_EQ(0u, ioctlHelper->createCooperativeContext(drm.get(), gcc));
EXPECT_EQ(0u, ioctlHelper->createCooperativeContext(gcc));
EXPECT_EQ(1u, drm->ioctlCallsCount);
}

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

@@ -25,7 +25,7 @@ DG1TEST_F(IoctlHelperTestsDg1, givenDg1WhenCreateGemExtThenReturnCorrectValue) {
auto ioctlHelper = drm->getIoctlHelper();
uint32_t handle = 0;
MemRegionsVec memClassInstance = {{I915_MEMORY_CLASS_DEVICE, 0}};
auto ret = ioctlHelper->createGemExt(drm.get(), memClassInstance, 1024, handle, {});
auto ret = ioctlHelper->createGemExt(memClassInstance, 1024, handle, {});
EXPECT_EQ(0u, ret);
EXPECT_EQ(1u, handle);
@@ -47,7 +47,7 @@ DG1TEST_F(IoctlHelperTestsDg1, givenDg1WithDrmTipWhenCreateGemExtWithDebugFlagTh
auto ioctlHelper = drm->getIoctlHelper();
uint32_t handle = 0;
MemRegionsVec memClassInstance = {{I915_MEMORY_CLASS_DEVICE, 0}};
auto ret = ioctlHelper->createGemExt(drm.get(), memClassInstance, 1024, handle, {});
auto ret = ioctlHelper->createGemExt(memClassInstance, 1024, handle, {});
std::string output = testing::internal::GetCapturedStdout();
std::string expectedOutput("Performing GEM_CREATE_EXT with { size: 1024, memory class: 1, memory instance: 0 }\nGEM_CREATE_EXT with EXT_MEMORY_REGIONS has returned: 0 BO-1 with size: 1024\n");
@@ -68,7 +68,7 @@ DG1TEST_F(IoctlHelperTestsDg1, givenDg1WhenCreateGemExtWithDebugFlagThenPrintDeb
auto ioctlHelper = drm->getIoctlHelper();
uint32_t handle = 0;
MemRegionsVec memClassInstance = {{I915_MEMORY_CLASS_DEVICE, 0}};
auto ret = ioctlHelper->createGemExt(drm.get(), memClassInstance, 1024, handle, {});
auto ret = ioctlHelper->createGemExt(memClassInstance, 1024, handle, {});
std::string output = testing::internal::GetCapturedStdout();
std::string expectedOutput("Performing GEM_CREATE_EXT with { size: 1024, memory class: 1, memory instance: 0 }\nGEM_CREATE_EXT with EXT_MEMORY_REGIONS has returned: -1 BO-0 with size: 1024\nGEM_CREATE_EXT with EXT_SETPARAM has returned: 0 BO-1 with size: 1024\n");

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

@@ -18,7 +18,7 @@ TEST(IoctlHelperUpstreamTest, whenGettingVmBindAvailabilityThenFalseIsReturned)
auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
IoctlHelperUpstream ioctlHelper{*drm};
EXPECT_FALSE(ioctlHelper.isVmBindAvailable(drm.get()));
EXPECT_FALSE(ioctlHelper.isVmBindAvailable());
}
TEST(IoctlHelperUpstreamTest, whenGettingIoctlRequestValueThenPropertValueIsReturned) {
@@ -147,7 +147,7 @@ TEST(IoctlHelperTestsUpstream, givenUpstreamWhenCreateGemExtThenReturnCorrectVal
auto ioctlHelper = drm->getIoctlHelper();
uint32_t handle = 0;
MemRegionsVec memClassInstance = {{I915_MEMORY_CLASS_DEVICE, 0}};
auto ret = ioctlHelper->createGemExt(drm.get(), memClassInstance, 1024, handle, {});
auto ret = ioctlHelper->createGemExt(memClassInstance, 1024, handle, {});
EXPECT_EQ(0u, ret);
EXPECT_EQ(1u, handle);
@@ -168,7 +168,7 @@ TEST(IoctlHelperTestsUpstream, givenUpstreamWhenCreateGemExtWithDebugFlagThenPri
auto ioctlHelper = drm->getIoctlHelper();
uint32_t handle = 0;
MemRegionsVec memClassInstance = {{I915_MEMORY_CLASS_DEVICE, 0}};
ioctlHelper->createGemExt(drm.get(), memClassInstance, 1024, handle, {});
ioctlHelper->createGemExt(memClassInstance, 1024, handle, {});
std::string output = testing::internal::GetCapturedStdout();
std::string expectedOutput("Performing GEM_CREATE_EXT with { size: 1024, memory class: 1, memory instance: 0 }\nGEM_CREATE_EXT with EXT_MEMORY_REGIONS has returned: 0 BO-1 with size: 1024\n");
@@ -181,7 +181,7 @@ TEST(IoctlHelperTestsUpstream, givenUpstreamWhenClosAllocThenReturnNoneRegion) {
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
auto ioctlHelper = drm->getIoctlHelper();
auto cacheRegion = ioctlHelper->closAlloc(drm.get());
auto cacheRegion = ioctlHelper->closAlloc();
EXPECT_EQ(CacheRegion::None, cacheRegion);
}
@@ -192,7 +192,7 @@ TEST(IoctlHelperTestsUpstream, givenUpstreamWhenClosFreeThenReturnNoneRegion) {
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
auto ioctlHelper = drm->getIoctlHelper();
auto cacheRegion = ioctlHelper->closFree(drm.get(), CacheRegion::Region2);
auto cacheRegion = ioctlHelper->closFree(CacheRegion::Region2);
EXPECT_EQ(CacheRegion::None, cacheRegion);
}
@@ -203,7 +203,7 @@ TEST(IoctlHelperTestsUpstream, givenUpstreamWhenClosAllocWaysThenReturnZeroWays)
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
auto ioctlHelper = drm->getIoctlHelper();
auto cacheRegion = ioctlHelper->closAllocWays(drm.get(), CacheRegion::Region2, 3, 10);
auto cacheRegion = ioctlHelper->closAllocWays(CacheRegion::Region2, 3, 10);
EXPECT_EQ(0, cacheRegion);
}
@@ -225,7 +225,7 @@ TEST(IoctlHelperTestsUpstream, givenUpstreamWhenSetVmBoAdviseThenReturnTrue) {
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
auto ioctlHelper = drm->getIoctlHelper();
EXPECT_TRUE(ioctlHelper->setVmBoAdvise(drm.get(), 0, 0, nullptr));
EXPECT_TRUE(ioctlHelper->setVmBoAdvise(0, 0, nullptr));
}
TEST(IoctlHelperTestsUpstream, givenUpstreamWhenSetVmPrefetchThenReturnTrue) {
@@ -234,7 +234,7 @@ TEST(IoctlHelperTestsUpstream, givenUpstreamWhenSetVmPrefetchThenReturnTrue) {
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
auto ioctlHelper = drm->getIoctlHelper();
EXPECT_TRUE(ioctlHelper->setVmPrefetch(drm.get(), 0, 0, 0));
EXPECT_TRUE(ioctlHelper->setVmPrefetch(0, 0, 0));
}
TEST(IoctlHelperTestsUpstream, givenUpstreamWhenDirectSubmissionEnabledThenNoFlagsAdded) {
@@ -258,7 +258,7 @@ TEST(IoctlHelperTestsUpstream, givenUpstreamWhenQueryDistancesThenReturnEinval)
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
std::vector<DistanceInfo> distanceInfos;
std::vector<QueryItem> queries(4);
auto ret = drm->getIoctlHelper()->queryDistances(drm.get(), queries, distanceInfos);
auto ret = drm->getIoctlHelper()->queryDistances(queries, distanceInfos);
EXPECT_EQ(0u, ret);
const bool queryUnsupported = std::all_of(queries.begin(), queries.end(),
[](const QueryItem &item) { return item.length == -EINVAL; });
@@ -315,7 +315,7 @@ TEST(IoctlHelperTestsUpstream, whenCreateContextWithAccessCountersIsCalledThenEr
GemContextCreateExt gcc{};
IoctlHelperUpstream ioctlHelper{*drm};
EXPECT_EQ(static_cast<uint32_t>(EINVAL), ioctlHelper.createContextWithAccessCounters(drm.get(), gcc));
EXPECT_EQ(static_cast<uint32_t>(EINVAL), ioctlHelper.createContextWithAccessCounters(gcc));
}
TEST(IoctlHelperTestsUpstream, whenCreateCooperativeContexIsCalledThenErrorIsReturned) {
@@ -326,7 +326,7 @@ TEST(IoctlHelperTestsUpstream, whenCreateCooperativeContexIsCalledThenErrorIsRet
GemContextCreateExt gcc{};
IoctlHelperUpstream ioctlHelper{*drm};
EXPECT_EQ(static_cast<uint32_t>(EINVAL), ioctlHelper.createCooperativeContext(drm.get(), gcc));
EXPECT_EQ(static_cast<uint32_t>(EINVAL), ioctlHelper.createCooperativeContext(gcc));
}
TEST(IoctlHelperTestsUpstream, whenFillVmBindSetPatThenNothingThrows) {
@@ -352,7 +352,7 @@ TEST(IoctlHelperTestsUpstream, whenVmBindIsCalledThenZeroIsReturned) {
VmBindParams vmBindParams{};
IoctlHelperUpstream ioctlHelper{*drm};
EXPECT_EQ(0, ioctlHelper.vmBind(drm.get(), vmBindParams));
EXPECT_EQ(0, ioctlHelper.vmBind(vmBindParams));
}
TEST(IoctlHelperTestsUpstream, whenVmUnbindIsCalledThenZeroIsReturned) {
@@ -362,7 +362,7 @@ TEST(IoctlHelperTestsUpstream, whenVmUnbindIsCalledThenZeroIsReturned) {
IoctlHelperUpstream ioctlHelper{*drm};
VmBindParams vmBindParams{};
EXPECT_EQ(0, ioctlHelper.vmUnbind(drm.get(), vmBindParams));
EXPECT_EQ(0, ioctlHelper.vmUnbind(vmBindParams));
}
TEST(IoctlHelperTestsUpstream, givenUpstreamWhenGettingEuStallPropertiesThenFailureIsReturned) {
@@ -387,13 +387,13 @@ TEST(IoctlHelperTestsUpstream, whenRegisterUuidIsCalledThenReturnNullHandle) {
IoctlHelperUpstream ioctlHelper{*drm};
{
const auto [retVal, handle] = ioctlHelper.registerUuid(drm.get(), "", 0, 0, 0);
const auto [retVal, handle] = ioctlHelper.registerUuid("", 0, 0, 0);
EXPECT_EQ(0u, retVal);
EXPECT_EQ(0u, handle);
}
{
const auto [retVal, handle] = ioctlHelper.registerStringClassUuid(drm.get(), "", 0, 0);
const auto [retVal, handle] = ioctlHelper.registerStringClassUuid("", 0, 0);
EXPECT_EQ(0u, retVal);
EXPECT_EQ(0u, handle);
}
@@ -404,7 +404,7 @@ TEST(IoctlHelperTestsUpstream, whenUnregisterUuidIsCalledThenZeroIsReturned) {
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
IoctlHelperUpstream ioctlHelper{*drm};
EXPECT_EQ(0, ioctlHelper.unregisterUuid(drm.get(), 0));
EXPECT_EQ(0, ioctlHelper.unregisterUuid(0));
}
TEST(IoctlHelperTestsUpstream, whenIsContextDebugSupportedIsCalledThenFalseIsReturned) {
@@ -412,7 +412,7 @@ TEST(IoctlHelperTestsUpstream, whenIsContextDebugSupportedIsCalledThenFalseIsRet
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
IoctlHelperUpstream ioctlHelper{*drm};
EXPECT_EQ(false, ioctlHelper.isContextDebugSupported(drm.get()));
EXPECT_EQ(false, ioctlHelper.isContextDebugSupported());
}
TEST(IoctlHelperTestsUpstream, whenSetContextDebugFlagIsCalledThenZeroIsReturned) {
@@ -420,5 +420,5 @@ TEST(IoctlHelperTestsUpstream, whenSetContextDebugFlagIsCalledThenZeroIsReturned
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
IoctlHelperUpstream ioctlHelper{*drm};
EXPECT_EQ(0, ioctlHelper.setContextDebugFlag(drm.get(), 0));
EXPECT_EQ(0, ioctlHelper.setContextDebugFlag(0));
}