Skip to content

Commit 1e0f0ef

Browse files
HoppeMateuszCompute-Runtime-Automation
HoppeMateusz
authored and
Compute-Runtime-Automation
committed
L0Debug - auto ack ISA VM BIND events when module created before attach
- Fix missing ACKs for VM BIND events when module was created before debugger attaches Related-To: NEO-6960 Signed-off-by: Mateusz Hoppe <[email protected]>
1 parent e07bf76 commit 1e0f0ef

File tree

2 files changed

+202
-3
lines changed

2 files changed

+202
-3
lines changed

‎level_zero/tools/source/debug/linux/prelim/debug_session.cpp‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -812,6 +812,11 @@ void DebugSessionLinux::handleVmBindEvent(prelim_drm_i915_debug_event_vm_bind *v
812812

813813
std::unique_lock<std::mutex> memLock(asyncThreadMutex);
814814
isaMap[vmBind->va_start] = std::move(isa);
815+
816+
// If ACK flag is not set when triggering MODULE LOAD event, auto-ack immediately
817+
if ((vmBind->base.flags & PRELIM_DRM_I915_DEBUG_EVENT_NEED_ACK) == 0) {
818+
connection->isaMap[vmBind->va_start]->moduleLoadEventAck = true;
819+
}
815820
memLock.unlock();
816821

817822
if (perKernelModules) {

‎level_zero/tools/test/unit_tests/sources/debug/linux/test_debug_api_linux.cpp‎

Lines changed: 197 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -3569,7 +3569,7 @@ struct DebugApiLinuxVmBindFixture : public DebugApiLinuxFixture {
35693569
ASSERT_NE(nullptr, session);
35703570
session->clientHandle = MockDebugSessionLinux::mockClientHandle;
35713571

3572-
auto handler = new MockIoctlHandler;
3572+
handler = new MockIoctlHandler;
35733573
session->ioctlHandler.reset(handler);
35743574

35753575
session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->classHandleToIndex[sbaClassHandle] = {"SBA AREA", static_cast<uint32_t>(NEO::DrmResourceClass::SbaTrackingBuffer)};
@@ -3643,6 +3643,7 @@ struct DebugApiLinuxVmBindFixture : public DebugApiLinuxFixture {
36433643
const uint64_t stateSaveUUID = 8;
36443644
const uint64_t zebinModuleUUID = 9;
36453645

3646+
MockIoctlHandler *handler = nullptr;
36463647
std::unique_ptr<MockDebugSessionLinux> session;
36473648
};
36483649

@@ -3844,6 +3845,55 @@ TEST_F(DebugApiLinuxVmBindTest, GivenEventForISAWhenModuleLoadEventAlreadyAckedT
38443845
EXPECT_EQ(0u, isaIter->second->ackEvents.size());
38453846
}
38463847

3848+
TEST_F(DebugApiLinuxVmBindTest, GivenEventForIsaWithoutAckTriggeredBeforeAttachWhenHandlingSubsequentEventsWithAckThenEventsAreAckedImmediatelyAndNotPushed) {
3849+
uint64_t isaGpuVa = 0x345000;
3850+
uint64_t isaSize = 0x2000;
3851+
uint64_t vmBindIsaData[sizeof(prelim_drm_i915_debug_event_vm_bind) / sizeof(uint64_t) + 3 * sizeof(typeOfUUID)];
3852+
prelim_drm_i915_debug_event_vm_bind *vmBindIsa = reinterpret_cast<prelim_drm_i915_debug_event_vm_bind *>(&vmBindIsaData);
3853+
3854+
vmBindIsa->base.type = PRELIM_DRM_I915_DEBUG_EVENT_VM_BIND;
3855+
// CREATE flag without ACK - triggered before attach
3856+
vmBindIsa->base.flags = PRELIM_DRM_I915_DEBUG_EVENT_CREATE;
3857+
vmBindIsa->base.size = sizeof(prelim_drm_i915_debug_event_vm_bind) + 3 * sizeof(typeOfUUID);
3858+
vmBindIsa->base.seqno = 20u;
3859+
vmBindIsa->client_handle = MockDebugSessionLinux::mockClientHandle;
3860+
vmBindIsa->va_start = isaGpuVa;
3861+
vmBindIsa->va_length = isaSize;
3862+
vmBindIsa->vm_handle = vmHandleForVmBind;
3863+
vmBindIsa->num_uuids = 3;
3864+
3865+
auto *uuids = reinterpret_cast<typeOfUUID *>(ptrOffset(vmBindIsaData, sizeof(prelim_drm_i915_debug_event_vm_bind)));
3866+
3867+
typeOfUUID uuidsTemp[3];
3868+
uuidsTemp[0] = static_cast<typeOfUUID>(isaUUID);
3869+
uuidsTemp[1] = static_cast<typeOfUUID>(cookieUUID);
3870+
uuidsTemp[2] = static_cast<typeOfUUID>(elfUUID);
3871+
3872+
memcpy(uuids, uuidsTemp, sizeof(uuidsTemp));
3873+
3874+
session->handleEvent(&vmBindIsa->base);
3875+
3876+
auto isaIter = session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->isaMap.find(isaGpuVa);
3877+
ASSERT_NE(session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->isaMap.end(), isaIter);
3878+
EXPECT_EQ(0u, isaIter->second->ackEvents.size());
3879+
// Auto-acked event
3880+
EXPECT_TRUE(isaIter->second->moduleLoadEventAck);
3881+
3882+
auto event = session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->apiEvents.front();
3883+
session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->apiEvents.pop();
3884+
EXPECT_EQ(0u, event.flags & ZET_DEBUG_EVENT_FLAG_NEED_ACK);
3885+
3886+
// VM BIND after attach needs ACK
3887+
vmBindIsa->base.flags = PRELIM_DRM_I915_DEBUG_EVENT_CREATE | PRELIM_DRM_I915_DEBUG_EVENT_NEED_ACK;
3888+
vmBindIsa->base.seqno = 150;
3889+
vmBindIsa->vm_handle = vmHandleForVmBind + 100;
3890+
3891+
session->handleEvent(&vmBindIsa->base);
3892+
3893+
EXPECT_EQ(0u, isaIter->second->ackEvents.size());
3894+
EXPECT_EQ(vmBindIsa->base.seqno, handler->debugEventAcked.seqno);
3895+
}
3896+
38473897
TEST_F(DebugApiLinuxVmBindTest, GivenIsaRemovedWhenModuleLoadEventIsAckedThenSuccessReturned) {
38483898
uint64_t isaGpuVa = 0x345000;
38493899
uint64_t isaSize = 0x2000;
@@ -3902,15 +3952,16 @@ TEST_F(DebugApiLinuxVmBindTest, GivenVmBindEventWithInvalidNumUUIDsWhenHandlingE
39023952
EXPECT_EQ(0u, session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->vmToStateBaseAreaBindInfo.size());
39033953
}
39043954

3905-
TEST_F(DebugApiLinuxVmBindTest, GivenVmBindEventForIsaWhenHandlingEventThenIsaAllocationIsSaved) {
3955+
TEST_F(DebugApiLinuxVmBindTest, GivenVmBindEventWithAckNeededForIsaWhenHandlingEventThenIsaAllocationIsSavedWithEventToAck) {
39063956
uint64_t isaGpuVa = 0x345000;
39073957
uint64_t isaSize = 0x2000;
39083958
uint64_t vmBindIsaData[sizeof(prelim_drm_i915_debug_event_vm_bind) / sizeof(uint64_t) + 3 * sizeof(typeOfUUID)];
39093959
prelim_drm_i915_debug_event_vm_bind *vmBindIsa = reinterpret_cast<prelim_drm_i915_debug_event_vm_bind *>(&vmBindIsaData);
39103960

39113961
vmBindIsa->base.type = PRELIM_DRM_I915_DEBUG_EVENT_VM_BIND;
3912-
vmBindIsa->base.flags = PRELIM_DRM_I915_DEBUG_EVENT_CREATE;
3962+
vmBindIsa->base.flags = PRELIM_DRM_I915_DEBUG_EVENT_CREATE | PRELIM_DRM_I915_DEBUG_EVENT_NEED_ACK;
39133963
vmBindIsa->base.size = sizeof(prelim_drm_i915_debug_event_vm_bind) + 3 * sizeof(typeOfUUID);
3964+
vmBindIsa->base.seqno = 3;
39143965
vmBindIsa->client_handle = MockDebugSessionLinux::mockClientHandle;
39153966
vmBindIsa->va_start = isaGpuVa;
39163967
vmBindIsa->va_length = isaSize;
@@ -3926,6 +3977,8 @@ TEST_F(DebugApiLinuxVmBindTest, GivenVmBindEventForIsaWhenHandlingEventThenIsaAl
39263977

39273978
memcpy(uuids, uuidsTemp, sizeof(uuidsTemp));
39283979

3980+
EXPECT_EQ(0u, session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->eventsToAck.size());
3981+
39293982
session->handleEvent(&vmBindIsa->base);
39303983

39313984
auto &isaMap = session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->isaMap;
@@ -3940,6 +3993,12 @@ TEST_F(DebugApiLinuxVmBindTest, GivenVmBindEventForIsaWhenHandlingEventThenIsaAl
39403993
EXPECT_EQ(3u, isaAllocation->vmHandle);
39413994
EXPECT_EQ(1u, isaAllocation->cookies.size());
39423995
EXPECT_EQ(cookieUUID, *isaAllocation->cookies.begin());
3996+
3997+
ASSERT_EQ(1u, session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->eventsToAck.size());
3998+
auto eventToAck = session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->eventsToAck[0].second;
3999+
EXPECT_EQ(vmBindIsa->base.type, eventToAck.type);
4000+
EXPECT_EQ(vmBindIsa->base.seqno, eventToAck.seqno);
4001+
EXPECT_EQ(0u, handler->debugEventAcked.seqno);
39434002
}
39444003

39454004
TEST_F(DebugApiLinuxVmBindTest, GivenTwoVmBindEventForTheSameIsaInDifferentVMWhenHandlingEventThenIsaVmHandleIsNotOverriden) {
@@ -4193,8 +4252,124 @@ TEST_F(DebugApiLinuxVmBindTest, GivenEventWithL0ZebinModuleWhenHandlingEventThen
41934252
session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->uuidMap[elfUUID].ptr = 0x1000;
41944253

41954254
vmBindIsa->base.type = PRELIM_DRM_I915_DEBUG_EVENT_VM_BIND;
4255+
vmBindIsa->base.flags = PRELIM_DRM_I915_DEBUG_EVENT_CREATE | PRELIM_DRM_I915_DEBUG_EVENT_NEED_ACK;
4256+
vmBindIsa->base.size = sizeof(prelim_drm_i915_debug_event_vm_bind) + 3 * sizeof(typeOfUUID);
4257+
vmBindIsa->base.seqno = 10;
4258+
vmBindIsa->client_handle = MockDebugSessionLinux::mockClientHandle;
4259+
vmBindIsa->va_start = isaGpuVa;
4260+
vmBindIsa->va_length = isaSize;
4261+
vmBindIsa->vm_handle = vmHandleForVmBind;
4262+
vmBindIsa->num_uuids = 4;
4263+
auto *uuids = reinterpret_cast<typeOfUUID *>(ptrOffset(vmBindIsaData, sizeof(prelim_drm_i915_debug_event_vm_bind)));
4264+
typeOfUUID uuidsTemp[4];
4265+
uuidsTemp[0] = static_cast<typeOfUUID>(isaUUID);
4266+
uuidsTemp[1] = static_cast<typeOfUUID>(cookieUUID);
4267+
uuidsTemp[2] = static_cast<typeOfUUID>(elfUUID);
4268+
uuidsTemp[3] = static_cast<typeOfUUID>(zebinModuleUUID);
4269+
4270+
memcpy(uuids, uuidsTemp, sizeof(uuidsTemp));
4271+
session->handleEvent(&vmBindIsa->base);
4272+
4273+
EXPECT_EQ(0u, session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->apiEvents.size());
4274+
EXPECT_EQ(1u, session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->uuidToModule.size());
4275+
EXPECT_EQ(1u, session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->uuidToModule[zebinModuleUUID].loadAddresses.size());
4276+
4277+
// event not pushed to ack
4278+
EXPECT_EQ(0u, session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->isaMap[isaGpuVa]->ackEvents.size());
4279+
EXPECT_EQ(1, handler->ioctlCalled); // ACK
4280+
EXPECT_EQ(vmBindIsa->base.seqno, handler->debugEventAcked.seqno);
4281+
4282+
vmBindIsa->va_start = isaGpuVa2;
4283+
vmBindIsa->base.seqno = 11;
4284+
handler->ioctlCalled = 0;
4285+
handler->debugEventAcked.seqno = 0;
4286+
4287+
session->handleEvent(&vmBindIsa->base);
4288+
4289+
EXPECT_EQ(1u, session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->apiEvents.size());
4290+
EXPECT_EQ(1u, session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->uuidToModule.size());
4291+
EXPECT_EQ(2u, session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->uuidToModule[zebinModuleUUID].loadAddresses.size());
4292+
EXPECT_EQ(2u, session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->uuidToModule[zebinModuleUUID].segmentCount);
4293+
4294+
// event not pushed to ack
4295+
EXPECT_EQ(0u, session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->isaMap[isaGpuVa2]->ackEvents.size());
4296+
EXPECT_EQ(0, handler->ioctlCalled);
4297+
EXPECT_EQ(0u, handler->debugEventAcked.seqno);
4298+
4299+
auto &isaMap = session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->isaMap;
4300+
EXPECT_EQ(2u, isaMap.size());
4301+
4302+
EXPECT_FALSE(session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->isaMap[isaGpuVa]->moduleLoadEventAck);
4303+
EXPECT_FALSE(session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->isaMap[isaGpuVa2]->moduleLoadEventAck);
4304+
4305+
zet_debug_event_t event = {};
4306+
ze_result_t result = zetDebugReadEvent(session->toHandle(), 0, &event);
4307+
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
4308+
EXPECT_EQ(ZET_DEBUG_EVENT_TYPE_MODULE_LOAD, event.type);
4309+
EXPECT_EQ(ZET_DEBUG_EVENT_FLAG_NEED_ACK, event.flags & ZET_DEBUG_EVENT_FLAG_NEED_ACK);
4310+
EXPECT_EQ(isaGpuVa2, event.info.module.load);
4311+
4312+
auto elfAddress = session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->uuidMap[elfUUID].ptr;
4313+
auto elfSize = session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->uuidMap[elfUUID].dataSize;
4314+
EXPECT_EQ(elfAddress, event.info.module.moduleBegin);
4315+
EXPECT_EQ(elfAddress + elfSize, event.info.module.moduleEnd);
4316+
4317+
vmBindIsa->base.flags = PRELIM_DRM_I915_DEBUG_EVENT_DESTROY;
4318+
vmBindIsa->va_start = isaGpuVa2;
4319+
4320+
session->handleEvent(&vmBindIsa->base);
4321+
4322+
EXPECT_EQ(0u, session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->apiEvents.size());
4323+
4324+
vmBindIsa->base.flags = PRELIM_DRM_I915_DEBUG_EVENT_DESTROY;
4325+
vmBindIsa->va_start = isaGpuVa;
4326+
4327+
session->handleEvent(&vmBindIsa->base);
4328+
4329+
EXPECT_EQ(1u, session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->apiEvents.size());
4330+
4331+
memset(&event, 0, sizeof(zet_debug_event_t));
4332+
4333+
result = zetDebugReadEvent(session->toHandle(), 0, &event);
4334+
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
4335+
4336+
EXPECT_EQ(ZET_DEBUG_EVENT_TYPE_MODULE_UNLOAD, event.type);
4337+
EXPECT_EQ(isaGpuVa2, event.info.module.load);
4338+
EXPECT_EQ(0u, event.flags & ZET_DEBUG_EVENT_FLAG_NEED_ACK);
4339+
4340+
EXPECT_EQ(session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->uuidMap[elfUUID].ptr, event.info.module.moduleBegin);
4341+
EXPECT_EQ(session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->uuidMap[elfUUID].ptr +
4342+
session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->uuidMap[elfUUID].dataSize,
4343+
event.info.module.moduleEnd);
4344+
}
4345+
4346+
TEST_F(DebugApiLinuxVmBindTest, GivenAttachAfterModuleCreateWhenHandlingEventWithforL0ZebinModuleThenModuleLoadAndUnloadEventsAreReportedForLastKernel) {
4347+
uint64_t isaGpuVa = 0x345000;
4348+
uint64_t isaGpuVa2 = 0x340000;
4349+
uint64_t isaSize = 0x2000;
4350+
uint64_t vmBindIsaData[sizeof(prelim_drm_i915_debug_event_vm_bind) / sizeof(uint64_t) + 3 * sizeof(typeOfUUID)];
4351+
prelim_drm_i915_debug_event_vm_bind *vmBindIsa = reinterpret_cast<prelim_drm_i915_debug_event_vm_bind *>(&vmBindIsaData);
4352+
4353+
const uint32_t kernelCount = 2;
4354+
DebugSessionLinux::UuidData zebinModuleUuidData = {
4355+
.handle = zebinModuleUUID,
4356+
.classHandle = zebinModuleClassHandle,
4357+
.classIndex = NEO::DrmResourceClass::L0ZebinModule,
4358+
.data = std::make_unique<char[]>(sizeof(kernelCount)),
4359+
.dataSize = sizeof(kernelCount)};
4360+
4361+
memcpy(zebinModuleUuidData.data.get(), &kernelCount, sizeof(kernelCount));
4362+
4363+
session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->classHandleToIndex[zebinModuleClassHandle] = {"L0_ZEBIN_MODULE", static_cast<uint32_t>(NEO::DrmResourceClass::L0ZebinModule)};
4364+
session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->uuidMap.emplace(zebinModuleUUID, std::move(zebinModuleUuidData));
4365+
session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->uuidToModule[zebinModuleUUID].segmentCount = 2;
4366+
session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->uuidMap[elfUUID].ptr = 0x1000;
4367+
4368+
vmBindIsa->base.type = PRELIM_DRM_I915_DEBUG_EVENT_VM_BIND;
4369+
// No ACK flag - vm bind called before debugger attached
41964370
vmBindIsa->base.flags = PRELIM_DRM_I915_DEBUG_EVENT_CREATE;
41974371
vmBindIsa->base.size = sizeof(prelim_drm_i915_debug_event_vm_bind) + 3 * sizeof(typeOfUUID);
4372+
vmBindIsa->base.seqno = 20;
41984373
vmBindIsa->client_handle = MockDebugSessionLinux::mockClientHandle;
41994374
vmBindIsa->va_start = isaGpuVa;
42004375
vmBindIsa->va_length = isaSize;
@@ -4214,22 +4389,39 @@ TEST_F(DebugApiLinuxVmBindTest, GivenEventWithL0ZebinModuleWhenHandlingEventThen
42144389
EXPECT_EQ(1u, session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->uuidToModule.size());
42154390
EXPECT_EQ(1u, session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->uuidToModule[zebinModuleUUID].loadAddresses.size());
42164391

4392+
// event not pushed to ack
4393+
EXPECT_EQ(0u, session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->isaMap[isaGpuVa]->ackEvents.size());
4394+
EXPECT_EQ(0, handler->ioctlCalled);
4395+
EXPECT_EQ(0u, handler->debugEventAcked.seqno);
4396+
42174397
vmBindIsa->va_start = isaGpuVa2;
4398+
vmBindIsa->base.seqno = 21;
42184399

4400+
handler->ioctlCalled = 0;
42194401
session->handleEvent(&vmBindIsa->base);
42204402

42214403
EXPECT_EQ(1u, session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->apiEvents.size());
42224404
EXPECT_EQ(1u, session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->uuidToModule.size());
42234405
EXPECT_EQ(2u, session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->uuidToModule[zebinModuleUUID].loadAddresses.size());
42244406
EXPECT_EQ(2u, session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->uuidToModule[zebinModuleUUID].segmentCount);
42254407

4408+
// event not pushed to ack
4409+
EXPECT_EQ(0u, session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->isaMap[isaGpuVa]->ackEvents.size());
4410+
EXPECT_EQ(0, handler->ioctlCalled);
4411+
EXPECT_EQ(0u, handler->debugEventAcked.seqno); // Not acked
4412+
42264413
auto &isaMap = session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->isaMap;
42274414
EXPECT_EQ(2u, isaMap.size());
42284415

4416+
EXPECT_TRUE(session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->isaMap[isaGpuVa]->moduleLoadEventAck);
4417+
EXPECT_TRUE(session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->isaMap[isaGpuVa2]->moduleLoadEventAck);
4418+
42294419
zet_debug_event_t event = {};
42304420
ze_result_t result = zetDebugReadEvent(session->toHandle(), 0, &event);
42314421
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
42324422
EXPECT_EQ(ZET_DEBUG_EVENT_TYPE_MODULE_LOAD, event.type);
4423+
EXPECT_EQ(0u, event.flags & ZET_DEBUG_EVENT_FLAG_NEED_ACK);
4424+
42334425
EXPECT_EQ(isaGpuVa2, event.info.module.load);
42344426

42354427
auto elfAddress = session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->uuidMap[elfUUID].ptr;
@@ -4258,6 +4450,8 @@ TEST_F(DebugApiLinuxVmBindTest, GivenEventWithL0ZebinModuleWhenHandlingEventThen
42584450

42594451
EXPECT_EQ(ZET_DEBUG_EVENT_TYPE_MODULE_UNLOAD, event.type);
42604452
EXPECT_EQ(isaGpuVa2, event.info.module.load);
4453+
EXPECT_EQ(0u, event.flags & ZET_DEBUG_EVENT_FLAG_NEED_ACK);
4454+
42614455
EXPECT_EQ(session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->uuidMap[elfUUID].ptr, event.info.module.moduleBegin);
42624456
EXPECT_EQ(session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->uuidMap[elfUUID].ptr +
42634457
session->clientHandleToConnection[MockDebugSessionLinux::mockClientHandle]->uuidMap[elfUUID].dataSize,

0 commit comments

Comments
 (0)