Debian Codegraph @

level_zero/sysman/test/unit_tests/sources/events/linux/test_zes_events.cpp

raw
1 /*
2 * Copyright (C) 2023-2024 Intel Corporation
3 *
4 * SPDX-License-Identifier: MIT
5 *
6 */
7
8 #include "shared/test/common/os_interface/linux/sys_calls_linux_ult.h"
9
10 #include "level_zero/sysman/test/unit_tests/sources/events/linux/mock_events.h"
11 #include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h"
12
13 namespace L0 {
14 namespace Sysman {
15 namespace ult {
16
17 constexpr uint32_t mockHandleCount = 2u;
18 constexpr int mockReadPipeFd = 8;
19 constexpr int mockWritePipeFd = 9;
20 constexpr uint32_t pmuDriverType = 16u;
21 class SysmanEventsFixture : public SysmanDeviceFixture {
22 protected:
23 std::unique_ptr<MockEventsFsAccess> pFsAccess;
24 MockEventNeoDrm *pDrm = nullptr;
25 Drm *pOriginalDrm = nullptr;
26 FsAccessInterface *pFsAccessOriginal = nullptr;
27 OsEvents *pOsEventsPrev = nullptr;
28 L0::Sysman::EventsImp *pEventsImp;
29 std::unique_ptr<MockEventsSysfsAccess> pSysfsAccess;
30 SysFsAccessInterface *pSysfsAccessOriginal = nullptr;
31 std::unique_ptr<MockPmuInterfaceImpForEvents> pPmuInterface;
32 PmuInterface *pOriginalPmuInterface = nullptr;
33 PublicLinuxEventsImp *pLinuxEventsImp = nullptr;
34 L0::Sysman::SysmanDevice *device = nullptr;
35
36 void SetUp() override {
37 SysmanDeviceFixture::SetUp();
38 pFsAccessOriginal = pLinuxSysmanImp->pFsAccess;
39 pFsAccess = std::make_unique<MockEventsFsAccess>();
40 pLinuxSysmanImp->pFsAccess = pFsAccess.get();
41 pDrm = new MockEventNeoDrm(const_cast<NEO::RootDeviceEnvironment &>(pSysmanDeviceImp->getRootDeviceEnvironment()));
42 pDrm->setupIoctlHelper(pSysmanDeviceImp->getRootDeviceEnvironment().getHardwareInfo()->platform.eProductFamily);
43 pDrm->setMemoryType(NEO::DeviceBlobConstants::MemoryType::hbm2e);
44 auto &osInterface = pSysmanDeviceImp->getRootDeviceEnvironment().osInterface;
45 osInterface->setDriverModel(std::unique_ptr<MockEventNeoDrm>(pDrm));
46
47 pSysfsAccessOriginal = pLinuxSysmanImp->pSysfsAccess;
48 pSysfsAccess = std::make_unique<MockEventsSysfsAccess>();
49 pLinuxSysmanImp->pSysfsAccess = pSysfsAccess.get();
50
51 pEventsImp = static_cast<L0::Sysman::EventsImp *>(pSysmanDeviceImp->pEvents);
52
53 pLinuxEventsImp = new PublicLinuxEventsImp(pOsSysman);
54 pEventsImp->pOsEvents = pLinuxEventsImp;
55 pPmuInterface = std::make_unique<MockPmuInterfaceImpForEvents>(pLinuxSysmanImp);
56 pOriginalPmuInterface = pLinuxSysmanImp->pPmuInterface;
57 pLinuxSysmanImp->pPmuInterface = pPmuInterface.get();
58
59 pFsAccess->mockReadValSuccess = true;
60
61 for (const auto &handle : pSysmanDeviceImp->pRasHandleContext->handleList) {
62 delete handle;
63 }
64 pSysmanDeviceImp->pRasHandleContext->handleList.clear();
65 device = pSysmanDeviceImp;
66 getRasHandles(0);
67 }
68
69 void TearDown() override {
70 if (nullptr != pEventsImp->pOsEvents) {
71 delete pEventsImp->pOsEvents;
72 }
73 pEventsImp->pOsEvents = pOsEventsPrev;
74 pEventsImp = nullptr;
75 pLinuxSysmanImp->pSysfsAccess = pSysfsAccessOriginal;
76 pLinuxSysmanImp->pFsAccess = pFsAccessOriginal;
77
78 pLinuxSysmanImp->pPmuInterface = pOriginalPmuInterface;
79 SysmanDeviceFixture::TearDown();
80 }
81
82 std::vector<zes_ras_handle_t> getRasHandles(uint32_t count) {
83 std::vector<zes_ras_handle_t> handles(count, nullptr);
84 EXPECT_EQ(zesDeviceEnumRasErrorSets(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
85 return handles;
86 }
87 };
88
89 TEST_F(SysmanEventsFixture, whenRegisteringInvalidEventsThenErrorIsReturned) {
90 zes_event_type_flags_t events = 0xFFFF;
91 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ENUMERATION, pLinuxEventsImp->eventRegister(events));
92 }
93
94 TEST_F(SysmanEventsFixture, GivenValidSysmanHandleWhenEventsAreClearedThenDeviceListenReturnsNoEvents) {
95 VariableBackup<decltype(SysCalls::sysCallsPipe)> mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int {
96 pipeFd[0] = mockReadPipeFd;
97 pipeFd[1] = mockWritePipeFd;
98 return 1;
99 });
100 VariableBackup<decltype(SysCalls::sysCallsPoll)> mockPoll(&SysCalls::sysCallsPoll, [](struct pollfd *pollFd, unsigned long int numberOfFds, int timeout) -> int {
101 for (uint64_t i = 0; i < numberOfFds; i++) {
102 if (pollFd[i].fd == mockUdevFd) {
103 pollFd[i].revents = POLLIN;
104 }
105 }
106 return 1;
107 });
108
109 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
110 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
111 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
112
113 auto pUdevLibLocal = new EventsUdevLibMock();
114 int a = 0;
115 void *ptr = &a; // Initialize a void pointer with dummy data
116 pUdevLibLocal->allocateDeviceToReceiveDataResult = ptr;
117
118 auto pUdevLibOriginal = pPublicLinuxSysmanDriverImp->pUdevLib;
119 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibLocal;
120
121 zes_event_type_flags_t events = 0;
122 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), events));
123 zes_device_handle_t *phDevices = new zes_device_handle_t[2];
124 phDevices[0] = device->toHandle();
125 phDevices[1] = device->toHandle();
126 uint32_t numDeviceEvents = 0;
127 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[2];
128 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 2u, phDevices, &numDeviceEvents, pDeviceEvents));
129 EXPECT_EQ(0u, numDeviceEvents);
130 delete[] phDevices;
131 delete[] pDeviceEvents;
132 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibOriginal;
133 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
134 delete pPublicLinuxSysmanDriverImp;
135 delete pUdevLibLocal;
136 }
137
138 TEST_F(SysmanEventsFixture, GivenPollSystemCallReturnsFailureWhenlisteningForResetRequiredEventThenDeviceListenReturnsNoEvents) {
139 VariableBackup<decltype(SysCalls::sysCallsPipe)> mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int {
140 pipeFd[0] = mockReadPipeFd;
141 pipeFd[1] = mockWritePipeFd;
142 return 1;
143 });
144 VariableBackup<decltype(SysCalls::sysCallsPoll)> mockPoll(&SysCalls::sysCallsPoll, [](struct pollfd *pollFd, unsigned long int numberOfFds, int timeout) -> int {
145 for (uint64_t i = 0; i < numberOfFds; i++) {
146 if (pollFd[i].fd == mockUdevFd) {
147 pollFd[i].revents = POLLIN;
148 }
149 }
150 return -1;
151 });
152
153 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
154 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
155 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
156
157 auto pUdevLibLocal = new EventsUdevLibMock();
158 int a = 0;
159 void *ptr = &a; // Initialize a void pointer with dummy data
160 pUdevLibLocal->allocateDeviceToReceiveDataResult = ptr;
161
162 auto pUdevLibOriginal = pPublicLinuxSysmanDriverImp->pUdevLib;
163 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibLocal;
164
165 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED));
166 zes_device_handle_t *phDevices = new zes_device_handle_t[2];
167 phDevices[0] = device->toHandle();
168 phDevices[1] = device->toHandle();
169 uint32_t numDeviceEvents = 0;
170 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[2];
171 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 2u, phDevices, &numDeviceEvents, pDeviceEvents));
172 EXPECT_EQ(0u, numDeviceEvents);
173 delete[] phDevices;
174 delete[] pDeviceEvents;
175 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibOriginal;
176 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
177 delete pPublicLinuxSysmanDriverImp;
178 delete pUdevLibLocal;
179 }
180
181 TEST_F(SysmanEventsFixture, GivenPipeSystemCallReturnsFailureWhenlisteningForResetRequiredEventThenDeviceListenReturnsResetRequiredEvent) {
182 VariableBackup<decltype(SysCalls::sysCallsPipe)> mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int {
183 return -1;
184 });
185
186 VariableBackup<FirmwareUtil *> backupFwUtil(&pLinuxSysmanImp->pFwUtilInterface);
187 auto pMockFwInterface = new MockEventsFwInterface;
188 pLinuxSysmanImp->pFwUtilInterface = pMockFwInterface;
189
190 VariableBackup<decltype(SysCalls::sysCallsPoll)> mockPoll(&SysCalls::sysCallsPoll, [](struct pollfd *pollFd, unsigned long int numberOfFds, int timeout) -> int {
191 for (uint64_t i = 0; i < numberOfFds; i++) {
192 if (pollFd[i].fd == mockUdevFd) {
193 pollFd[i].revents = POLLIN;
194 }
195 }
196 return 1;
197 });
198
199 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
200 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
201 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
202
203 auto pUdevLibLocal = new EventsUdevLibMock();
204 int a = 0;
205 void *ptr = &a; // Initialize a void pointer with dummy data
206 pUdevLibLocal->allocateDeviceToReceiveDataResult = ptr;
207
208 auto pUdevLibOriginal = pPublicLinuxSysmanDriverImp->pUdevLib;
209 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibLocal;
210
211 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED));
212 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
213 phDevices[0] = device->toHandle();
214 uint32_t numDeviceEvents = 0;
215 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
216 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
217 EXPECT_EQ(1u, numDeviceEvents);
218 EXPECT_EQ(ZES_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED, pDeviceEvents[0]);
219
220 delete[] phDevices;
221 delete[] pDeviceEvents;
222 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibOriginal;
223 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
224 delete pPublicLinuxSysmanDriverImp;
225 delete pUdevLibLocal;
226 delete pMockFwInterface;
227 }
228
229 TEST_F(SysmanEventsFixture, GivenPollSystemCallReturnsOnAllFdsWhenlisteningForResetRequiredEventThenDeviceListenReturnsResetRequiredEvent) {
230 VariableBackup<decltype(SysCalls::sysCallsPipe)> mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int {
231 pipeFd[0] = mockReadPipeFd;
232 pipeFd[1] = mockWritePipeFd;
233 return 1;
234 });
235
236 VariableBackup<FirmwareUtil *> backupFwUtil(&pLinuxSysmanImp->pFwUtilInterface);
237 auto pMockFwInterface = new MockEventsFwInterface;
238 pLinuxSysmanImp->pFwUtilInterface = pMockFwInterface;
239
240 VariableBackup<decltype(SysCalls::sysCallsPoll)> mockPoll(&SysCalls::sysCallsPoll, [](struct pollfd *pollFd, unsigned long int numberOfFds, int timeout) -> int {
241 for (uint64_t i = 0; i < numberOfFds; i++) {
242 pollFd[i].revents = POLLIN;
243 }
244 return 1;
245 });
246
247 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
248 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
249 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
250
251 auto pUdevLibLocal = new EventsUdevLibMock();
252 int a = 0;
253 void *ptr = &a; // Initialize a void pointer with dummy data
254 pUdevLibLocal->allocateDeviceToReceiveDataResult = ptr;
255
256 auto pUdevLibOriginal = pPublicLinuxSysmanDriverImp->pUdevLib;
257 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibLocal;
258
259 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED));
260 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
261 phDevices[0] = device->toHandle();
262 uint32_t numDeviceEvents = 0;
263 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
264 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
265 EXPECT_EQ(1u, numDeviceEvents);
266 EXPECT_EQ(ZES_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED, pDeviceEvents[0]);
267
268 delete[] phDevices;
269 delete[] pDeviceEvents;
270 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibOriginal;
271 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
272 delete pPublicLinuxSysmanDriverImp;
273 delete pUdevLibLocal;
274 delete pMockFwInterface;
275 }
276
277 TEST_F(SysmanEventsFixture, GivenPollSystemCallReturnsOnPipeFdWhenlisteningForResetRequiredEventThenEventListenAPIReturnsOnTimeout) {
278 VariableBackup<decltype(SysCalls::sysCallsPipe)> mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int {
279 pipeFd[0] = mockReadPipeFd;
280 pipeFd[1] = mockWritePipeFd;
281 return 1;
282 });
283
284 VariableBackup<FirmwareUtil *> backupFwUtil(&pLinuxSysmanImp->pFwUtilInterface);
285 auto pMockFwInterface = new MockEventsFwInterface;
286 pLinuxSysmanImp->pFwUtilInterface = pMockFwInterface;
287
288 VariableBackup<decltype(SysCalls::sysCallsPoll)> mockPoll(&SysCalls::sysCallsPoll, [](struct pollfd *pollFd, unsigned long int numberOfFds, int timeout) -> int {
289 for (uint64_t i = 0; i < numberOfFds; i++) {
290 if (pollFd[i].fd == mockReadPipeFd) {
291 pollFd[i].revents = POLLIN;
292 }
293 }
294 return 1;
295 });
296
297 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
298 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
299 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
300
301 auto pUdevLibLocal = new EventsUdevLibMock();
302 int a = 0;
303 void *ptr = &a; // Initialize a void pointer with dummy data
304 pUdevLibLocal->allocateDeviceToReceiveDataResult = ptr;
305
306 auto pUdevLibOriginal = pPublicLinuxSysmanDriverImp->pUdevLib;
307 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibLocal;
308
309 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED));
310 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
311 phDevices[0] = device->toHandle();
312 uint32_t numDeviceEvents = 0;
313 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
314 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
315 EXPECT_EQ(0u, numDeviceEvents);
316
317 delete[] phDevices;
318 delete[] pDeviceEvents;
319 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibOriginal;
320 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
321 delete pPublicLinuxSysmanDriverImp;
322 delete pUdevLibLocal;
323 delete pMockFwInterface;
324 }
325
326 TEST_F(SysmanEventsFixture, GivenValidSysmanHandleWhenDeviceEventListenIsInvokedThenVerifyEventListenReturnsFalse) {
327 zes_event_type_flags_t events;
328 EXPECT_FALSE(pSysmanDeviceImp->deviceEventListen(events, 1000u));
329 }
330
331 TEST_F(SysmanEventsFixture, GivenLibUdevNotFoundWhenListeningForEventsThenEventListenIsNotSuccess) {
332 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
333 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
334 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
335
336 auto pLinuxEventsImp = new PublicLinuxEventsUtil(pPublicLinuxSysmanDriverImp);
337 auto pLinuxEventsUtilOld = pPublicLinuxSysmanDriverImp->pLinuxEventsUtil;
338 pPublicLinuxSysmanDriverImp->pLinuxEventsUtil = pLinuxEventsImp;
339
340 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED));
341
342 pLinuxEventsImp->pUdevLib = nullptr;
343
344 zes_event_type_flags_t pEvents;
345 std::vector<zes_event_type_flags_t> registeredEvents;
346 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
347 phDevices[0] = device->toHandle();
348 EXPECT_FALSE(pLinuxEventsImp->listenSystemEvents(&pEvents, 1u, registeredEvents, phDevices, 1000u));
349 delete[] phDevices;
350 pPublicLinuxSysmanDriverImp->pLinuxEventsUtil = pLinuxEventsUtilOld;
351 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
352 delete pPublicLinuxSysmanDriverImp;
353 delete pLinuxEventsImp;
354 }
355
356 TEST_F(SysmanEventsFixture, GivenNoEventsAreRegisteredWhenListeningForEventsThenVerifyListenSystemEventsReturnsFalse) {
357 VariableBackup<decltype(SysCalls::sysCallsPipe)> mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int {
358 pipeFd[0] = mockReadPipeFd;
359 pipeFd[1] = mockWritePipeFd;
360 return 1;
361 });
362 VariableBackup<decltype(SysCalls::sysCallsPoll)> mockPoll(&SysCalls::sysCallsPoll, [](struct pollfd *pollFd, unsigned long int numberOfFds, int timeout) -> int {
363 return -1;
364 });
365
366 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
367 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
368 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
369
370 auto pUdevLibLocal = new EventsUdevLibMock();
371 int a = 0;
372 void *ptr = &a; // Initialize a void pointer with dummy data
373 pUdevLibLocal->allocateDeviceToReceiveDataResult = ptr;
374
375 auto pUdevLibOriginal = pPublicLinuxSysmanDriverImp->pUdevLib;
376 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibLocal;
377
378 auto pLinuxEventsImp = new PublicLinuxEventsUtil(pPublicLinuxSysmanDriverImp);
379 auto pLinuxEventsUtilOld = pPublicLinuxSysmanDriverImp->pLinuxEventsUtil;
380 pPublicLinuxSysmanDriverImp->pLinuxEventsUtil = pLinuxEventsImp;
381
382 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), 0));
383
384 zes_event_type_flags_t pEvents;
385 std::vector<zes_event_type_flags_t> registeredEvents(1);
386 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
387 phDevices[0] = device->toHandle();
388 EXPECT_FALSE(pLinuxEventsImp->listenSystemEvents(&pEvents, 1u, registeredEvents, phDevices, 1000u));
389 delete[] phDevices;
390 pPublicLinuxSysmanDriverImp->pLinuxEventsUtil = pLinuxEventsUtilOld;
391 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibOriginal;
392 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
393 delete pPublicLinuxSysmanDriverImp;
394 delete pUdevLibLocal;
395 delete pLinuxEventsImp;
396 }
397
398 TEST_F(SysmanEventsFixture, GivenOsSysmanDriverAsNullWhenListeningForEventsThenVerifyEventListenIsNotSuccess) {
399 VariableBackup<L0::Sysman::OsSysmanDriver *> driverBackup(&driverHandle->pOsSysmanDriver);
400 driverHandle->pOsSysmanDriver = nullptr;
401 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
402 phDevices[0] = device->toHandle();
403 uint32_t numDeviceEvents = 0;
404 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
405 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
406 delete[] phDevices;
407 delete[] pDeviceEvents;
408 }
409
410 TEST_F(SysmanEventsFixture, GivenOsSysmanDriverAsNullWhenRegisteringForEventsThenVerifyEventListenIsNotSuccess) {
411 VariableBackup<L0::Sysman::OsSysmanDriver *> driverBackup(&driverHandle->pOsSysmanDriver);
412 driverHandle->pOsSysmanDriver = nullptr;
413 zes_event_type_flags_t events = 0;
414 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDeviceEventRegister(device->toHandle(), events));
415 }
416
417 TEST_F(SysmanEventsFixture, GivenOsSysmanDriverAsNullWhenCallingDriverEventListenExThenVerifyEventListenIsNotSuccess) {
418 VariableBackup<L0::Sysman::OsSysmanDriver *> driverBackup(&driverHandle->pOsSysmanDriver);
419 driverHandle->pOsSysmanDriver = nullptr;
420 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
421 phDevices[0] = device->toHandle();
422 uint32_t numDeviceEvents = 0;
423 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
424 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDriverEventListenEx(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
425 delete[] phDevices;
426 delete[] pDeviceEvents;
427 }
428
429 TEST_F(SysmanEventsFixture, GivenValidDeviceHandleWhenListeningForCurrentlyUnsupportedEventsThenEventListenAPIWaitForTimeoutIfEventNotReceived) {
430 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_TEMP_THRESHOLD2));
431
432 pFsAccess->mockReadValOne = true;
433
434 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
435 phDevices[0] = device->toHandle();
436 uint32_t numDeviceEvents = 0;
437 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
438 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
439 EXPECT_EQ(0u, numDeviceEvents);
440 delete[] phDevices;
441 delete[] pDeviceEvents;
442 }
443
444 TEST_F(SysmanEventsFixture,
445 GivenValidDeviceHandleAndListeningForEventsWhenEventGeneratedDevicePathIsNullThenEventListenReturnsAfterTimeout) {
446 VariableBackup<FirmwareUtil *> backupFwUtil(&pLinuxSysmanImp->pFwUtilInterface);
447 auto pMockFwInterface = new MockEventsFwInterface;
448 pLinuxSysmanImp->pFwUtilInterface = pMockFwInterface;
449
450 VariableBackup<decltype(SysCalls::sysCallsPipe)> mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int {
451 pipeFd[0] = mockReadPipeFd;
452 pipeFd[1] = mockWritePipeFd;
453 return 1;
454 });
455 VariableBackup<decltype(SysCalls::sysCallsPoll)> mockPoll(&SysCalls::sysCallsPoll, [](struct pollfd *pollFd, unsigned long int numberOfFds, int timeout) -> int {
456 for (uint64_t i = 0; i < numberOfFds; i++) {
457 if (pollFd[i].fd == mockUdevFd) {
458 pollFd[i].revents = POLLIN;
459 }
460 }
461 return 1;
462 });
463
464 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
465 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
466 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
467
468 auto pUdevLibLocal = new EventsUdevLibMock();
469 int a = 0;
470 void *ptr = &a; // Initialize a void pointer with dummy data
471 pUdevLibLocal->allocateDeviceToReceiveDataResult = ptr;
472 pUdevLibLocal->eventPropertyValueDevPathResult.clear();
473
474 auto pUdevLibOriginal = pPublicLinuxSysmanDriverImp->pUdevLib;
475 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibLocal;
476
477 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED));
478 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
479 phDevices[0] = device->toHandle();
480 uint32_t numDeviceEvents = 0;
481 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
482 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
483 EXPECT_EQ(0u, numDeviceEvents);
484
485 delete[] phDevices;
486 delete[] pDeviceEvents;
487 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibOriginal;
488 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
489 delete pPublicLinuxSysmanDriverImp;
490 delete pUdevLibLocal;
491 delete pMockFwInterface;
492 }
493
494 TEST_F(SysmanEventsFixture,
495 GivenValidDeviceHandleAndListeningForEventsWhenNoEventIsRegisteredThenVerifyNoEventsAreReturned) {
496 VariableBackup<decltype(SysCalls::sysCallsPipe)> mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int {
497 pipeFd[0] = mockReadPipeFd;
498 pipeFd[1] = mockWritePipeFd;
499 return 1;
500 });
501 VariableBackup<decltype(SysCalls::sysCallsPoll)> mockPoll(&SysCalls::sysCallsPoll, [](struct pollfd *pollFd, unsigned long int numberOfFds, int timeout) -> int {
502 for (uint64_t i = 0; i < numberOfFds; i++) {
503 if (pollFd[i].fd == mockUdevFd) {
504 pollFd[i].revents = POLLIN;
505 }
506 }
507 return 1;
508 });
509
510 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
511 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
512 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
513
514 auto pUdevLibLocal = new EventsUdevLibMock();
515 int a = 0;
516 void *ptr = &a; // Initialize a void pointer with dummy data
517 pUdevLibLocal->allocateDeviceToReceiveDataResult = ptr;
518
519 auto pUdevLibOriginal = pPublicLinuxSysmanDriverImp->pUdevLib;
520 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibLocal;
521
522 zes_device_handle_t *phDevices = new zes_device_handle_t[2];
523 phDevices[0] = device->toHandle();
524 phDevices[1] = device->toHandle();
525 uint32_t numDeviceEvents = 0;
526 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[2];
527 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 2u, phDevices, &numDeviceEvents, pDeviceEvents));
528 EXPECT_EQ(0u, numDeviceEvents);
529 delete[] phDevices;
530 delete[] pDeviceEvents;
531 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibOriginal;
532 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
533 delete pPublicLinuxSysmanDriverImp;
534 delete pUdevLibLocal;
535 }
536
537 TEST_F(SysmanEventsFixture, GivenValidDeviceHandleAndListeningEventsWhenNullEventTypeIsReceivedThenEventListenAPIReturnsNoEvent) {
538 VariableBackup<decltype(SysCalls::sysCallsPipe)> mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int {
539 pipeFd[0] = mockReadPipeFd;
540 pipeFd[1] = mockWritePipeFd;
541 return 1;
542 });
543 VariableBackup<decltype(SysCalls::sysCallsPoll)> mockPoll(&SysCalls::sysCallsPoll, [](struct pollfd *pollFd, unsigned long int numberOfFds, int timeout) -> int {
544 for (uint64_t i = 0; i < numberOfFds; i++) {
545 if (pollFd[i].fd == mockUdevFd) {
546 pollFd[i].revents = POLLIN;
547 }
548 }
549 return 1;
550 });
551
552 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
553 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
554 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
555
556 auto pUdevLibLocal = new EventsUdevLibMock();
557 int a = 0;
558 void *ptr = &a; // Initialize a void pointer with dummy data
559 pUdevLibLocal->allocateDeviceToReceiveDataResult = ptr;
560 pUdevLibLocal->getEventTypeResult = nullptr;
561
562 auto pUdevLibOriginal = pPublicLinuxSysmanDriverImp->pUdevLib;
563 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibLocal;
564
565 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_DEVICE_ATTACH));
566 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
567 phDevices[0] = device->toHandle();
568 uint32_t numDeviceEvents = 0;
569 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
570 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
571 EXPECT_EQ(0u, numDeviceEvents);
572
573 delete[] phDevices;
574 delete[] pDeviceEvents;
575 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibOriginal;
576 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
577 delete pPublicLinuxSysmanDriverImp;
578 delete pUdevLibLocal;
579 }
580
581 TEST_F(SysmanEventsFixture,
582 GivenValidDeviceHandleAndListeningForEventsWhenUdevCallToAllocateDeviceFailsThenEventListenReturnFalse) {
583 VariableBackup<FirmwareUtil *> backupFwUtil(&pLinuxSysmanImp->pFwUtilInterface);
584 auto pMockFwInterface = new MockEventsFwInterface;
585 pLinuxSysmanImp->pFwUtilInterface = pMockFwInterface;
586
587 VariableBackup<decltype(SysCalls::sysCallsPipe)> mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int {
588 pipeFd[0] = mockReadPipeFd;
589 pipeFd[1] = mockWritePipeFd;
590 return 1;
591 });
592 VariableBackup<decltype(SysCalls::sysCallsPoll)> mockPoll(&SysCalls::sysCallsPoll, [](struct pollfd *pollFd, unsigned long int numberOfFds, int timeout) -> int {
593 for (uint64_t i = 0; i < numberOfFds; i++) {
594 if (pollFd[i].fd == mockUdevFd) {
595 pollFd[i].revents = POLLIN;
596 }
597 }
598 return 1;
599 });
600
601 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
602 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
603 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
604
605 auto pUdevLibLocal = new EventsUdevLibMock();
606 pUdevLibLocal->allocateDeviceToReceiveDataResult = nullptr;
607 pUdevLibLocal->getEventGenerationSourceDeviceResult = 10;
608
609 auto pUdevLibOriginal = pPublicLinuxSysmanDriverImp->pUdevLib;
610 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibLocal;
611
612 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED));
613 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
614 phDevices[0] = device->toHandle();
615 uint32_t numDeviceEvents = std::numeric_limits<uint32_t>::max();
616 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
617 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
618 EXPECT_EQ(0u, numDeviceEvents);
619
620 delete[] phDevices;
621 delete[] pDeviceEvents;
622 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibOriginal;
623 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
624 delete pPublicLinuxSysmanDriverImp;
625 delete pUdevLibLocal;
626 delete pMockFwInterface;
627 }
628
629 TEST_F(SysmanEventsFixture, GivenValidDeviceHandleWhenListeningForResetRequiredEventsThenEventListenAPIReturnsAfterReceivingEventWithinTimeout) {
630 VariableBackup<FirmwareUtil *> backupFwUtil(&pLinuxSysmanImp->pFwUtilInterface);
631 auto pMockFwInterface = new MockEventsFwInterface;
632 pLinuxSysmanImp->pFwUtilInterface = pMockFwInterface;
633
634 VariableBackup<decltype(SysCalls::sysCallsPipe)> mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int {
635 pipeFd[0] = mockReadPipeFd;
636 pipeFd[1] = mockWritePipeFd;
637 return 1;
638 });
639 VariableBackup<decltype(SysCalls::sysCallsPoll)> mockPoll(&SysCalls::sysCallsPoll, [](struct pollfd *pollFd, unsigned long int numberOfFds, int timeout) -> int {
640 for (uint64_t i = 0; i < numberOfFds; i++) {
641 if (pollFd[i].fd == mockUdevFd) {
642 pollFd[i].revents = POLLIN;
643 }
644 }
645 return 1;
646 });
647
648 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
649 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
650 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
651
652 auto pUdevLibLocal = new EventsUdevLibMock();
653 int a = 0;
654 void *ptr = &a; // Initialize a void pointer with dummy data
655 pUdevLibLocal->allocateDeviceToReceiveDataResult = ptr;
656
657 auto pUdevLibOriginal = pPublicLinuxSysmanDriverImp->pUdevLib;
658 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibLocal;
659
660 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED));
661 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
662 phDevices[0] = device->toHandle();
663 uint32_t numDeviceEvents = 0;
664 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
665 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
666 EXPECT_EQ(1u, numDeviceEvents);
667 EXPECT_EQ(ZES_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED, pDeviceEvents[0]);
668
669 delete[] phDevices;
670 delete[] pDeviceEvents;
671 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibOriginal;
672 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
673 delete pPublicLinuxSysmanDriverImp;
674 delete pUdevLibLocal;
675 delete pMockFwInterface;
676 }
677
678 TEST_F(SysmanEventsFixture, GivenNeedsResetUeventPropertyIsSignalledWhenListeningForResetRequiredEventsThenEventListenAPIReturnsAfterReceivingEventWithinTimeout) {
679 VariableBackup<FirmwareUtil *> backupFwUtil(&pLinuxSysmanImp->pFwUtilInterface);
680 auto pMockFwInterface = new MockEventsFwInterface;
681 pLinuxSysmanImp->pFwUtilInterface = pMockFwInterface;
682
683 VariableBackup<decltype(SysCalls::sysCallsPipe)> mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int {
684 pipeFd[0] = mockReadPipeFd;
685 pipeFd[1] = mockWritePipeFd;
686 return 1;
687 });
688 VariableBackup<decltype(SysCalls::sysCallsPoll)> mockPoll(&SysCalls::sysCallsPoll, [](struct pollfd *pollFd, unsigned long int numberOfFds, int timeout) -> int {
689 for (uint64_t i = 0; i < numberOfFds; i++) {
690 if (pollFd[i].fd == mockUdevFd) {
691 pollFd[i].revents = POLLIN;
692 }
693 }
694 return 1;
695 });
696
697 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
698 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
699 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
700
701 auto pUdevLibLocal = new EventsUdevLibMock();
702 int a = 0;
703 void *ptr = &a; // Initialize a void pointer with dummy data
704 pUdevLibLocal->allocateDeviceToReceiveDataResult = ptr;
705 pUdevLibLocal->getEventPropertyValueResult = "NEEDS_RESET";
706
707 auto pUdevLibOriginal = pPublicLinuxSysmanDriverImp->pUdevLib;
708 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibLocal;
709
710 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED));
711 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
712 phDevices[0] = device->toHandle();
713 uint32_t numDeviceEvents = 0;
714 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
715 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
716 EXPECT_EQ(1u, numDeviceEvents);
717 EXPECT_EQ(ZES_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED, pDeviceEvents[0]);
718
719 delete[] phDevices;
720 delete[] pDeviceEvents;
721 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibOriginal;
722 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
723 delete pPublicLinuxSysmanDriverImp;
724 delete pUdevLibLocal;
725 delete pMockFwInterface;
726 }
727
728 TEST_F(SysmanDeviceFixture, GivenValidDeviceHandleWhenEventRegisterIsCalledThenSuccessIsReturned) {
729 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
730 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
731 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
732
733 auto pLinuxEventsImp = new PublicLinuxEventsUtil(pPublicLinuxSysmanDriverImp);
734 auto pLinuxEventsUtilOld = pPublicLinuxSysmanDriverImp->pLinuxEventsUtil;
735 pPublicLinuxSysmanDriverImp->pLinuxEventsUtil = pLinuxEventsImp;
736
737 pLinuxEventsImp->pipeFd[0] = mockReadPipeFd;
738 pLinuxEventsImp->pipeFd[1] = mockWritePipeFd;
739 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(pSysmanDeviceImp->toHandle(), ZES_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED));
740
741 pPublicLinuxSysmanDriverImp->pLinuxEventsUtil = pLinuxEventsUtilOld;
742 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
743 delete pPublicLinuxSysmanDriverImp;
744 delete pLinuxEventsImp;
745 }
746
747 TEST_F(SysmanEventsFixture, GivenEventsAreRegisteredWhenEventRegisterWithNoEventsIsCalledAgainThenSuccessIsReturned) {
748 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
749 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
750 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
751
752 auto pLinuxEventsImp = new PublicLinuxEventsUtil(pPublicLinuxSysmanDriverImp);
753 auto pLinuxEventsUtilOld = pPublicLinuxSysmanDriverImp->pLinuxEventsUtil;
754 pPublicLinuxSysmanDriverImp->pLinuxEventsUtil = pLinuxEventsImp;
755
756 pLinuxEventsImp->pipeFd[0] = mockReadPipeFd;
757 pLinuxEventsImp->pipeFd[1] = mockWritePipeFd;
758 std::map<SysmanDeviceImp *, zes_event_type_flags_t> deviceEventsMap = {{pLinuxSysmanImp->getSysmanDeviceImp(), ZES_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED | ZES_EVENT_TYPE_FLAG_TEMP_THRESHOLD2}};
759
760 pLinuxEventsImp->deviceEventsMap = deviceEventsMap;
761 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), 0));
762 EXPECT_EQ(0u, pLinuxEventsImp->deviceEventsMap[pLinuxSysmanImp->getSysmanDeviceImp()]);
763
764 pPublicLinuxSysmanDriverImp->pLinuxEventsUtil = pLinuxEventsUtilOld;
765 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
766 delete pPublicLinuxSysmanDriverImp;
767 delete pLinuxEventsImp;
768 }
769
770 TEST_F(SysmanEventsFixture, GivenValidDeviceHandleWhenListeningForFabricHealthEventsThenEventListenAPIReturnsAfterReceivingEventWithinTimeout) {
771 VariableBackup<FirmwareUtil *> backupFwUtil(&pLinuxSysmanImp->pFwUtilInterface);
772 auto pMockFwInterface = new MockEventsFwInterface;
773 pLinuxSysmanImp->pFwUtilInterface = pMockFwInterface;
774
775 VariableBackup<decltype(SysCalls::sysCallsPipe)> mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int {
776 pipeFd[0] = mockReadPipeFd;
777 pipeFd[1] = mockWritePipeFd;
778 return 1;
779 });
780 VariableBackup<decltype(SysCalls::sysCallsPoll)> mockPoll(&SysCalls::sysCallsPoll, [](struct pollfd *pollFd, unsigned long int numberOfFds, int timeout) -> int {
781 for (uint64_t i = 0; i < numberOfFds; i++) {
782 if (pollFd[i].fd == mockUdevFd) {
783 pollFd[i].revents = POLLIN;
784 }
785 }
786 return 1;
787 });
788
789 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
790 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
791 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
792
793 auto pUdevLibLocal = new EventsUdevLibMock();
794 int a = 0;
795 void *ptr = &a; // Initialize a void pointer with dummy data
796 pUdevLibLocal->allocateDeviceToReceiveDataResult = ptr;
797
798 auto pUdevLibOriginal = pPublicLinuxSysmanDriverImp->pUdevLib;
799 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibLocal;
800
801 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_FABRIC_PORT_HEALTH));
802 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
803 phDevices[0] = device->toHandle();
804 uint32_t numDeviceEvents = 0;
805 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
806 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
807 EXPECT_EQ(1u, numDeviceEvents);
808 EXPECT_EQ(ZES_EVENT_TYPE_FLAG_FABRIC_PORT_HEALTH, pDeviceEvents[0]);
809
810 delete[] phDevices;
811 delete[] pDeviceEvents;
812 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibOriginal;
813 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
814 delete pPublicLinuxSysmanDriverImp;
815 delete pUdevLibLocal;
816 delete pMockFwInterface;
817 }
818
819 TEST_F(SysmanEventsFixture, GivenImproperDevPathForUeventWhenListeningForFabricHealthEventsThenEventListenAPIReturnsAfterTimeout) {
820 VariableBackup<FirmwareUtil *> backupFwUtil(&pLinuxSysmanImp->pFwUtilInterface);
821 auto pMockFwInterface = new MockEventsFwInterface;
822 pLinuxSysmanImp->pFwUtilInterface = pMockFwInterface;
823
824 VariableBackup<decltype(SysCalls::sysCallsPipe)> mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int {
825 pipeFd[0] = mockReadPipeFd;
826 pipeFd[1] = mockWritePipeFd;
827 return 1;
828 });
829 VariableBackup<decltype(SysCalls::sysCallsPoll)> mockPoll(&SysCalls::sysCallsPoll, [](struct pollfd *pollFd, unsigned long int numberOfFds, int timeout) -> int {
830 for (uint64_t i = 0; i < numberOfFds; i++) {
831 if (pollFd[i].fd == mockUdevFd) {
832 pollFd[i].revents = POLLIN;
833 }
834 }
835 return 1;
836 });
837
838 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
839 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
840 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
841
842 auto pUdevLibLocal = new EventsUdevLibMock();
843 int a = 0;
844 void *ptr = &a; // Initialize a void pointer with dummy data
845 pUdevLibLocal->allocateDeviceToReceiveDataResult = ptr;
846 pUdevLibLocal->getEventGenerationSourceDeviceResult = 20;
847 pUdevLibLocal->eventPropertyValueDevPathResult = "/devices/pci0000:97/0000:97:02.0/0000:98:00.0/0000:99:01.0/";
848
849 auto pUdevLibOriginal = pPublicLinuxSysmanDriverImp->pUdevLib;
850 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibLocal;
851
852 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_FABRIC_PORT_HEALTH));
853 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
854 phDevices[0] = device->toHandle();
855 uint32_t numDeviceEvents = 0;
856 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
857 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
858 EXPECT_EQ(0u, numDeviceEvents);
859
860 delete[] phDevices;
861 delete[] pDeviceEvents;
862 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibOriginal;
863 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
864 delete pPublicLinuxSysmanDriverImp;
865 delete pUdevLibLocal;
866 delete pMockFwInterface;
867 }
868
869 TEST_F(SysmanEventsFixture, GivenInvalidEventTypeWhenListeningForFabricHealthEventsThenEventListenAPIReturnsAfterTimeout) {
870 VariableBackup<FirmwareUtil *> backupFwUtil(&pLinuxSysmanImp->pFwUtilInterface);
871 auto pMockFwInterface = new MockEventsFwInterface;
872 pLinuxSysmanImp->pFwUtilInterface = pMockFwInterface;
873
874 VariableBackup<decltype(SysCalls::sysCallsPipe)> mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int {
875 pipeFd[0] = mockReadPipeFd;
876 pipeFd[1] = mockWritePipeFd;
877 return 1;
878 });
879 VariableBackup<decltype(SysCalls::sysCallsPoll)> mockPoll(&SysCalls::sysCallsPoll, [](struct pollfd *pollFd, unsigned long int numberOfFds, int timeout) -> int {
880 for (uint64_t i = 0; i < numberOfFds; i++) {
881 if (pollFd[i].fd == mockUdevFd) {
882 pollFd[i].revents = POLLIN;
883 }
884 }
885 return 1;
886 });
887
888 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
889 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
890 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
891
892 auto pUdevLibLocal = new EventsUdevLibMock();
893 int a = 0;
894 void *ptr = &a; // Initialize a void pointer with dummy data
895 pUdevLibLocal->allocateDeviceToReceiveDataResult = ptr;
896 pUdevLibLocal->getEventGenerationSourceDeviceResult = 20;
897 pUdevLibLocal->getEventTypeResult = "Invalid";
898
899 auto pUdevLibOriginal = pPublicLinuxSysmanDriverImp->pUdevLib;
900 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibLocal;
901
902 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_FABRIC_PORT_HEALTH));
903 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
904 phDevices[0] = device->toHandle();
905 uint32_t numDeviceEvents = 0;
906 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
907 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
908 EXPECT_EQ(0u, numDeviceEvents);
909
910 delete[] phDevices;
911 delete[] pDeviceEvents;
912 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibOriginal;
913 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
914 delete pPublicLinuxSysmanDriverImp;
915 delete pUdevLibLocal;
916 delete pMockFwInterface;
917 }
918
919 TEST_F(SysmanEventsFixture, GivenRealPathSystemCallFailsWhenListeningForFabricHealthEventsThenEventListenAPIReturnsAfterTimeout) {
920 VariableBackup<FirmwareUtil *> backupFwUtil(&pLinuxSysmanImp->pFwUtilInterface);
921 auto pMockFwInterface = new MockEventsFwInterface;
922 pLinuxSysmanImp->pFwUtilInterface = pMockFwInterface;
923
924 VariableBackup<decltype(SysCalls::sysCallsPipe)> mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int {
925 pipeFd[0] = mockReadPipeFd;
926 pipeFd[1] = mockWritePipeFd;
927 return 1;
928 });
929 VariableBackup<decltype(SysCalls::sysCallsPoll)> mockPoll(&SysCalls::sysCallsPoll, [](struct pollfd *pollFd, unsigned long int numberOfFds, int timeout) -> int {
930 for (uint64_t i = 0; i < numberOfFds; i++) {
931 if (pollFd[i].fd == mockUdevFd) {
932 pollFd[i].revents = POLLIN;
933 }
934 }
935 return 1;
936 });
937
938 pSysfsAccess->getRealPathResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
939
940 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
941 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
942 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
943
944 auto pUdevLibLocal = new EventsUdevLibMock();
945 int a = 0;
946 void *ptr = &a; // Initialize a void pointer with dummy data
947 pUdevLibLocal->allocateDeviceToReceiveDataResult = ptr;
948 pUdevLibLocal->getEventGenerationSourceDeviceResult = 20;
949
950 auto pUdevLibOriginal = pPublicLinuxSysmanDriverImp->pUdevLib;
951 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibLocal;
952
953 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_FABRIC_PORT_HEALTH));
954 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
955 phDevices[0] = device->toHandle();
956 uint32_t numDeviceEvents = 0;
957 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
958 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
959 EXPECT_EQ(0u, numDeviceEvents);
960
961 delete[] phDevices;
962 delete[] pDeviceEvents;
963 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibOriginal;
964 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
965 delete pPublicLinuxSysmanDriverImp;
966 delete pUdevLibLocal;
967 delete pMockFwInterface;
968 }
969
970 TEST_F(SysmanEventsFixture, GivenRealPathSystemCallReturnsInvalidDeviceWhenListeningForFabricHealthEventsThenEventListenAPIReturnsAfterTimeout) {
971 VariableBackup<FirmwareUtil *> backupFwUtil(&pLinuxSysmanImp->pFwUtilInterface);
972 auto pMockFwInterface = new MockEventsFwInterface;
973 pLinuxSysmanImp->pFwUtilInterface = pMockFwInterface;
974
975 VariableBackup<decltype(SysCalls::sysCallsPipe)> mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int {
976 pipeFd[0] = mockReadPipeFd;
977 pipeFd[1] = mockWritePipeFd;
978 return 1;
979 });
980 VariableBackup<decltype(SysCalls::sysCallsPoll)> mockPoll(&SysCalls::sysCallsPoll, [](struct pollfd *pollFd, unsigned long int numberOfFds, int timeout) -> int {
981 for (uint64_t i = 0; i < numberOfFds; i++) {
982 if (pollFd[i].fd == mockUdevFd) {
983 pollFd[i].revents = POLLIN;
984 }
985 }
986 return 1;
987 });
988
989 pSysfsAccess->realPath = "Invalid";
990
991 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
992 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
993 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
994
995 auto pUdevLibLocal = new EventsUdevLibMock();
996 int a = 0;
997 void *ptr = &a; // Initialize a void pointer with dummy data
998 pUdevLibLocal->allocateDeviceToReceiveDataResult = ptr;
999 pUdevLibLocal->getEventGenerationSourceDeviceResult = 20;
1000
1001 auto pUdevLibOriginal = pPublicLinuxSysmanDriverImp->pUdevLib;
1002 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibLocal;
1003
1004 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_FABRIC_PORT_HEALTH));
1005 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
1006 phDevices[0] = device->toHandle();
1007 uint32_t numDeviceEvents = 0;
1008 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
1009 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
1010 EXPECT_EQ(0u, numDeviceEvents);
1011
1012 delete[] phDevices;
1013 delete[] pDeviceEvents;
1014 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibOriginal;
1015 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
1016 delete pPublicLinuxSysmanDriverImp;
1017 delete pUdevLibLocal;
1018 delete pMockFwInterface;
1019 }
1020
1021 TEST_F(SysmanEventsFixture, GivenEventPropertyForTypeKeyIsNullPtrWhenListeningForFabricHealthEventsThenEventListenAPIReturnsAfterTimeout) {
1022 VariableBackup<FirmwareUtil *> backupFwUtil(&pLinuxSysmanImp->pFwUtilInterface);
1023 auto pMockFwInterface = new MockEventsFwInterface;
1024 pLinuxSysmanImp->pFwUtilInterface = pMockFwInterface;
1025
1026 VariableBackup<decltype(SysCalls::sysCallsPipe)> mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int {
1027 pipeFd[0] = mockReadPipeFd;
1028 pipeFd[1] = mockWritePipeFd;
1029 return 1;
1030 });
1031 VariableBackup<decltype(SysCalls::sysCallsPoll)> mockPoll(&SysCalls::sysCallsPoll, [](struct pollfd *pollFd, unsigned long int numberOfFds, int timeout) -> int {
1032 for (uint64_t i = 0; i < numberOfFds; i++) {
1033 if (pollFd[i].fd == mockUdevFd) {
1034 pollFd[i].revents = POLLIN;
1035 }
1036 }
1037 return 1;
1038 });
1039
1040 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
1041 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
1042 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
1043
1044 auto pUdevLibLocal = new EventsUdevLibMock();
1045 int a = 0;
1046 void *ptr = &a; // Initialize a void pointer with dummy data
1047 pUdevLibLocal->allocateDeviceToReceiveDataResult = ptr;
1048 pUdevLibLocal->getEventGenerationSourceDeviceResult = 20;
1049 pUdevLibLocal->eventPropertyValueTypeResult = "";
1050
1051 auto pUdevLibOriginal = pPublicLinuxSysmanDriverImp->pUdevLib;
1052 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibLocal;
1053
1054 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_FABRIC_PORT_HEALTH));
1055 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
1056 phDevices[0] = device->toHandle();
1057 uint32_t numDeviceEvents = 0;
1058 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
1059 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
1060 EXPECT_EQ(0u, numDeviceEvents);
1061
1062 delete[] phDevices;
1063 delete[] pDeviceEvents;
1064 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibOriginal;
1065 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
1066 delete pPublicLinuxSysmanDriverImp;
1067 delete pUdevLibLocal;
1068 delete pMockFwInterface;
1069 }
1070
1071 TEST_F(SysmanEventsFixture, GivenEventPropertyForTypeKeyInvalidWhenListeningForFabricHealthEventsThenEventListenAPIReturnsAfterTimeout) {
1072 VariableBackup<FirmwareUtil *> backupFwUtil(&pLinuxSysmanImp->pFwUtilInterface);
1073 auto pMockFwInterface = new MockEventsFwInterface;
1074 pLinuxSysmanImp->pFwUtilInterface = pMockFwInterface;
1075
1076 VariableBackup<decltype(SysCalls::sysCallsPipe)> mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int {
1077 pipeFd[0] = mockReadPipeFd;
1078 pipeFd[1] = mockWritePipeFd;
1079 return 1;
1080 });
1081 VariableBackup<decltype(SysCalls::sysCallsPoll)> mockPoll(&SysCalls::sysCallsPoll, [](struct pollfd *pollFd, unsigned long int numberOfFds, int timeout) -> int {
1082 for (uint64_t i = 0; i < numberOfFds; i++) {
1083 if (pollFd[i].fd == mockUdevFd) {
1084 pollFd[i].revents = POLLIN;
1085 }
1086 }
1087 return 1;
1088 });
1089
1090 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
1091 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
1092 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
1093
1094 auto pUdevLibLocal = new EventsUdevLibMock();
1095 int a = 0;
1096 void *ptr = &a; // Initialize a void pointer with dummy data
1097 pUdevLibLocal->allocateDeviceToReceiveDataResult = ptr;
1098 pUdevLibLocal->getEventGenerationSourceDeviceResult = 20;
1099 pUdevLibLocal->eventPropertyValueTypeResult = "Invalid";
1100
1101 auto pUdevLibOriginal = pPublicLinuxSysmanDriverImp->pUdevLib;
1102 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibLocal;
1103
1104 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_FABRIC_PORT_HEALTH));
1105 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
1106 phDevices[0] = device->toHandle();
1107 uint32_t numDeviceEvents = 0;
1108 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
1109 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
1110 EXPECT_EQ(0u, numDeviceEvents);
1111
1112 delete[] phDevices;
1113 delete[] pDeviceEvents;
1114 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibOriginal;
1115 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
1116 delete pPublicLinuxSysmanDriverImp;
1117 delete pUdevLibLocal;
1118 delete pMockFwInterface;
1119 }
1120
1121 TEST_F(SysmanEventsFixture, GivenEventsAreRegisteredWhenEventRegisterIsCalledAgainThenSuccessIsReturned) {
1122 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
1123 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
1124 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
1125
1126 auto pLinuxEventsImp = new PublicLinuxEventsUtil(pPublicLinuxSysmanDriverImp);
1127 auto pLinuxEventsUtilOld = pPublicLinuxSysmanDriverImp->pLinuxEventsUtil;
1128 pPublicLinuxSysmanDriverImp->pLinuxEventsUtil = pLinuxEventsImp;
1129
1130 pLinuxEventsImp->pipeFd[0] = mockReadPipeFd;
1131 pLinuxEventsImp->pipeFd[1] = mockWritePipeFd;
1132 std::map<SysmanDeviceImp *, zes_event_type_flags_t> deviceEventsMap = {{pLinuxSysmanImp->getSysmanDeviceImp(), ZES_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED | ZES_EVENT_TYPE_FLAG_TEMP_THRESHOLD2}};
1133
1134 pLinuxEventsImp->deviceEventsMap = deviceEventsMap;
1135 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED));
1136
1137 pPublicLinuxSysmanDriverImp->pLinuxEventsUtil = pLinuxEventsUtilOld;
1138 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
1139 delete pPublicLinuxSysmanDriverImp;
1140 delete pLinuxEventsImp;
1141 }
1142
1143 TEST_F(SysmanEventsFixture, GivenWriteSystemCallReturnsFailureWhenEventRegisterIsCalledThenSuccessIsReturned) {
1144 VariableBackup<decltype(SysCalls::sysCallsWrite)> mockWrite(&SysCalls::sysCallsWrite, [](int fd, const void *buf, size_t count) -> ssize_t {
1145 return -1;
1146 });
1147
1148 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
1149 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
1150 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
1151
1152 auto pLinuxEventsImp = new PublicLinuxEventsUtil(pPublicLinuxSysmanDriverImp);
1153 auto pLinuxEventsUtilOld = pPublicLinuxSysmanDriverImp->pLinuxEventsUtil;
1154 pPublicLinuxSysmanDriverImp->pLinuxEventsUtil = pLinuxEventsImp;
1155
1156 pLinuxEventsImp->pipeFd[0] = mockReadPipeFd;
1157 pLinuxEventsImp->pipeFd[1] = mockWritePipeFd;
1158 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED));
1159
1160 pPublicLinuxSysmanDriverImp->pLinuxEventsUtil = pLinuxEventsUtilOld;
1161 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
1162 delete pPublicLinuxSysmanDriverImp;
1163 delete pLinuxEventsImp;
1164 }
1165
1166 TEST_F(SysmanEventsFixture,
1167 GivenValidDeviceHandleWhenListeningForResetRequiredEventsAndIfUeventReceivedWithWrongPropertyValueThenEventListenAPIReturnsWithinTimeout) {
1168 VariableBackup<FirmwareUtil *> backupFwUtil(&pLinuxSysmanImp->pFwUtilInterface);
1169 auto pMockFwInterface = new MockEventsFwInterface;
1170 pLinuxSysmanImp->pFwUtilInterface = pMockFwInterface;
1171
1172 VariableBackup<decltype(SysCalls::sysCallsPipe)> mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int {
1173 pipeFd[0] = mockReadPipeFd;
1174 pipeFd[1] = mockWritePipeFd;
1175 return 1;
1176 });
1177 VariableBackup<decltype(SysCalls::sysCallsPoll)> mockPoll(&SysCalls::sysCallsPoll, [](struct pollfd *pollFd, unsigned long int numberOfFds, int timeout) -> int {
1178 for (uint64_t i = 0; i < numberOfFds; i++) {
1179 if (pollFd[i].fd == mockUdevFd) {
1180 pollFd[i].revents = POLLIN;
1181 }
1182 }
1183 return 1;
1184 });
1185
1186 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
1187 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
1188 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
1189
1190 auto pUdevLibLocal = new EventsUdevLibMock();
1191 int a = 0;
1192 void *ptr = &a; // Initialize a void pointer with dummy data
1193 pUdevLibLocal->allocateDeviceToReceiveDataResult = ptr;
1194 pUdevLibLocal->getEventPropertyValueResult = "0";
1195
1196 auto pUdevLibOriginal = pPublicLinuxSysmanDriverImp->pUdevLib;
1197 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibLocal;
1198
1199 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED));
1200 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
1201 phDevices[0] = device->toHandle();
1202 uint32_t numDeviceEvents = 0;
1203 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
1204 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
1205 EXPECT_EQ(0u, numDeviceEvents);
1206
1207 delete[] phDevices;
1208 delete[] pDeviceEvents;
1209 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibOriginal;
1210 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
1211 delete pPublicLinuxSysmanDriverImp;
1212 delete pUdevLibLocal;
1213 delete pMockFwInterface;
1214 }
1215
1216 TEST_F(SysmanEventsFixture,
1217 GivenValidDeviceHandleWhenListeningForResetRequiredEventsAndIfDrmEventReceivedButChangeEventNotReceivedThenEventListenAPIReturnsWithinTimeout) {
1218 VariableBackup<FirmwareUtil *> backupFwUtil(&pLinuxSysmanImp->pFwUtilInterface);
1219 auto pMockFwInterface = new MockEventsFwInterface;
1220 pLinuxSysmanImp->pFwUtilInterface = pMockFwInterface;
1221
1222 VariableBackup<decltype(SysCalls::sysCallsPipe)> mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int {
1223 pipeFd[0] = mockReadPipeFd;
1224 pipeFd[1] = mockWritePipeFd;
1225 return 1;
1226 });
1227 VariableBackup<decltype(SysCalls::sysCallsPoll)> mockPoll(&SysCalls::sysCallsPoll, [](struct pollfd *pollFd, unsigned long int numberOfFds, int timeout) -> int {
1228 for (uint64_t i = 0; i < numberOfFds; i++) {
1229 if (pollFd[i].fd == mockUdevFd) {
1230 pollFd[i].revents = POLLIN;
1231 }
1232 }
1233 return 1;
1234 });
1235
1236 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
1237 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
1238 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
1239
1240 auto pUdevLibLocal = new EventsUdevLibMock();
1241 int a = 0;
1242 void *ptr = &a; // Initialize a void pointer with dummy data
1243 pUdevLibLocal->allocateDeviceToReceiveDataResult = ptr;
1244 pUdevLibLocal->getEventTypeResult = "add"; // In order to receive RESET_REQUIRED event type must be "change"
1245
1246 auto pUdevLibOriginal = pPublicLinuxSysmanDriverImp->pUdevLib;
1247 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibLocal;
1248
1249 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED));
1250 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
1251 phDevices[0] = device->toHandle();
1252 uint32_t numDeviceEvents = 0;
1253 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
1254 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
1255 EXPECT_EQ(0u, numDeviceEvents);
1256
1257 delete[] phDevices;
1258 delete[] pDeviceEvents;
1259 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibOriginal;
1260 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
1261 delete pPublicLinuxSysmanDriverImp;
1262 delete pUdevLibLocal;
1263 delete pMockFwInterface;
1264 }
1265
1266 TEST_F(SysmanEventsFixture,
1267 GivenValidDeviceHandleWhenListeningForResetRequiredEventsAndIfUeventReceivedWithNullPropertyValueThenEventListenAPIReturnsWithinTimeout) {
1268 VariableBackup<FirmwareUtil *> backupFwUtil(&pLinuxSysmanImp->pFwUtilInterface);
1269 auto pMockFwInterface = new MockEventsFwInterface;
1270 pLinuxSysmanImp->pFwUtilInterface = pMockFwInterface;
1271
1272 VariableBackup<decltype(SysCalls::sysCallsPipe)> mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int {
1273 pipeFd[0] = mockReadPipeFd;
1274 pipeFd[1] = mockWritePipeFd;
1275 return 1;
1276 });
1277 VariableBackup<decltype(SysCalls::sysCallsPoll)> mockPoll(&SysCalls::sysCallsPoll, [](struct pollfd *pollFd, unsigned long int numberOfFds, int timeout) -> int {
1278 for (uint64_t i = 0; i < numberOfFds; i++) {
1279 if (pollFd[i].fd == mockUdevFd) {
1280 pollFd[i].revents = POLLIN;
1281 }
1282 }
1283 return 1;
1284 });
1285
1286 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
1287 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
1288 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
1289
1290 auto pUdevLibLocal = new EventsUdevLibMock();
1291 int a = 0;
1292 void *ptr = &a; // Initialize a void pointer with dummy data
1293 pUdevLibLocal->allocateDeviceToReceiveDataResult = ptr;
1294 pUdevLibLocal->getEventPropertyValueResult.clear();
1295
1296 auto pUdevLibOriginal = pPublicLinuxSysmanDriverImp->pUdevLib;
1297 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibLocal;
1298
1299 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED));
1300 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
1301 phDevices[0] = device->toHandle();
1302 uint32_t numDeviceEvents = 0;
1303 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
1304 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
1305 EXPECT_EQ(0u, numDeviceEvents);
1306
1307 delete[] phDevices;
1308 delete[] pDeviceEvents;
1309 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibOriginal;
1310 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
1311 delete pPublicLinuxSysmanDriverImp;
1312 delete pUdevLibLocal;
1313 delete pMockFwInterface;
1314 }
1315
1316 HWTEST2_F(SysmanEventsFixture,
1317 GivenValidDeviceHandleWhenListeningForResetRequiredEventsAfterInFieldRepairAndIfUeventReceivedWithNullPropertyValueThenEventListenAPIReturnsResetEvent, IsPVC) {
1318 VariableBackup<FirmwareUtil *> backupFwUtil(&pLinuxSysmanImp->pFwUtilInterface);
1319 auto pMockFwInterface = new MockEventsFwInterface;
1320 pLinuxSysmanImp->pFwUtilInterface = pMockFwInterface;
1321
1322 VariableBackup<decltype(SysCalls::sysCallsPipe)> mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int {
1323 pipeFd[0] = mockReadPipeFd;
1324 pipeFd[1] = mockWritePipeFd;
1325 return 1;
1326 });
1327 VariableBackup<decltype(SysCalls::sysCallsPoll)> mockPoll(&SysCalls::sysCallsPoll, [](struct pollfd *pollFd, unsigned long int numberOfFds, int timeout) -> int {
1328 for (uint64_t i = 0; i < numberOfFds; i++) {
1329 if (pollFd[i].fd == mockUdevFd) {
1330 pollFd[i].revents = POLLIN;
1331 }
1332 }
1333 return 1;
1334 });
1335
1336 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED));
1337 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
1338 phDevices[0] = device->toHandle();
1339 uint32_t numDeviceEvents = 0;
1340 pMockFwInterface->mockIfrStatus = true;
1341 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
1342 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
1343 EXPECT_EQ(1u, numDeviceEvents);
1344 EXPECT_EQ(ZES_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED, pDeviceEvents[0]);
1345
1346 delete[] phDevices;
1347 delete[] pDeviceEvents;
1348 delete pMockFwInterface;
1349 }
1350
1351 TEST_F(SysmanEventsFixture, GivenValidDeviceHandleWhenListeningForDeviceDetachEventsThenEventListenAPIReturnsAfterReceivingEventWithinTimeout) {
1352 VariableBackup<decltype(SysCalls::sysCallsPipe)> mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int {
1353 pipeFd[0] = mockReadPipeFd;
1354 pipeFd[1] = mockWritePipeFd;
1355 return 1;
1356 });
1357 VariableBackup<decltype(SysCalls::sysCallsPoll)> mockPoll(&SysCalls::sysCallsPoll, [](struct pollfd *pollFd, unsigned long int numberOfFds, int timeout) -> int {
1358 for (uint64_t i = 0; i < numberOfFds; i++) {
1359 if (pollFd[i].fd == mockUdevFd) {
1360 pollFd[i].revents = POLLIN;
1361 }
1362 }
1363 return 1;
1364 });
1365
1366 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
1367 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
1368 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
1369
1370 auto pUdevLibLocal = new EventsUdevLibMock();
1371 int a = 0;
1372 void *ptr = &a; // Initialize a void pointer with dummy data
1373 pUdevLibLocal->allocateDeviceToReceiveDataResult = ptr;
1374 pUdevLibLocal->getEventTypeResult = "remove";
1375
1376 auto pUdevLibOriginal = pPublicLinuxSysmanDriverImp->pUdevLib;
1377 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibLocal;
1378
1379 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_DEVICE_DETACH));
1380 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
1381 phDevices[0] = device->toHandle();
1382 uint32_t numDeviceEvents = 0;
1383 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
1384 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
1385 EXPECT_EQ(1u, numDeviceEvents);
1386 EXPECT_EQ(ZES_EVENT_TYPE_FLAG_DEVICE_DETACH, pDeviceEvents[0]);
1387
1388 delete[] phDevices;
1389 delete[] pDeviceEvents;
1390 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibOriginal;
1391 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
1392 delete pPublicLinuxSysmanDriverImp;
1393 delete pUdevLibLocal;
1394 }
1395
1396 TEST_F(SysmanEventsFixture,
1397 GivenValidDeviceWhenListeningForDeviceDetachEventsAndDrmEventReceivedButRemoveEventNotReceivedThenEventListenAPIWaitForTimeout) {
1398 VariableBackup<decltype(SysCalls::sysCallsPipe)> mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int {
1399 pipeFd[0] = mockReadPipeFd;
1400 pipeFd[1] = mockWritePipeFd;
1401 return 1;
1402 });
1403 VariableBackup<decltype(SysCalls::sysCallsPoll)> mockPoll(&SysCalls::sysCallsPoll, [](struct pollfd *pollFd, unsigned long int numberOfFds, int timeout) -> int {
1404 for (uint64_t i = 0; i < numberOfFds; i++) {
1405 if (pollFd[i].fd == mockUdevFd) {
1406 pollFd[i].revents = POLLIN;
1407 }
1408 }
1409 return 1;
1410 });
1411
1412 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
1413 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
1414 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
1415
1416 auto pUdevLibLocal = new EventsUdevLibMock();
1417 int a = 0;
1418 void *ptr = &a; // Initialize a void pointer with dummy data
1419 pUdevLibLocal->allocateDeviceToReceiveDataResult = ptr;
1420 pUdevLibLocal->getEventTypeResult = "change"; // ZES_EVENT_TYPE_FLAG_DEVICE_ATTACH will be received only if EventType is "remove"
1421
1422 auto pUdevLibOriginal = pPublicLinuxSysmanDriverImp->pUdevLib;
1423 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibLocal;
1424
1425 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_DEVICE_DETACH));
1426 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
1427 phDevices[0] = device->toHandle();
1428 uint32_t numDeviceEvents = 0;
1429 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
1430 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
1431 EXPECT_EQ(0u, numDeviceEvents);
1432
1433 delete[] phDevices;
1434 delete[] pDeviceEvents;
1435 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibOriginal;
1436 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
1437 delete pPublicLinuxSysmanDriverImp;
1438 delete pUdevLibLocal;
1439 }
1440
1441 TEST_F(SysmanEventsFixture, GivenValidDeviceHandleWhenListeningForDeviceAttachEventsThenEventListenAPIReturnsAfterReceivingEventWithinTimeout) {
1442 VariableBackup<decltype(SysCalls::sysCallsPipe)> mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int {
1443 pipeFd[0] = mockReadPipeFd;
1444 pipeFd[1] = mockWritePipeFd;
1445 return 1;
1446 });
1447 VariableBackup<decltype(SysCalls::sysCallsPoll)> mockPoll(&SysCalls::sysCallsPoll, [](struct pollfd *pollFd, unsigned long int numberOfFds, int timeout) -> int {
1448 for (uint64_t i = 0; i < numberOfFds; i++) {
1449 if (pollFd[i].fd == mockUdevFd) {
1450 pollFd[i].revents = POLLIN;
1451 }
1452 }
1453 return 1;
1454 });
1455
1456 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
1457 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
1458 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
1459
1460 auto pUdevLibLocal = new EventsUdevLibMock();
1461 int a = 0;
1462 void *ptr = &a; // Initialize a void pointer with dummy data
1463 pUdevLibLocal->allocateDeviceToReceiveDataResult = ptr;
1464 pUdevLibLocal->getEventTypeResult = "add";
1465
1466 auto pUdevLibOriginal = pPublicLinuxSysmanDriverImp->pUdevLib;
1467 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibLocal;
1468
1469 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_DEVICE_ATTACH));
1470 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
1471 phDevices[0] = device->toHandle();
1472 uint32_t numDeviceEvents = 0;
1473 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
1474 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
1475 EXPECT_EQ(1u, numDeviceEvents);
1476 EXPECT_EQ(ZES_EVENT_TYPE_FLAG_DEVICE_ATTACH, pDeviceEvents[0]);
1477
1478 delete[] phDevices;
1479 delete[] pDeviceEvents;
1480 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibOriginal;
1481 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
1482 delete pPublicLinuxSysmanDriverImp;
1483 delete pUdevLibLocal;
1484 }
1485
1486 TEST_F(SysmanEventsFixture,
1487 GivenValidDeviceWhenListeningForDeviceAttachEventsAndDrmEventReceivedButAddEventNotReceivedThenEventListenAPIWaitForTimeout) {
1488 VariableBackup<decltype(SysCalls::sysCallsPipe)> mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int {
1489 pipeFd[0] = mockReadPipeFd;
1490 pipeFd[1] = mockWritePipeFd;
1491 return 1;
1492 });
1493 VariableBackup<decltype(SysCalls::sysCallsPoll)> mockPoll(&SysCalls::sysCallsPoll, [](struct pollfd *pollFd, unsigned long int numberOfFds, int timeout) -> int {
1494 for (uint64_t i = 0; i < numberOfFds; i++) {
1495 if (pollFd[i].fd == mockUdevFd) {
1496 pollFd[i].revents = POLLIN;
1497 }
1498 }
1499 return 1;
1500 });
1501
1502 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
1503 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
1504 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
1505
1506 auto pUdevLibLocal = new EventsUdevLibMock();
1507 int a = 0;
1508 void *ptr = &a; // Initialize a void pointer with dummy data
1509 pUdevLibLocal->allocateDeviceToReceiveDataResult = ptr;
1510 pUdevLibLocal->getEventTypeResult = "change"; // ZES_EVENT_TYPE_FLAG_DEVICE_ATTACH will be received only if EventType is "add"
1511
1512 auto pUdevLibOriginal = pPublicLinuxSysmanDriverImp->pUdevLib;
1513 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibLocal;
1514
1515 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_DEVICE_ATTACH));
1516 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
1517 phDevices[0] = device->toHandle();
1518 uint32_t numDeviceEvents = 0;
1519 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
1520 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
1521 EXPECT_EQ(0u, numDeviceEvents);
1522
1523 delete[] phDevices;
1524 delete[] pDeviceEvents;
1525 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibOriginal;
1526 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
1527 delete pPublicLinuxSysmanDriverImp;
1528 delete pUdevLibLocal;
1529 }
1530
1531 TEST_F(SysmanEventsFixture, GivenValidDeviceHandleWhenListeningForDeviceAttachEventsThenEventListenExAPIReturnsAfterReceivingEventWithinTimeout) {
1532 VariableBackup<decltype(SysCalls::sysCallsPipe)> mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int {
1533 pipeFd[0] = mockReadPipeFd;
1534 pipeFd[1] = mockWritePipeFd;
1535 return 1;
1536 });
1537 VariableBackup<decltype(SysCalls::sysCallsPoll)> mockPoll(&SysCalls::sysCallsPoll, [](struct pollfd *pollFd, unsigned long int numberOfFds, int timeout) -> int {
1538 for (uint64_t i = 0; i < numberOfFds; i++) {
1539 if (pollFd[i].fd == mockUdevFd) {
1540 pollFd[i].revents = POLLIN;
1541 }
1542 }
1543 return 1;
1544 });
1545
1546 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
1547 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
1548 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
1549
1550 auto pUdevLibLocal = new EventsUdevLibMock();
1551 int a = 0;
1552 void *ptr = &a; // Initialize a void pointer with dummy data
1553 pUdevLibLocal->allocateDeviceToReceiveDataResult = ptr;
1554 pUdevLibLocal->getEventTypeResult = "add";
1555
1556 auto pUdevLibOriginal = pPublicLinuxSysmanDriverImp->pUdevLib;
1557 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibLocal;
1558
1559 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_DEVICE_ATTACH));
1560 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
1561 phDevices[0] = device->toHandle();
1562 uint32_t numDeviceEvents = 0;
1563 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
1564 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListenEx(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
1565 EXPECT_EQ(1u, numDeviceEvents);
1566 EXPECT_EQ(ZES_EVENT_TYPE_FLAG_DEVICE_ATTACH, pDeviceEvents[0]);
1567
1568 delete[] phDevices;
1569 delete[] pDeviceEvents;
1570 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibOriginal;
1571 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
1572 delete pPublicLinuxSysmanDriverImp;
1573 delete pUdevLibLocal;
1574 }
1575
1576 TEST_F(SysmanEventsFixture, GivenValidDeviceHandleWhenListeningForMemHealthEventsThenEventListenAPIReturnsAfterReceivingEventWithinTimeout) {
1577 VariableBackup<decltype(SysCalls::sysCallsPipe)> mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int {
1578 pipeFd[0] = mockReadPipeFd;
1579 pipeFd[1] = mockWritePipeFd;
1580 return 1;
1581 });
1582 VariableBackup<decltype(SysCalls::sysCallsPoll)> mockPoll(&SysCalls::sysCallsPoll, [](struct pollfd *pollFd, unsigned long int numberOfFds, int timeout) -> int {
1583 for (uint64_t i = 0; i < numberOfFds; i++) {
1584 if (pollFd[i].fd == mockUdevFd) {
1585 pollFd[i].revents = POLLIN;
1586 }
1587 }
1588 return 1;
1589 });
1590
1591 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
1592 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
1593 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
1594
1595 auto pUdevLibLocal = new EventsUdevLibMock();
1596 int a = 0;
1597 void *ptr = &a; // Initialize a void pointer with dummy data
1598 pUdevLibLocal->allocateDeviceToReceiveDataResult = ptr;
1599
1600 auto pUdevLibOriginal = pPublicLinuxSysmanDriverImp->pUdevLib;
1601 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibLocal;
1602
1603 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_MEM_HEALTH));
1604 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
1605 phDevices[0] = device->toHandle();
1606 uint32_t numDeviceEvents = 0;
1607 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
1608 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
1609 EXPECT_EQ(1u, numDeviceEvents);
1610 EXPECT_EQ(ZES_EVENT_TYPE_FLAG_MEM_HEALTH, pDeviceEvents[0]);
1611
1612 delete[] phDevices;
1613 delete[] pDeviceEvents;
1614 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibOriginal;
1615 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
1616 delete pPublicLinuxSysmanDriverImp;
1617 delete pUdevLibLocal;
1618 }
1619
1620 TEST_F(SysmanEventsFixture,
1621 GivenValidDeviceHandleWhenListeningForMemHealthEventsAndIfUeventReceivedWithWrongPropertyValueThenEventListenAPIReturnsWithinTimeout) {
1622 VariableBackup<decltype(SysCalls::sysCallsPipe)> mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int {
1623 pipeFd[0] = mockReadPipeFd;
1624 pipeFd[1] = mockWritePipeFd;
1625 return 1;
1626 });
1627 VariableBackup<decltype(SysCalls::sysCallsPoll)> mockPoll(&SysCalls::sysCallsPoll, [](struct pollfd *pollFd, unsigned long int numberOfFds, int timeout) -> int {
1628 for (uint64_t i = 0; i < numberOfFds; i++) {
1629 if (pollFd[i].fd == mockUdevFd) {
1630 pollFd[i].revents = POLLIN;
1631 }
1632 }
1633 return 1;
1634 });
1635
1636 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
1637 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
1638 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
1639
1640 auto pUdevLibLocal = new EventsUdevLibMock();
1641 int a = 0;
1642 void *ptr = &a; // Initialize a void pointer with dummy data
1643 pUdevLibLocal->allocateDeviceToReceiveDataResult = ptr;
1644 pUdevLibLocal->getEventPropertyValueResult = "0"; // getEventPropertyValue must return 1 in order to assure that MEM_HEALTH event is there
1645
1646 auto pUdevLibOriginal = pPublicLinuxSysmanDriverImp->pUdevLib;
1647 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibLocal;
1648
1649 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_MEM_HEALTH));
1650 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
1651 phDevices[0] = device->toHandle();
1652 uint32_t numDeviceEvents = 0;
1653 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
1654 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
1655 EXPECT_EQ(0u, numDeviceEvents);
1656
1657 delete[] phDevices;
1658 delete[] pDeviceEvents;
1659 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibOriginal;
1660 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
1661 delete pPublicLinuxSysmanDriverImp;
1662 delete pUdevLibLocal;
1663 }
1664
1665 TEST_F(SysmanEventsFixture,
1666 GivenValidDeviceHandleWhenListeningForMemHealthEventsAndDrmEventReceivedButChangeEventNotReceivedThenEventListenAPIReturnsWithinTimeout) {
1667 VariableBackup<decltype(SysCalls::sysCallsPipe)> mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int {
1668 pipeFd[0] = mockReadPipeFd;
1669 pipeFd[1] = mockWritePipeFd;
1670 return 1;
1671 });
1672 VariableBackup<decltype(SysCalls::sysCallsPoll)> mockPoll(&SysCalls::sysCallsPoll, [](struct pollfd *pollFd, unsigned long int numberOfFds, int timeout) -> int {
1673 for (uint64_t i = 0; i < numberOfFds; i++) {
1674 if (pollFd[i].fd == mockUdevFd) {
1675 pollFd[i].revents = POLLIN;
1676 }
1677 }
1678 return 1;
1679 });
1680
1681 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
1682 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
1683 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
1684
1685 auto pUdevLibLocal = new EventsUdevLibMock();
1686 int a = 0;
1687 void *ptr = &a; // Initialize a void pointer with dummy data
1688 pUdevLibLocal->allocateDeviceToReceiveDataResult = ptr;
1689 pUdevLibLocal->getEventTypeResult = "add"; // In order to receive MEM_HEALTH event type must be "change"
1690
1691 auto pUdevLibOriginal = pPublicLinuxSysmanDriverImp->pUdevLib;
1692 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibLocal;
1693
1694 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_MEM_HEALTH));
1695 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
1696 phDevices[0] = device->toHandle();
1697 uint32_t numDeviceEvents = 0;
1698 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
1699 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
1700 EXPECT_EQ(0u, numDeviceEvents);
1701
1702 delete[] phDevices;
1703 delete[] pDeviceEvents;
1704 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibOriginal;
1705 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
1706 delete pPublicLinuxSysmanDriverImp;
1707 delete pUdevLibLocal;
1708 }
1709
1710 TEST_F(SysmanEventsFixture,
1711 GivenValidDeviceHandleWhenListeningForMemHealthEventsAndIfUeventReceivedWithNullPropertyValueThenEventListenAPIReturnsWithinTimeout) {
1712 VariableBackup<decltype(SysCalls::sysCallsPipe)> mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int {
1713 pipeFd[0] = mockReadPipeFd;
1714 pipeFd[1] = mockWritePipeFd;
1715 return 1;
1716 });
1717 VariableBackup<decltype(SysCalls::sysCallsPoll)> mockPoll(&SysCalls::sysCallsPoll, [](struct pollfd *pollFd, unsigned long int numberOfFds, int timeout) -> int {
1718 for (uint64_t i = 0; i < numberOfFds; i++) {
1719 if (pollFd[i].fd == mockUdevFd) {
1720 pollFd[i].revents = POLLIN;
1721 }
1722 }
1723 return 1;
1724 });
1725
1726 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
1727 auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
1728 driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
1729
1730 auto pUdevLibLocal = new EventsUdevLibMock();
1731 int a = 0;
1732 void *ptr = &a; // Initialize a void pointer with dummy data
1733 pUdevLibLocal->allocateDeviceToReceiveDataResult = ptr;
1734 pUdevLibLocal->getEventPropertyValueResult.clear(); // getEventPropertyValue must return 1 in order to assure that MEM_HEALTH event is there
1735
1736 auto pUdevLibOriginal = pPublicLinuxSysmanDriverImp->pUdevLib;
1737 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibLocal;
1738
1739 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_MEM_HEALTH));
1740 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
1741 phDevices[0] = device->toHandle();
1742 uint32_t numDeviceEvents = 0;
1743 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
1744 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
1745 EXPECT_EQ(0u, numDeviceEvents);
1746
1747 delete[] phDevices;
1748 delete[] pDeviceEvents;
1749 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibOriginal;
1750 driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal;
1751 delete pPublicLinuxSysmanDriverImp;
1752 delete pUdevLibLocal;
1753 }
1754
1755 HWTEST2_F(SysmanEventsFixture, GivenValidDeviceHandleWhenListeningForRasUncorrectableErrorsCrossingTotalThresholdEventAndTotalErrorsCrossesThresholdThenEventListenAPIReturnsAfterReceivingEventWithinTimeout, IsPVC) {
1756
1757 VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, [](const char *path, char *buf, size_t bufsize) -> int {
1758 constexpr size_t sizeofPath = sizeof("/sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0/0000:02:01.0/0000:03:00.0");
1759 strcpy_s(buf, sizeofPath, "/sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0/0000:02:01.0/0000:03:00.0");
1760 return sizeofPath;
1761 });
1762
1763 VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
1764 std::ostringstream oStream;
1765 oStream << pmuDriverType;
1766 std::string value = oStream.str();
1767 memcpy(buf, value.data(), count);
1768 return count;
1769 });
1770
1771 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_RAS_UNCORRECTABLE_ERRORS));
1772 auto handles = getRasHandles(mockHandleCount);
1773 for (auto handle : handles) {
1774 ASSERT_NE(nullptr, handle);
1775 zes_ras_properties_t properties = {};
1776 EXPECT_EQ(ZE_RESULT_SUCCESS, zesRasGetProperties(handle, &properties));
1777 if (properties.type == ZES_RAS_ERROR_TYPE_UNCORRECTABLE) {
1778 zes_ras_config_t setConfig = {};
1779 setConfig.totalThreshold = 14;
1780 memset(setConfig.detailedThresholds.category, 0, sizeof(setConfig.detailedThresholds.category));
1781 EXPECT_EQ(ZE_RESULT_SUCCESS, zesRasSetConfig(handle, &setConfig));
1782 }
1783 }
1784 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
1785 phDevices[0] = device->toHandle();
1786 uint32_t numDeviceEvents = 0;
1787 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
1788 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
1789 EXPECT_EQ(1u, numDeviceEvents);
1790 EXPECT_EQ(ZES_EVENT_TYPE_FLAG_RAS_UNCORRECTABLE_ERRORS, pDeviceEvents[0]);
1791 delete[] phDevices;
1792 delete[] pDeviceEvents;
1793 }
1794
1795 HWTEST2_F(SysmanEventsFixture, GivenValidDeviceHandleWhenListeningForRasUncorrectableErrorsCrossingTotalThresholdEventAndTotalErrorsCrossesThresholdThenEventListenAPIReturnsAfterReceivingEventThenAfterReceivingEventRegisterEventAgainToReceiveEvent, IsPVC) {
1796
1797 VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, [](const char *path, char *buf, size_t bufsize) -> int {
1798 constexpr size_t sizeofPath = sizeof("/sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0/0000:02:01.0/0000:03:00.0");
1799 strcpy_s(buf, sizeofPath, "/sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0/0000:02:01.0/0000:03:00.0");
1800 return sizeofPath;
1801 });
1802
1803 VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
1804 std::ostringstream oStream;
1805 oStream << pmuDriverType;
1806 std::string value = oStream.str();
1807 memcpy(buf, value.data(), count);
1808 return count;
1809 });
1810
1811 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_RAS_UNCORRECTABLE_ERRORS));
1812 auto handles = getRasHandles(mockHandleCount);
1813 for (auto handle : handles) {
1814 ASSERT_NE(nullptr, handle);
1815 zes_ras_properties_t properties = {};
1816 EXPECT_EQ(ZE_RESULT_SUCCESS, zesRasGetProperties(handle, &properties));
1817 if (properties.type == ZES_RAS_ERROR_TYPE_UNCORRECTABLE) {
1818 zes_ras_config_t setConfig = {};
1819 setConfig.totalThreshold = 14;
1820 memset(setConfig.detailedThresholds.category, 0, sizeof(setConfig.detailedThresholds.category));
1821 EXPECT_EQ(ZE_RESULT_SUCCESS, zesRasSetConfig(handle, &setConfig));
1822 }
1823 }
1824 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
1825 phDevices[0] = device->toHandle();
1826 uint32_t numDeviceEvents = 0;
1827 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
1828 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
1829 EXPECT_EQ(1u, numDeviceEvents);
1830 EXPECT_EQ(ZES_EVENT_TYPE_FLAG_RAS_UNCORRECTABLE_ERRORS, pDeviceEvents[0]);
1831 numDeviceEvents = 0;
1832 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_RAS_UNCORRECTABLE_ERRORS));
1833 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
1834 EXPECT_EQ(1u, numDeviceEvents);
1835 EXPECT_EQ(ZES_EVENT_TYPE_FLAG_RAS_UNCORRECTABLE_ERRORS, pDeviceEvents[0]);
1836 delete[] phDevices;
1837 delete[] pDeviceEvents;
1838 }
1839
1840 HWTEST2_F(SysmanEventsFixture, GivenValidDeviceHandleWhenListeningForRasCorrectableErrorsCrossingTotalThresholdEventAndTotalErrorsCrossesThresholdThenEventListenAPIReturnsAfterReceivingEventWithinTimeout, IsPVC) {
1841
1842 VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, [](const char *path, char *buf, size_t bufsize) -> int {
1843 constexpr size_t sizeofPath = sizeof("/sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0/0000:02:01.0/0000:03:00.0");
1844 strcpy_s(buf, sizeofPath, "/sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0/0000:02:01.0/0000:03:00.0");
1845 return sizeofPath;
1846 });
1847
1848 VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
1849 std::ostringstream oStream;
1850 oStream << pmuDriverType;
1851 std::string value = oStream.str();
1852 memcpy(buf, value.data(), count);
1853 return count;
1854 });
1855
1856 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_RAS_CORRECTABLE_ERRORS));
1857 auto handles = getRasHandles(mockHandleCount);
1858 for (auto handle : handles) {
1859 ASSERT_NE(nullptr, handle);
1860 zes_ras_properties_t properties = {};
1861 EXPECT_EQ(ZE_RESULT_SUCCESS, zesRasGetProperties(handle, &properties));
1862 if (properties.type == ZES_RAS_ERROR_TYPE_CORRECTABLE) {
1863 zes_ras_config_t setConfig = {};
1864 setConfig.totalThreshold = 14;
1865 memset(setConfig.detailedThresholds.category, 0, sizeof(setConfig.detailedThresholds.category));
1866 EXPECT_EQ(ZE_RESULT_SUCCESS, zesRasSetConfig(handle, &setConfig));
1867 }
1868 }
1869 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
1870 phDevices[0] = device->toHandle();
1871 uint32_t numDeviceEvents = 0;
1872 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
1873 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
1874 EXPECT_EQ(1u, numDeviceEvents);
1875 EXPECT_EQ(ZES_EVENT_TYPE_FLAG_RAS_CORRECTABLE_ERRORS, pDeviceEvents[0]);
1876 delete[] phDevices;
1877 delete[] pDeviceEvents;
1878 }
1879
1880 HWTEST2_F(SysmanEventsFixture, GivenValidDeviceHandleWhenListeningForRasUncorrectableErrorsCrossingCategoryThresholdEventAndCategoryErrorsCrossesThresholdThenEventListenAPIReturnsAfterReceivingEventWithinTimeout, IsPVC) {
1881
1882 VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, [](const char *path, char *buf, size_t bufsize) -> int {
1883 constexpr size_t sizeofPath = sizeof("/sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0/0000:02:01.0/0000:03:00.0");
1884 strcpy_s(buf, sizeofPath, "/sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0/0000:02:01.0/0000:03:00.0");
1885 return sizeofPath;
1886 });
1887
1888 VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
1889 std::ostringstream oStream;
1890 oStream << pmuDriverType;
1891 std::string value = oStream.str();
1892 memcpy(buf, value.data(), count);
1893 return count;
1894 });
1895
1896 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_RAS_UNCORRECTABLE_ERRORS));
1897 auto handles = getRasHandles(mockHandleCount);
1898 for (auto handle : handles) {
1899 ASSERT_NE(nullptr, handle);
1900 zes_ras_properties_t properties = {};
1901 EXPECT_EQ(ZE_RESULT_SUCCESS, zesRasGetProperties(handle, &properties));
1902 if (properties.type == ZES_RAS_ERROR_TYPE_UNCORRECTABLE) {
1903 zes_ras_config_t setConfig = {};
1904 setConfig.totalThreshold = 0;
1905 memset(setConfig.detailedThresholds.category, 0, sizeof(setConfig.detailedThresholds.category));
1906 setConfig.detailedThresholds.category[ZES_RAS_ERROR_CAT_RESET] = 12;
1907 EXPECT_EQ(ZE_RESULT_SUCCESS, zesRasSetConfig(handle, &setConfig));
1908 }
1909 }
1910 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
1911 phDevices[0] = device->toHandle();
1912 uint32_t numDeviceEvents = 0;
1913 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
1914 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
1915 EXPECT_EQ(1u, numDeviceEvents);
1916 EXPECT_EQ(ZES_EVENT_TYPE_FLAG_RAS_UNCORRECTABLE_ERRORS, pDeviceEvents[0]);
1917 delete[] phDevices;
1918 delete[] pDeviceEvents;
1919 }
1920
1921 HWTEST2_F(SysmanEventsFixture, GivenValidDeviceHandleWhenListeningForRasCorrectableErrorsCrossingCategoryThresholdEventAndCategoryErrorsCrossesThresholdThenEventListenAPIReturnsAfterReceivingEventWithinTimeout, IsPVC) {
1922
1923 VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, [](const char *path, char *buf, size_t bufsize) -> int {
1924 constexpr size_t sizeofPath = sizeof("/sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0/0000:02:01.0/0000:03:00.0");
1925 strcpy_s(buf, sizeofPath, "/sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0/0000:02:01.0/0000:03:00.0");
1926 return sizeofPath;
1927 });
1928
1929 VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
1930 std::ostringstream oStream;
1931 oStream << pmuDriverType;
1932 std::string value = oStream.str();
1933 memcpy(buf, value.data(), count);
1934 return count;
1935 });
1936
1937 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_RAS_CORRECTABLE_ERRORS));
1938 auto handles = getRasHandles(mockHandleCount);
1939 for (auto handle : handles) {
1940 ASSERT_NE(nullptr, handle);
1941 zes_ras_properties_t properties = {};
1942 EXPECT_EQ(ZE_RESULT_SUCCESS, zesRasGetProperties(handle, &properties));
1943 if (properties.type == ZES_RAS_ERROR_TYPE_CORRECTABLE) {
1944 zes_ras_config_t setConfig = {};
1945 setConfig.totalThreshold = 0;
1946 memset(setConfig.detailedThresholds.category, 0, sizeof(setConfig.detailedThresholds.category));
1947 setConfig.detailedThresholds.category[ZES_RAS_ERROR_CAT_COMPUTE_ERRORS] = 11;
1948 EXPECT_EQ(ZE_RESULT_SUCCESS, zesRasSetConfig(handle, &setConfig));
1949 }
1950 }
1951 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
1952 phDevices[0] = device->toHandle();
1953 uint32_t numDeviceEvents = 0;
1954 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
1955 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
1956 EXPECT_EQ(1u, numDeviceEvents);
1957 EXPECT_EQ(ZES_EVENT_TYPE_FLAG_RAS_CORRECTABLE_ERRORS, pDeviceEvents[0]);
1958 delete[] phDevices;
1959 delete[] pDeviceEvents;
1960 }
1961
1962 HWTEST2_F(SysmanEventsFixture, GivenValidDeviceHandleWhenListeningForRasUncorrectableErrorsCrossingTotalThresholdEventThenEventListenAPIWaitForTimeoutIfEventNotReceived, IsPVC) {
1963 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_RAS_UNCORRECTABLE_ERRORS));
1964 auto handles = getRasHandles(mockHandleCount);
1965 for (auto handle : handles) {
1966 ASSERT_NE(nullptr, handle);
1967 zes_ras_properties_t properties = {};
1968 EXPECT_EQ(ZE_RESULT_SUCCESS, zesRasGetProperties(handle, &properties));
1969 if (properties.type == ZES_RAS_ERROR_TYPE_UNCORRECTABLE) {
1970 zes_ras_config_t setConfig = {};
1971 setConfig.totalThreshold = 0;
1972 memset(setConfig.detailedThresholds.category, 0, sizeof(setConfig.detailedThresholds.category));
1973 EXPECT_EQ(ZE_RESULT_SUCCESS, zesRasSetConfig(handle, &setConfig));
1974 }
1975 }
1976 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
1977 phDevices[0] = device->toHandle();
1978 uint32_t numDeviceEvents = 0;
1979 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
1980 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
1981 EXPECT_EQ(0u, numDeviceEvents);
1982 delete[] phDevices;
1983 delete[] pDeviceEvents;
1984 }
1985
1986 HWTEST2_F(SysmanEventsFixture, GivenRasGetStateReturnsFailureWhenListeningForRasUncorrectableErrorsCrossingTotalThresholdEventThenEventListenAPIReturnsNoEvents, IsPVC) {
1987 pFsAccess->mockListDirectoryResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
1988 VariableBackup<FirmwareUtil *> backupFwUtil(&pLinuxSysmanImp->pFwUtilInterface);
1989 auto pMockFwInterface = new MockEventsFwInterface;
1990 pLinuxSysmanImp->pFwUtilInterface = pMockFwInterface;
1991 pMockFwInterface->fwGetMemoryErrorCountResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
1992 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_RAS_UNCORRECTABLE_ERRORS));
1993 for (const auto &handle : pSysmanDeviceImp->pRasHandleContext->handleList) {
1994 delete handle;
1995 }
1996 pSysmanDeviceImp->pRasHandleContext->handleList.clear();
1997 pSysmanDeviceImp->pRasHandleContext->init(pOsSysman->getSubDeviceCount());
1998 auto handles = getRasHandles(mockHandleCount);
1999 for (auto handle : handles) {
2000 ASSERT_NE(nullptr, handle);
2001 zes_ras_properties_t properties = {};
2002 EXPECT_EQ(ZE_RESULT_SUCCESS, zesRasGetProperties(handle, &properties));
2003 if (properties.type == ZES_RAS_ERROR_TYPE_UNCORRECTABLE) {
2004 zes_ras_config_t setConfig = {};
2005 setConfig.totalThreshold = 0;
2006 memset(setConfig.detailedThresholds.category, 0, sizeof(setConfig.detailedThresholds.category));
2007 EXPECT_EQ(ZE_RESULT_SUCCESS, zesRasSetConfig(handle, &setConfig));
2008 }
2009 }
2010 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
2011 phDevices[0] = device->toHandle();
2012 uint32_t numDeviceEvents = 0;
2013 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
2014 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
2015 EXPECT_EQ(0u, numDeviceEvents);
2016 delete[] phDevices;
2017 delete[] pDeviceEvents;
2018 delete pMockFwInterface;
2019 }
2020
2021 HWTEST2_F(SysmanEventsFixture, GivenValidDeviceHandleWhenListeningForRasCorrectableErrorsCrossingTotalThresholdEventThenEventListenAPIWaitForTimeoutIfEventNotReceived, IsPVC) {
2022 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_RAS_CORRECTABLE_ERRORS));
2023 auto handles = getRasHandles(mockHandleCount);
2024 for (auto handle : handles) {
2025 ASSERT_NE(nullptr, handle);
2026 zes_ras_properties_t properties = {};
2027 EXPECT_EQ(ZE_RESULT_SUCCESS, zesRasGetProperties(handle, &properties));
2028 if (properties.type == ZES_RAS_ERROR_TYPE_CORRECTABLE) {
2029 zes_ras_config_t setConfig = {};
2030 setConfig.totalThreshold = 0;
2031 memset(setConfig.detailedThresholds.category, 0, sizeof(setConfig.detailedThresholds.category));
2032 EXPECT_EQ(ZE_RESULT_SUCCESS, zesRasSetConfig(handle, &setConfig));
2033 }
2034 }
2035 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
2036 phDevices[0] = device->toHandle();
2037 uint32_t numDeviceEvents = 0;
2038 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
2039 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
2040 EXPECT_EQ(0u, numDeviceEvents);
2041 delete[] phDevices;
2042 delete[] pDeviceEvents;
2043 }
2044
2045 HWTEST2_F(SysmanEventsFixture, GivenValidDeviceHandleWhenListeningForRasCorrectableErrorsCrossingTotalThresholdEventAndPmuReadSingleFailsThenEventListenAPIWaitForTimeoutIfEventNotReceived, IsPVC) {
2046
2047 pPmuInterface->mockPmuReadFail = true;
2048
2049 for (const auto &handle : pSysmanDeviceImp->pRasHandleContext->handleList) {
2050 delete handle;
2051 }
2052 pSysmanDeviceImp->pRasHandleContext->handleList.clear();
2053 pSysmanDeviceImp->pRasHandleContext->init(pOsSysman->getSubDeviceCount());
2054 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_RAS_CORRECTABLE_ERRORS));
2055 auto handles = getRasHandles(mockHandleCount);
2056 for (auto handle : handles) {
2057 ASSERT_NE(nullptr, handle);
2058 zes_ras_properties_t properties = {};
2059 EXPECT_EQ(ZE_RESULT_SUCCESS, zesRasGetProperties(handle, &properties));
2060 if (properties.type == ZES_RAS_ERROR_TYPE_CORRECTABLE) {
2061 zes_ras_config_t setConfig = {};
2062 setConfig.totalThreshold = 10;
2063 memset(setConfig.detailedThresholds.category, 0, sizeof(setConfig.detailedThresholds.category));
2064 EXPECT_EQ(ZE_RESULT_SUCCESS, zesRasSetConfig(handle, &setConfig));
2065 }
2066 }
2067 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
2068 phDevices[0] = device->toHandle();
2069 uint32_t numDeviceEvents = 0;
2070 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
2071 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
2072 EXPECT_EQ(0u, numDeviceEvents);
2073 delete[] phDevices;
2074 delete[] pDeviceEvents;
2075 }
2076
2077 HWTEST2_F(SysmanEventsFixture, GivenValidDeviceHandleWhenListeningForRasUncorrectableErrorsCrossingTotalThresholdEventAndTotalErrorsDoNotThresholdThenEventListenAPIWaitForTimeoutIfEventNotReceived, IsPVC) {
2078 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_RAS_UNCORRECTABLE_ERRORS));
2079 auto handles = getRasHandles(mockHandleCount);
2080 for (auto handle : handles) {
2081 ASSERT_NE(nullptr, handle);
2082 zes_ras_properties_t properties = {};
2083 EXPECT_EQ(ZE_RESULT_SUCCESS, zesRasGetProperties(handle, &properties));
2084 if (properties.type == ZES_RAS_ERROR_TYPE_UNCORRECTABLE) {
2085 zes_ras_config_t setConfig = {};
2086 setConfig.totalThreshold = 30;
2087 memset(setConfig.detailedThresholds.category, 0, sizeof(setConfig.detailedThresholds.category));
2088 EXPECT_EQ(ZE_RESULT_SUCCESS, zesRasSetConfig(handle, &setConfig));
2089 }
2090 }
2091 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
2092 phDevices[0] = device->toHandle();
2093 uint32_t numDeviceEvents = 0;
2094 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
2095 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
2096 EXPECT_EQ(0u, numDeviceEvents);
2097 delete[] phDevices;
2098 delete[] pDeviceEvents;
2099 }
2100
2101 HWTEST2_F(SysmanEventsFixture, GivenValidDeviceHandleWhenListeningForRasCorrectableErrorsCrossingCategoryThresholdEventAndCategoryErrorsDoNotCrossThresholdThenEventListenAPIWaitForTimeoutIfEventNotReceived, IsPVC) {
2102 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_RAS_CORRECTABLE_ERRORS));
2103 auto handles = getRasHandles(mockHandleCount);
2104 for (auto handle : handles) {
2105 ASSERT_NE(nullptr, handle);
2106 zes_ras_properties_t properties = {};
2107 EXPECT_EQ(ZE_RESULT_SUCCESS, zesRasGetProperties(handle, &properties));
2108 if (properties.type == ZES_RAS_ERROR_TYPE_CORRECTABLE) {
2109 zes_ras_config_t setConfig = {};
2110 setConfig.totalThreshold = 0;
2111 memset(setConfig.detailedThresholds.category, 0, sizeof(setConfig.detailedThresholds.category));
2112 setConfig.detailedThresholds.category[ZES_RAS_ERROR_CAT_CACHE_ERRORS] = 35;
2113 EXPECT_EQ(ZE_RESULT_SUCCESS, zesRasSetConfig(handle, &setConfig));
2114 }
2115 }
2116 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
2117 phDevices[0] = device->toHandle();
2118 uint32_t numDeviceEvents = 0;
2119 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
2120 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
2121 EXPECT_EQ(0u, numDeviceEvents);
2122 delete[] phDevices;
2123 delete[] pDeviceEvents;
2124 }
2125
2126 TEST_F(SysmanEventsFixture, GivenValidDeviceHandleWhenListeningForUnsupportedEventTypeThenEventListenAPIReturnsWithinTimeout) {
2127 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_FREQ_THROTTLED));
2128
2129 zes_device_handle_t *phDevices = new zes_device_handle_t[1];
2130 phDevices[0] = device->toHandle();
2131 uint32_t numDeviceEvents = 0;
2132 zes_event_type_flags_t *pDeviceEvents = new zes_event_type_flags_t[1];
2133
2134 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices, &numDeviceEvents, pDeviceEvents));
2135 EXPECT_EQ(0u, numDeviceEvents);
2136 delete[] phDevices;
2137 delete[] pDeviceEvents;
2138 }
2139
2140 } // namespace ult
2141 } // namespace Sysman
2142 } // namespace L0