Debian Codegraph @

level_zero/tools/test/unit_tests/sources/sysman/linux/test_sysman.cpp

raw
1 /*
2 * Copyright (C) 2020-2026 Intel Corporation
3 *
4 * SPDX-License-Identifier: MIT
5 *
6 */
7
8 #include "shared/source/os_interface/linux/system_info.h"
9 #include "shared/test/common/mocks/mock_driver_model.h"
10 #include "shared/test/common/os_interface/linux/sys_calls_linux_ult.h"
11 #include "shared/test/common/test_macros/test.h"
12
13 #include "level_zero/sysman/source/driver/sysman_driver.h"
14 #include "level_zero/tools/source/sysman/diagnostics/diagnostics_imp.h"
15 #include "level_zero/tools/source/sysman/diagnostics/linux/os_diagnostics_imp.h"
16 #include "level_zero/tools/source/sysman/ecc/ecc.h"
17 #include "level_zero/tools/source/sysman/events/events.h"
18 #include "level_zero/tools/source/sysman/events/linux/os_events_imp.h"
19 #include "level_zero/tools/source/sysman/firmware/firmware_imp.h"
20 #include "level_zero/tools/source/sysman/firmware/linux/os_firmware_imp.h"
21 #include "level_zero/tools/source/sysman/global_operations/global_operations.h"
22 #include "level_zero/tools/source/sysman/linux/pmu/pmu.h"
23 #include "level_zero/tools/source/sysman/pci/pci.h"
24 #include "level_zero/tools/source/sysman/ras/ras_imp.h"
25 #include "level_zero/tools/test/unit_tests/sources/sysman/linux/mock_sysman_fixture.h"
26
27 #include "drm.h"
28
29 namespace NEO {
30 namespace SysCalls {
31 extern bool allowFakeDevicePath;
32 } // namespace SysCalls
33 } // namespace NEO
34
35 namespace L0 {
36 namespace ult {
37
38 inline static int mockAccessFailure(const char *pathname, int mode) {
39 return -1;
40 }
41
42 inline static int mockAccessSuccess(const char *pathname, int mode) {
43 return 0;
44 }
45
46 inline static int mockStatFailure(const char *pathname, struct stat *sb) noexcept {
47 return -1;
48 }
49
50 inline static int mockStatSuccess(const char *pathname, struct stat *sb) noexcept {
51 sb->st_mode = S_IWUSR | S_IRUSR;
52 return 0;
53 }
54
55 inline static int mockStatNoPermissions(const char *pathname, struct stat *sb) noexcept {
56 sb->st_mode = 0;
57 return 0;
58 }
59
60 TEST_F(SysmanDeviceFixture, GivenValidDeviceHandleInSysmanImpCreationWhenAllSysmanInterfacesAreAssignedToNullThenExpectSysmanDeviceModuleContextsAreNull) {
61 ze_device_handle_t hSysman = device->toHandle();
62 SysmanDeviceImp *sysmanImp = new SysmanDeviceImp(hSysman);
63
64 delete (sysmanImp->pPowerHandleContext);
65 delete (sysmanImp->pFrequencyHandleContext);
66 delete (sysmanImp->pFabricPortHandleContext);
67 delete (sysmanImp->pTempHandleContext);
68 delete (sysmanImp->pPci);
69 delete (sysmanImp->pStandbyHandleContext);
70 delete (sysmanImp->pEngineHandleContext);
71 delete (sysmanImp->pSchedulerHandleContext);
72 delete (sysmanImp->pRasHandleContext);
73 delete (sysmanImp->pMemoryHandleContext);
74 delete (sysmanImp->pGlobalOperations);
75 delete (sysmanImp->pEvents);
76 delete (sysmanImp->pFanHandleContext);
77 delete (sysmanImp->pFirmwareHandleContext);
78 delete (sysmanImp->pDiagnosticsHandleContext);
79 delete (sysmanImp->pPerformanceHandleContext);
80 delete (sysmanImp->pEcc);
81
82 sysmanImp->pPowerHandleContext = nullptr;
83 sysmanImp->pFrequencyHandleContext = nullptr;
84 sysmanImp->pFabricPortHandleContext = nullptr;
85 sysmanImp->pTempHandleContext = nullptr;
86 sysmanImp->pPci = nullptr;
87 sysmanImp->pStandbyHandleContext = nullptr;
88 sysmanImp->pEngineHandleContext = nullptr;
89 sysmanImp->pSchedulerHandleContext = nullptr;
90 sysmanImp->pRasHandleContext = nullptr;
91 sysmanImp->pMemoryHandleContext = nullptr;
92 sysmanImp->pGlobalOperations = nullptr;
93 sysmanImp->pEvents = nullptr;
94 sysmanImp->pFanHandleContext = nullptr;
95 sysmanImp->pFirmwareHandleContext = nullptr;
96 sysmanImp->pDiagnosticsHandleContext = nullptr;
97 sysmanImp->pPerformanceHandleContext = nullptr;
98 sysmanImp->pEcc = nullptr;
99
100 auto pLinuxSysmanImpTemp = static_cast<PublicLinuxSysmanImp *>(sysmanImp->pOsSysman);
101 pLinuxSysmanImpTemp->pSysfsAccess = pSysfsAccess;
102 pLinuxSysmanImpTemp->pProcfsAccess = pProcfsAccess;
103
104 sysmanImp->init();
105 // all sysman module contexts are null. Validating PowerHandleContext instead of all contexts
106 EXPECT_EQ(sysmanImp->pPowerHandleContext, nullptr);
107 pLinuxSysmanImpTemp->pSysfsAccess = nullptr;
108 pLinuxSysmanImpTemp->pProcfsAccess = nullptr;
109 delete sysmanImp;
110 sysmanImp = nullptr;
111 }
112
113 TEST_F(SysmanDeviceFixture, GivenValidDeviceHandleAndIfSysmanDeviceInitFailsThenErrorReturnedWhileQueryingSysmanAPIs) {
114 ze_device_handle_t hSysman = device->toHandle();
115 auto pSysmanDeviceOriginal = device->getSysmanHandle();
116
117 // L0::SysmanDeviceHandleContext::init() would return nullptr as:
118 // L0::SysmanDeviceHandleContext::init() --> sysmanDevice->init() --> pOsSysman->init() --> pSysfsAccess->getRealPath()
119 // pSysfsAccess->getRealPath() would fail because pSysfsAccess is not mocked in this test case.
120 auto pSysmanDeviceLocal = L0::SysmanDeviceHandleContext::init(hSysman);
121 EXPECT_EQ(pSysmanDeviceLocal, nullptr);
122 device->setSysmanHandle(pSysmanDeviceLocal);
123 uint32_t count = 0;
124 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDeviceEnumSchedulers(hSysman, &count, nullptr));
125 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDeviceProcessesGetState(hSysman, &count, nullptr));
126 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDevicePciGetBars(hSysman, &count, nullptr));
127 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDeviceEnumPowerDomains(hSysman, &count, nullptr));
128 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDeviceEnumFrequencyDomains(hSysman, &count, nullptr));
129 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDeviceEnumEngineGroups(hSysman, &count, nullptr));
130 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDeviceEnumStandbyDomains(hSysman, &count, nullptr));
131 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDeviceEnumFirmwares(hSysman, &count, nullptr));
132 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDeviceEnumMemoryModules(hSysman, &count, nullptr));
133 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDeviceEnumFabricPorts(hSysman, &count, nullptr));
134 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDeviceEnumTemperatureSensors(hSysman, &count, nullptr));
135 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDeviceEnumRasErrorSets(hSysman, &count, nullptr));
136 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDeviceEnumFans(hSysman, &count, nullptr));
137 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDeviceEnumDiagnosticTestSuites(hSysman, &count, nullptr));
138 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDeviceEnumPerformanceFactorDomains(hSysman, &count, nullptr));
139
140 zes_device_properties_t properties;
141 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDeviceGetProperties(hSysman, &properties));
142 zes_device_state_t state;
143 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDeviceGetState(hSysman, &state));
144 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDeviceReset(hSysman, true));
145 zes_pci_properties_t pciProperties;
146 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDevicePciGetProperties(hSysman, &pciProperties));
147 zes_pci_state_t pciState;
148 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDevicePciGetState(hSysman, &pciState));
149 zes_pci_stats_t pciStats;
150 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDevicePciGetStats(hSysman, &pciStats));
151 zes_event_type_flags_t events = ZES_EVENT_TYPE_FLAG_DEVICE_DETACH;
152 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDeviceEventRegister(hSysman, events));
153 zes_pwr_handle_t phPower = {};
154 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDeviceGetCardPowerDomain(hSysman, &phPower));
155 ze_bool_t eccAvailable = false;
156 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDeviceEccAvailable(device, &eccAvailable));
157 ze_bool_t eccConfigurable = false;
158 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDeviceEccConfigurable(device, &eccConfigurable));
159 zes_device_ecc_desc_t newState = {};
160 zes_device_ecc_properties_t props = {};
161 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDeviceSetEccState(device, &newState, &props));
162 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDeviceGetEccState(device, &props));
163 device->setSysmanHandle(pSysmanDeviceOriginal);
164 }
165
166 TEST_F(SysmanDeviceFixture, GivenValidDeviceHandleAndSysmanHandleIsSetToNullWhenSysmanAPICalledThenErrorIsReturned) {
167 ze_device_handle_t hSysman = device->toHandle();
168 auto pSysmanDeviceOriginal = device->getSysmanHandle();
169 device->setSysmanHandle(nullptr);
170
171 uint32_t count = 0;
172 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, L0::SysmanDevice::schedulerGet(hSysman, &count, nullptr));
173 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, L0::SysmanDevice::processesGetState(hSysman, &count, nullptr));
174 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, L0::SysmanDevice::pciGetBars(hSysman, &count, nullptr));
175 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, L0::SysmanDevice::powerGet(hSysman, &count, nullptr));
176 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, L0::SysmanDevice::frequencyGet(hSysman, &count, nullptr));
177 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, L0::SysmanDevice::engineGet(hSysman, &count, nullptr));
178 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, L0::SysmanDevice::standbyGet(hSysman, &count, nullptr));
179 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, L0::SysmanDevice::firmwareGet(hSysman, &count, nullptr));
180 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, L0::SysmanDevice::memoryGet(hSysman, &count, nullptr));
181 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, L0::SysmanDevice::fabricPortGet(hSysman, &count, nullptr));
182 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, L0::SysmanDevice::temperatureGet(hSysman, &count, nullptr));
183 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, L0::SysmanDevice::rasGet(hSysman, &count, nullptr));
184 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, L0::SysmanDevice::fanGet(hSysman, &count, nullptr));
185 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, L0::SysmanDevice::diagnosticsGet(hSysman, &count, nullptr));
186 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, L0::SysmanDevice::performanceGet(hSysman, &count, nullptr));
187 zes_device_properties_t properties;
188 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, L0::SysmanDevice::deviceGetProperties(hSysman, &properties));
189 zes_device_state_t state;
190 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, L0::SysmanDevice::deviceGetState(hSysman, &state));
191 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, L0::SysmanDevice::deviceReset(hSysman, true));
192 zes_pci_properties_t pciProperties;
193 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, L0::SysmanDevice::pciGetProperties(hSysman, &pciProperties));
194 zes_pci_state_t pciState;
195 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, L0::SysmanDevice::pciGetState(hSysman, &pciState));
196 zes_pci_stats_t pciStats;
197 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, L0::SysmanDevice::pciGetStats(hSysman, &pciStats));
198 zes_event_type_flags_t events = ZES_EVENT_TYPE_FLAG_DEVICE_DETACH;
199 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, L0::SysmanDevice::deviceEventRegister(hSysman, events));
200 zes_pwr_handle_t phPower = {};
201 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, L0::SysmanDevice::powerGetCardDomain(hSysman, &phPower));
202 ze_bool_t eccAvailable = false;
203 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, L0::SysmanDevice::deviceEccAvailable(device, &eccAvailable));
204 ze_bool_t eccConfigurable = false;
205 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, L0::SysmanDevice::deviceEccConfigurable(device, &eccConfigurable));
206 zes_device_ecc_desc_t newState = {};
207 zes_device_ecc_properties_t props = {};
208 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, L0::SysmanDevice::deviceSetEccState(device, &newState, &props));
209 EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, L0::SysmanDevice::deviceGetEccState(device, &props));
210 device->setSysmanHandle(pSysmanDeviceOriginal);
211 }
212
213 using MockDeviceSysmanGetTest = Test<DeviceFixture>;
214 TEST_F(MockDeviceSysmanGetTest, GivenValidSysmanHandleSetInDeviceStructWhenGetThisSysmanHandleThenHandlesShouldBeSimilar) {
215 SysmanDeviceImp *sysman = new SysmanDeviceImp(device->toHandle());
216 device->setSysmanHandle(sysman);
217 EXPECT_EQ(sysman, device->getSysmanHandle());
218 }
219
220 TEST_F(SysmanDeviceFixture, GivenValidDeviceHandleButSysmanInitFailsThenValidNullptrReceived) {
221 ze_device_handle_t hSysman = device->toHandle();
222 auto pSysmanDevice = L0::SysmanDeviceHandleContext::init(hSysman);
223 EXPECT_EQ(pSysmanDevice, nullptr);
224 }
225
226 TEST_F(SysmanDeviceFixture, GivenValidDeviceHandleWithSysmanOnlyInitSetAsTrueThenSysmanInitFailsAndValidNullptrReceived) {
227 ze_device_handle_t hSysman = device->toHandle();
228 L0::Sysman::sysmanOnlyInit = true;
229 L0::sysmanInitFromCore = false;
230 auto pSysmanDevice = L0::SysmanDeviceHandleContext::init(hSysman);
231 EXPECT_EQ(pSysmanDevice, nullptr);
232 EXPECT_FALSE(L0::sysmanInitFromCore);
233 L0::Sysman::sysmanOnlyInit = false;
234 }
235
236 TEST_F(SysmanDeviceFixture, GivenSetValidDrmHandleForDeviceWhenDoingOsSysmanDeviceInitThenSameDrmHandleIsRetrieved) {
237 EXPECT_EQ(&pLinuxSysmanImp->getDrm(), device->getOsInterface()->getDriverModel()->as<Drm>());
238 }
239
240 TEST_F(SysmanDeviceFixture, GivenCreateFsAccessHandleWhenCallinggetFsAccessThenCreatedFsAccessHandleWillBeRetrieved) {
241 if (pLinuxSysmanImp->pFsAccess != nullptr) {
242 // delete previously allocated pFsAccess
243 delete pLinuxSysmanImp->pFsAccess;
244 pLinuxSysmanImp->pFsAccess = nullptr;
245 }
246 pLinuxSysmanImp->pFsAccess = FsAccess::create();
247 EXPECT_EQ(&pLinuxSysmanImp->getFsAccess(), pLinuxSysmanImp->pFsAccess);
248 }
249
250 std::string getcwd(char buf[], size_t size) {
251 auto cwd = ::getcwd(buf, size);
252 if (cwd) {
253 return cwd;
254 }
255 return "";
256 }
257
258 TEST_F(SysmanDeviceFixture, GivenPublicFsAccessClassWhenCallingDirectoryExistsWithValidAndInvalidPathThenSuccessAndFailureAreReturnedRespectively) {
259 PublicFsAccess *tempFsAccess = new PublicFsAccess();
260 tempFsAccess->accessSyscall = mockAccessSuccess;
261 char cwd[PATH_MAX];
262 std::string path = getcwd(cwd, PATH_MAX);
263 EXPECT_TRUE(tempFsAccess->directoryExists(path));
264 tempFsAccess->accessSyscall = mockAccessFailure;
265 path = "invalidDiretory";
266 EXPECT_FALSE(tempFsAccess->directoryExists(path));
267 delete tempFsAccess;
268 }
269
270 TEST_F(SysmanDeviceFixture, GivenPublicSysfsAccessClassWhenCallingDirectoryExistsWithInvalidPathThenFalseIsRetured) {
271 PublicFsAccess *tempSysfsAccess = new PublicFsAccess();
272 tempSysfsAccess->accessSyscall = mockAccessFailure;
273 std::string path = "invalidDiretory";
274 EXPECT_FALSE(tempSysfsAccess->directoryExists(path));
275 delete tempSysfsAccess;
276 }
277
278 TEST_F(SysmanDeviceFixture, GivenPublicFsAccessClassWhenCallingCanWriteWithUserHavingWritePermissionsThenSuccessIsReturned) {
279 PublicFsAccess *tempFsAccess = new PublicFsAccess();
280 tempFsAccess->statSyscall = mockStatSuccess;
281 char cwd[PATH_MAX];
282 std::string path = getcwd(cwd, PATH_MAX);
283 EXPECT_EQ(ZE_RESULT_SUCCESS, tempFsAccess->canWrite(path));
284 delete tempFsAccess;
285 }
286
287 TEST_F(SysmanDeviceFixture, GivenPublicFsAccessClassWhenCallingCanReadWithUserHavingReadPermissionsThenSuccessIsReturned) {
288 PublicFsAccess *tempFsAccess = new PublicFsAccess();
289 tempFsAccess->statSyscall = mockStatSuccess;
290 char cwd[PATH_MAX];
291 std::string path = getcwd(cwd, PATH_MAX);
292 EXPECT_EQ(ZE_RESULT_SUCCESS, tempFsAccess->canRead(path));
293 delete tempFsAccess;
294 }
295
296 TEST_F(SysmanDeviceFixture, GivenPublicFsAccessClassWhenCallingCanWriteWithUserNotHavingWritePermissionsThenInsufficientIsReturned) {
297 PublicFsAccess *tempFsAccess = new PublicFsAccess();
298 tempFsAccess->statSyscall = mockStatNoPermissions;
299 char cwd[PATH_MAX];
300 std::string path = getcwd(cwd, PATH_MAX);
301 EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, tempFsAccess->canWrite(path));
302 delete tempFsAccess;
303 }
304
305 TEST_F(SysmanDeviceFixture, GivenPublicFsAccessClassWhenCallingCanReadWithUserNotHavingReadPermissionsThenInsufficientIsReturned) {
306 PublicFsAccess *tempFsAccess = new PublicFsAccess();
307 tempFsAccess->statSyscall = mockStatNoPermissions;
308 char cwd[PATH_MAX];
309 std::string path = getcwd(cwd, PATH_MAX);
310 EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, tempFsAccess->canRead(path));
311 delete tempFsAccess;
312 }
313
314 TEST_F(SysmanDeviceFixture, GivenPublicFsAccessClassWhenCallingCanReadWithInvalidPathThenErrorIsReturned) {
315 PublicFsAccess *tempFsAccess = new PublicFsAccess();
316 tempFsAccess->statSyscall = mockStatFailure;
317 std::string path = "invalidPath";
318 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, tempFsAccess->canRead(path));
319 delete tempFsAccess;
320 }
321
322 TEST_F(SysmanDeviceFixture, GivenPublicFsAccessClassWhenCallingCanWriteWithInvalidPathThenErrorIsReturned) {
323 PublicFsAccess *tempFsAccess = new PublicFsAccess();
324 tempFsAccess->statSyscall = mockStatFailure;
325 std::string path = "invalidPath";
326 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, tempFsAccess->canRead(path));
327 delete tempFsAccess;
328 }
329
330 TEST_F(SysmanDeviceFixture, GivenValidPathnameWhenCallingFsAccessExistsThenSuccessIsReturned) {
331 VariableBackup<bool> allowFakeDevicePathBackup(&SysCalls::allowFakeDevicePath, true);
332 auto fsAccess = pLinuxSysmanImp->getFsAccess();
333
334 char cwd[PATH_MAX];
335 std::string path = getcwd(cwd, PATH_MAX);
336 EXPECT_TRUE(fsAccess.fileExists(path));
337 }
338
339 TEST_F(SysmanDeviceFixture, GivenInvalidPathnameWhenCallingFsAccessExistsThenErrorIsReturned) {
340 auto fsAccess = pLinuxSysmanImp->getFsAccess();
341
342 std::string path = "noSuchFileOrDirectory";
343 EXPECT_FALSE(fsAccess.fileExists(path));
344 }
345
346 TEST_F(SysmanDeviceFixture, GivenSysfsAccessAndValidDeviceNameWhenCallingBindDeviceThenSuccessIsReturned) {
347
348 std::string deviceName = "card0";
349
350 VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int {
351 return 1;
352 });
353
354 VariableBackup<decltype(NEO::SysCalls::sysCallsPwrite)> mockPwrite(&NEO::SysCalls::sysCallsPwrite, [](int fd, const void *buf, size_t count, off_t offset) -> ssize_t {
355 std::string deviceName = "card0";
356 return static_cast<ssize_t>(deviceName.size());
357 });
358
359 PublicSysfsAccess *tempSysfsAccess = new PublicSysfsAccess();
360
361 EXPECT_EQ(ZE_RESULT_SUCCESS, tempSysfsAccess->bindDevice(deviceName));
362 delete tempSysfsAccess;
363 }
364
365 TEST_F(SysmanDeviceFixture, GivenSysfsAccessAndValidDeviceNameWhenCallingUnbindDeviceThenSuccessIsReturned) {
366
367 std::string deviceName = "card0";
368
369 VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int {
370 return 1;
371 });
372
373 VariableBackup<decltype(NEO::SysCalls::sysCallsPwrite)> mockPwrite(&NEO::SysCalls::sysCallsPwrite, [](int fd, const void *buf, size_t count, off_t offset) -> ssize_t {
374 std::string deviceName = "card0";
375 return static_cast<ssize_t>(deviceName.size());
376 });
377
378 PublicSysfsAccess *tempSysfsAccess = new PublicSysfsAccess();
379
380 EXPECT_EQ(ZE_RESULT_SUCCESS, tempSysfsAccess->unbindDevice(deviceName));
381 delete tempSysfsAccess;
382 }
383
384 TEST_F(SysmanDeviceFixture, GivenValidPathnameWhenCallingSysfsAccessGetFileModeThenSuccessIsReturned) {
385 PublicSysfsAccess *tempSysfsAccess = new PublicSysfsAccess();
386
387 char cwd[PATH_MAX];
388 ::mode_t mode;
389 std::string path = getcwd(cwd, PATH_MAX);
390 EXPECT_EQ(ZE_RESULT_SUCCESS, tempSysfsAccess->getFileMode(path, mode));
391 delete tempSysfsAccess;
392 }
393
394 TEST_F(SysmanDeviceFixture, GivenSysfsAccessClassWhenCallingCanWriteWithUserHavingWritePermissionsThenSuccessIsReturned) {
395 PublicSysfsAccess *tempSysfsAccess = new PublicSysfsAccess();
396 tempSysfsAccess->statSyscall = mockStatSuccess;
397 char cwd[PATH_MAX];
398 std::string path = getcwd(cwd, PATH_MAX);
399 EXPECT_EQ(ZE_RESULT_SUCCESS, tempSysfsAccess->canWrite(path));
400 delete tempSysfsAccess;
401 }
402
403 TEST_F(SysmanDeviceFixture, GivenSysfsAccessClassWhenCallingCanReadWithInvalidPathThenErrorIsReturned) {
404 PublicSysfsAccess *tempSysfsAccess = new PublicSysfsAccess();
405 tempSysfsAccess->statSyscall = mockStatFailure;
406 std::string path = "invalidPath";
407 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, tempSysfsAccess->canRead(path));
408 delete tempSysfsAccess;
409 }
410
411 TEST_F(SysmanDeviceFixture, GivenValidPathnameWhenCallingSysfsAccessExistsThenSuccessIsReturned) {
412 VariableBackup<bool> allowFakeDevicePathBackup(&SysCalls::allowFakeDevicePath, true);
413 PublicSysfsAccess *tempSysfsAccess = new PublicSysfsAccess();
414 char cwd[PATH_MAX];
415 std::string path = getcwd(cwd, PATH_MAX);
416 EXPECT_TRUE(tempSysfsAccess->fileExists(path));
417 delete tempSysfsAccess;
418 }
419
420 TEST_F(SysmanDeviceFixture, GivenSysfsAccessClassAndValidDirectoryWhenCallingscanDirEntriesThenSuccessIsReturned) {
421 VariableBackup<decltype(NEO::SysCalls::sysCallsOpendir)> mockOpendir(&NEO::SysCalls::sysCallsOpendir, [](const char *name) -> DIR * {
422 return reinterpret_cast<DIR *>(0xc001);
423 });
424
425 VariableBackup<decltype(NEO::SysCalls::sysCallsReaddir)> mockReaddir(
426 &NEO::SysCalls::sysCallsReaddir, [](DIR * dir) -> struct dirent * {
427 static int callCount = 0;
428 callCount++;
429 if (callCount > 1) {
430 return nullptr;
431 }
432 static struct dirent mockEntry = {0, 0, 0, 0, "mockDir"};
433 return &mockEntry;
434 });
435
436 VariableBackup<decltype(NEO::SysCalls::sysCallsClosedir)> mockClosedir(&NEO::SysCalls::sysCallsClosedir, [](DIR *dir) -> int {
437 return 0;
438 });
439
440 PublicSysfsAccess *tempSysfsAccess = new PublicSysfsAccess();
441 char cwd[PATH_MAX];
442 std::string path = getcwd(cwd, PATH_MAX);
443 std::vector<std::string> dir;
444 EXPECT_EQ(ZE_RESULT_SUCCESS, tempSysfsAccess->scanDirEntries(path, dir));
445 delete tempSysfsAccess;
446 }
447
448 TEST_F(SysmanDeviceFixture, GivenSysfsAccessClassAndConstantStringWhenCallingWriteThenSuccessIsReturned) {
449 const std::string fileName = "mockFile.txt";
450 const std::string str = "Mock String";
451
452 VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int {
453 return 1;
454 });
455
456 VariableBackup<decltype(NEO::SysCalls::sysCallsPwrite)> mockPwrite(&NEO::SysCalls::sysCallsPwrite, [](int fd, const void *buf, size_t count, off_t offset) -> ssize_t {
457 const std::string str = "Mock String";
458 return static_cast<ssize_t>(str.size());
459 });
460
461 PublicSysfsAccess *tempSysfsAccess = new PublicSysfsAccess();
462
463 EXPECT_EQ(ZE_RESULT_SUCCESS, tempSysfsAccess->write(fileName, str));
464 delete tempSysfsAccess;
465 }
466
467 TEST_F(SysmanDeviceFixture, GivenSysfsAccessClassAndConstantIntegerWhenCallingWriteThenSuccessIsReturned) {
468
469 const std::string fileName = "mockFile.txt";
470 const int iVal32 = 0;
471
472 VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int {
473 return 1;
474 });
475
476 VariableBackup<decltype(NEO::SysCalls::sysCallsPwrite)> mockPwrite(&NEO::SysCalls::sysCallsPwrite, [](int fd, const void *buf, size_t count, off_t offset) -> ssize_t {
477 const int iVal32 = 0;
478 std::ostringstream stream;
479 stream << iVal32;
480 return static_cast<ssize_t>(stream.str().size());
481 });
482
483 PublicSysfsAccess *tempSysfsAccess = new PublicSysfsAccess();
484
485 EXPECT_EQ(ZE_RESULT_SUCCESS, tempSysfsAccess->write(fileName, iVal32));
486 delete tempSysfsAccess;
487 }
488
489 TEST_F(SysmanDeviceFixture, GivenSysfsAccessClassAndIntegerWhenCallingReadThenSuccessIsReturned) {
490
491 VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int {
492 return 1;
493 });
494
495 VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
496 std::string value = "123";
497 memcpy(buf, value.data(), value.size());
498 return value.size();
499 });
500
501 PublicSysfsAccess *tempSysfsAccess = new PublicSysfsAccess();
502 const std::string fileName = "mockFile.txt";
503 int iVal32;
504
505 EXPECT_EQ(ZE_RESULT_SUCCESS, tempSysfsAccess->read(fileName, iVal32));
506 delete tempSysfsAccess;
507 }
508
509 TEST_F(SysmanDeviceFixture, GivenValidMockMutexFsAccessWhenCallingReadThenMutexLockCounterMatchesNumberOfReadCalls) {
510 VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int {
511 return 1;
512 });
513
514 VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
515 std::string value = "123";
516 memcpy(buf, value.data(), value.size());
517 return value.size();
518 });
519
520 class MockMutexFsAccess : public L0::FsAccess {
521 public:
522 uint32_t mutexLockCounter = 0;
523 std::unique_lock<std::mutex> obtainMutex() override {
524 mutexLockCounter++;
525 std::unique_lock<std::mutex> mutexLock = L0::FsAccess::obtainMutex();
526 EXPECT_TRUE(mutexLock.owns_lock());
527 return mutexLock;
528 }
529 };
530
531 MockMutexFsAccess *tempFsAccess = new MockMutexFsAccess();
532 std::string fileName = {};
533 uint32_t iVal32;
534 uint32_t testReadCount = 10;
535 for (uint32_t i = 0; i < testReadCount; i++) {
536 fileName = "mockfile" + std::to_string(i) + ".txt";
537 EXPECT_EQ(ZE_RESULT_SUCCESS, tempFsAccess->read(fileName, iVal32));
538 }
539 EXPECT_EQ(tempFsAccess->mutexLockCounter, testReadCount);
540 delete tempFsAccess;
541 }
542
543 TEST_F(SysmanDeviceFixture, GivenSysfsAccessClassAndOpenSysCallFailsWhenCallingReadThenFailureIsReturned) {
544
545 VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int {
546 return -1;
547 });
548
549 VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
550 std::string value = "123";
551 memcpy(buf, value.data(), value.size());
552 return value.size();
553 });
554
555 PublicSysfsAccess *tempSysfsAccess = new PublicSysfsAccess();
556 const std::string fileName = "mockFile.txt";
557 int iVal32;
558
559 errno = ENOENT;
560 EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, tempSysfsAccess->read(fileName, iVal32));
561 delete tempSysfsAccess;
562 }
563
564 TEST_F(SysmanDeviceFixture, GivenSysfsAccessClassAndIntegerWhenCallingReadOnMultipleFilesThenSuccessIsReturned) {
565
566 VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int {
567 return 1;
568 });
569
570 VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
571 std::string value = "123";
572 memcpy(buf, value.data(), value.size());
573 return value.size();
574 });
575
576 PublicSysfsAccess *tempSysfsAccess = new PublicSysfsAccess();
577 std::string fileName = {};
578 int iVal32;
579 for (auto i = 0; i < L0::FdCache::maxSize + 2; i++) {
580 fileName = "mockfile" + std::to_string(i) + ".txt";
581 EXPECT_EQ(ZE_RESULT_SUCCESS, tempSysfsAccess->read(fileName, iVal32));
582 }
583 delete tempSysfsAccess;
584 }
585
586 TEST(FdCacheTest, GivenValidFdCacheWhenCallingGetFdOnSameFileThenVerifyCacheIsUpdatedProperly) {
587
588 class MockFdCache : public FdCache {
589 public:
590 using FdCache::fdMap;
591 };
592
593 VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int {
594 return 1;
595 });
596
597 std::unique_ptr<MockFdCache> pFdCache = std::make_unique<MockFdCache>();
598 std::string fileName = {};
599 for (auto i = 0; i < L0::FdCache::maxSize; i++) {
600 fileName = "mockfile" + std::to_string(i) + ".txt";
601 EXPECT_LE(0, pFdCache->getFd(fileName));
602 }
603
604 fileName = "mockfile0.txt";
605 for (auto i = 0; i < 3; i++) {
606 EXPECT_LE(0, pFdCache->getFd(fileName));
607 }
608
609 for (auto i = 1; i < L0::FdCache::maxSize - 1; i++) {
610 fileName = "mockfile" + std::to_string(i) + ".txt";
611 EXPECT_LE(0, pFdCache->getFd(fileName));
612 }
613
614 // Get Fd after the cache is full.
615 EXPECT_LE(0, pFdCache->getFd("dummy.txt"));
616
617 // Verify Cache have the elements that are accessed more number of times
618 EXPECT_NE(pFdCache->fdMap.end(), pFdCache->fdMap.find("mockfile0.txt"));
619
620 // Verify cache doesn't have an element that is accessed less number of times.
621 EXPECT_EQ(pFdCache->fdMap.end(), pFdCache->fdMap.find("mockfile9.txt"));
622 }
623
624 TEST(FdCacheTest, GivenValidFdCacheWhenClearingCacheThenVerifyProperFdsAreClosedAndCacheIsUpdatedProperly) {
625
626 class MockFdCache : public FdCache {
627 public:
628 using FdCache::fdMap;
629 };
630
631 VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int {
632 return 1;
633 });
634
635 VariableBackup<decltype(NEO::SysCalls::sysCallsClose)> mockClose(&NEO::SysCalls::sysCallsClose, [](int fileDescriptor) -> int {
636 EXPECT_EQ(fileDescriptor, 1);
637 return 0;
638 });
639
640 MockFdCache *pFdCache = new MockFdCache();
641 std::string fileName = {};
642 for (auto i = 0; i < L0::FdCache::maxSize; i++) {
643 fileName = "mockfile" + std::to_string(i) + ".txt";
644 EXPECT_LE(0, pFdCache->getFd(fileName));
645 }
646
647 fileName = "mockfile0.txt";
648 for (auto i = 0; i < 3; i++) {
649 EXPECT_LE(0, pFdCache->getFd(fileName));
650 }
651
652 for (auto i = 1; i < L0::FdCache::maxSize - 1; i++) {
653 fileName = "mockfile" + std::to_string(i) + ".txt";
654 EXPECT_LE(0, pFdCache->getFd(fileName));
655 }
656
657 // Get Fd after the cache is full.
658 EXPECT_LE(0, pFdCache->getFd("dummy.txt"));
659
660 // Verify Cache have the elements that are accessed more number of times
661 EXPECT_NE(pFdCache->fdMap.end(), pFdCache->fdMap.find("mockfile0.txt"));
662
663 // Verify cache doesn't have an element that is accessed less number of times.
664 EXPECT_EQ(pFdCache->fdMap.end(), pFdCache->fdMap.find("mockfile9.txt"));
665
666 delete pFdCache;
667 }
668
669 TEST_F(SysmanDeviceFixture, GivenSysfsAccessClassAndUnsignedIntegerWhenCallingReadThenSuccessIsReturned) {
670
671 VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int {
672 return 1;
673 });
674
675 VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
676 std::string value = "123";
677 memcpy(buf, value.data(), value.size());
678 return value.size();
679 });
680
681 PublicSysfsAccess *tempSysfsAccess = new PublicSysfsAccess();
682 const std::string fileName = "mockFile.txt";
683 uint32_t uVal32;
684
685 EXPECT_EQ(ZE_RESULT_SUCCESS, tempSysfsAccess->read(fileName, uVal32));
686 delete tempSysfsAccess;
687 }
688
689 TEST_F(SysmanDeviceFixture, GivenSysfsAccessClassAndConstantDoubleValueWhenCallingWriteThenSuccessIsReturned) {
690
691 const std::string fileName = "mockFile.txt";
692 const double dVal = 0.0;
693
694 VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int {
695 return 1;
696 });
697
698 VariableBackup<decltype(NEO::SysCalls::sysCallsPwrite)> mockPwrite(&NEO::SysCalls::sysCallsPwrite, [](int fd, const void *buf, size_t count, off_t offset) -> ssize_t {
699 const double dVal = 0.0;
700 std::ostringstream stream;
701 stream << dVal;
702 return static_cast<ssize_t>(stream.str().size());
703 });
704
705 PublicSysfsAccess *tempSysfsAccess = new PublicSysfsAccess();
706
707 EXPECT_EQ(ZE_RESULT_SUCCESS, tempSysfsAccess->write(fileName, dVal));
708 delete tempSysfsAccess;
709 }
710
711 TEST_F(SysmanDeviceFixture, GivenSysfsAccessClassAndDoubleWhenCallingReadThenSuccessIsReturned) {
712
713 VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int {
714 return 1;
715 });
716
717 VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
718 std::string value = "123";
719 memcpy(buf, value.data(), value.size());
720 return value.size();
721 });
722
723 PublicSysfsAccess *tempSysfsAccess = new PublicSysfsAccess();
724 const std::string fileName = "mockFile.txt";
725 double dVal;
726
727 EXPECT_EQ(ZE_RESULT_SUCCESS, tempSysfsAccess->read(fileName, dVal));
728 delete tempSysfsAccess;
729 }
730
731 TEST_F(SysmanDeviceFixture, GivenSysfsAccessClassAndUnsignedLongValueWhenCallingWriteThenSuccessIsReturned) {
732 const std::string fileName = "mockFile.txt";
733 const uint64_t uVal64 = 0;
734
735 VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int {
736 return 1;
737 });
738
739 VariableBackup<decltype(NEO::SysCalls::sysCallsPwrite)> mockPwrite(&NEO::SysCalls::sysCallsPwrite, [](int fd, const void *buf, size_t count, off_t offset) -> ssize_t {
740 const uint64_t uVal64 = 0;
741 std::ostringstream stream;
742 stream << uVal64;
743 return static_cast<ssize_t>(stream.str().size());
744 });
745
746 PublicSysfsAccess *tempSysfsAccess = new PublicSysfsAccess();
747
748 EXPECT_EQ(ZE_RESULT_SUCCESS, tempSysfsAccess->write(fileName, uVal64));
749 delete tempSysfsAccess;
750 }
751
752 TEST_F(SysmanDeviceFixture, GivenSysfsAccessClassAndUnsignedLongWhenCallingReadThenSuccessIsReturned) {
753
754 VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int {
755 return 1;
756 });
757
758 VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
759 std::string value = "123";
760 memcpy(buf, value.data(), value.size());
761 return value.size();
762 });
763
764 PublicSysfsAccess *tempSysfsAccess = new PublicSysfsAccess();
765 const std::string fileName = "mockFile.txt";
766 uint64_t uVal64;
767
768 EXPECT_EQ(ZE_RESULT_SUCCESS, tempSysfsAccess->read(fileName, uVal64));
769 delete tempSysfsAccess;
770 }
771
772 TEST_F(SysmanDeviceFixture, GivenCreateSysfsAccessHandleWhenCallinggetSysfsAccessThenCreatedSysfsAccessHandleHandleWillBeRetrieved) {
773 if (pLinuxSysmanImp->pSysfsAccess != nullptr) {
774 // delete previously allocated pSysfsAccess
775 delete pLinuxSysmanImp->pSysfsAccess;
776 pLinuxSysmanImp->pSysfsAccess = nullptr;
777 }
778 pLinuxSysmanImp->pSysfsAccess = SysfsAccess::create("");
779 EXPECT_EQ(&pLinuxSysmanImp->getSysfsAccess(), pLinuxSysmanImp->pSysfsAccess);
780 }
781
782 TEST_F(SysmanDeviceFixture, GivenValidPidWhenCallingProcfsAccessGetFileDescriptorsThenSuccessIsReturned) {
783 VariableBackup<decltype(NEO::SysCalls::sysCallsOpendir)> mockOpendir(&NEO::SysCalls::sysCallsOpendir, [](const char *name) -> DIR * {
784 return reinterpret_cast<DIR *>(0xc001);
785 });
786
787 VariableBackup<decltype(NEO::SysCalls::sysCallsReaddir)> mockReaddir(
788 &NEO::SysCalls::sysCallsReaddir, [](DIR * dir) -> struct dirent * {
789 static int callCount = 0;
790 if (callCount > 2) {
791 return nullptr;
792 }
793 static struct dirent mockEntry[] = {
794 {0, 0, 0, 0, "mockDir"},
795 {0, 0, 0, 0, "mockDir2"},
796 {0, 0, 0, 0, "mockDir3"},
797 };
798 return &mockEntry[callCount++];
799 });
800
801 VariableBackup<decltype(NEO::SysCalls::sysCallsClosedir)> mockClosedir(&NEO::SysCalls::sysCallsClosedir, [](DIR *dir) -> int {
802 return 0;
803 });
804 auto procfsAccess = pLinuxSysmanImp->getProcfsAccess();
805
806 ::pid_t processID = getpid();
807 std::vector<int> listFiles;
808 EXPECT_EQ(ZE_RESULT_SUCCESS, procfsAccess.getFileDescriptors(processID, listFiles));
809 }
810
811 TEST_F(SysmanDeviceFixture, GivenValidProcfsAccessHandleWhenCallingListProcessesThenSuccessIsReturned) {
812 VariableBackup<decltype(NEO::SysCalls::sysCallsOpendir)> mockOpendir(&NEO::SysCalls::sysCallsOpendir, [](const char *name) -> DIR * {
813 return reinterpret_cast<DIR *>(0xc001);
814 });
815
816 VariableBackup<decltype(NEO::SysCalls::sysCallsReaddir)> mockReaddir(
817 &NEO::SysCalls::sysCallsReaddir, [](DIR * dir) -> struct dirent * {
818 static int callCount = 0;
819 if (callCount > 2) {
820 return nullptr;
821 }
822 static struct dirent mockEntry[] = {
823 {0, 0, 0, 0, "mockDir"},
824 {0, 0, 0, 0, "mockDir2"},
825 {0, 0, 0, 0, "mockDir3"},
826 };
827 return &mockEntry[callCount++];
828 });
829
830 VariableBackup<decltype(NEO::SysCalls::sysCallsClosedir)> mockClosedir(&NEO::SysCalls::sysCallsClosedir, [](DIR *dir) -> int {
831 return 0;
832 });
833
834 auto procfsAccess = pLinuxSysmanImp->getProcfsAccess();
835
836 std::vector<::pid_t> listPid;
837 EXPECT_EQ(ZE_RESULT_SUCCESS, procfsAccess.listProcesses(listPid));
838 }
839
840 TEST_F(SysmanDeviceFixture, GivenValidProcfsAccessHandleAndKillProcessWhenCallingIsAliveThenErrorIsReturned) {
841 auto procfsAccess = pLinuxSysmanImp->getProcfsAccess();
842 int pid = NEO::SysCalls::getProcessId();
843 procfsAccess.kill(pid);
844 EXPECT_FALSE(procfsAccess.isAlive(pid));
845 }
846
847 TEST_F(SysmanDeviceFixture, GivenCreateProcfsAccessHandleWhenCallinggetProcfsAccessThenCreatedProcfsAccessHandleWillBeRetrieved) {
848 if (pLinuxSysmanImp->pProcfsAccess != nullptr) {
849 // delete previously allocated pProcfsAccess
850 delete pLinuxSysmanImp->pProcfsAccess;
851 pLinuxSysmanImp->pProcfsAccess = nullptr;
852 }
853 pLinuxSysmanImp->pProcfsAccess = ProcfsAccess::create();
854 EXPECT_EQ(&pLinuxSysmanImp->getProcfsAccess(), pLinuxSysmanImp->pProcfsAccess);
855 }
856
857 TEST_F(SysmanDeviceFixture, GivenValidPidWhenCallingProcfsAccessIsAliveThenSuccessIsReturned) {
858 VariableBackup<bool> allowFakeDevicePathBackup(&SysCalls::allowFakeDevicePath, true);
859 auto procfsAccess = pLinuxSysmanImp->getProcfsAccess();
860
861 EXPECT_TRUE(procfsAccess.isAlive(getpid()));
862 }
863
864 TEST_F(SysmanDeviceFixture, GivenInvalidPidWhenCallingProcfsAccessIsAliveThenErrorIsReturned) {
865 auto procfsAccess = pLinuxSysmanImp->getProcfsAccess();
866
867 EXPECT_FALSE(procfsAccess.isAlive(reinterpret_cast<::pid_t>(-1)));
868 }
869
870 TEST_F(SysmanDeviceFixture, GivenValidDeviceHandleThenSameHandleIsRetrievedFromOsSpecificCode) {
871 EXPECT_EQ(pLinuxSysmanImp->getDeviceHandle(), device);
872 }
873
874 TEST_F(SysmanDeviceFixture, GivenPmuInterfaceHandleWhenCallinggetPmuInterfaceThenCreatedPmuInterfaceHandleWillBeRetrieved) {
875 if (pLinuxSysmanImp->pPmuInterface != nullptr) {
876 // delete previously allocated pPmuInterface
877 delete pLinuxSysmanImp->pPmuInterface;
878 pLinuxSysmanImp->pPmuInterface = nullptr;
879 }
880 pLinuxSysmanImp->pPmuInterface = PmuInterface::create(pLinuxSysmanImp);
881 EXPECT_EQ(pLinuxSysmanImp->getPmuInterface(), pLinuxSysmanImp->pPmuInterface);
882 }
883
884 TEST_F(SysmanDeviceFixture, GivenValidPciPathWhileGettingCardBusPortThenReturnedPathIs1LevelUpThenTheCurrentPath) {
885 const std::string mockBdf = "0000:00:02.0";
886 const std::string mockRealPath = "/sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0/0000:02:01.0/" + mockBdf;
887 const std::string mockRealPath1LevelUp = "/sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0";
888
889 std::string pciRootPort1 = pLinuxSysmanImp->getPciCardBusDirectoryPath(mockRealPath);
890 EXPECT_EQ(pciRootPort1, mockRealPath1LevelUp);
891
892 std::string pciRootPort2 = pLinuxSysmanImp->getPciCardBusDirectoryPath("device");
893 EXPECT_EQ(pciRootPort2, "device");
894 }
895
896 TEST_F(SysmanDeviceFixture, GivenNullDrmHandleWhenGettingDrmHandleThenValidDrmHandleIsReturned) {
897 pLinuxSysmanImp->releaseLocalDrmHandle();
898 EXPECT_NO_THROW(pLinuxSysmanImp->getDrm());
899 }
900
901 TEST_F(SysmanDeviceFixture, GivenValidDeviceHandleWhenGettingFwUtilInterfaceAndGetPciBdfFailsThenFailureIsReturned) {
902 auto l0Device = static_cast<L0::Device *>(pLinuxSysmanImp->getDeviceHandle());
903
904 l0Device->driverInfo.reset(nullptr);
905 FirmwareUtil *pFwUtilInterfaceOld = pLinuxSysmanImp->pFwUtilInterface;
906 pLinuxSysmanImp->pFwUtilInterface = nullptr;
907
908 EXPECT_EQ(pLinuxSysmanImp->getFwUtilInterface(), nullptr);
909 pLinuxSysmanImp->pFwUtilInterface = pFwUtilInterfaceOld;
910 }
911
912 TEST_F(SysmanDeviceFixture, GivenValidEnumeratedHandlesWhenReleaseIsCalledThenHandleCountZeroIsReturned) {
913 uint32_t count = 0;
914
915 const std::vector<std::string> mockSupportedDiagTypes = {"MOCKSUITE1", "MOCKSUITE2"};
916 std::vector<std::string> mockSupportedFirmwareTypes = {"GSC", "OptionROM", "PSC"};
917
918 FirmwareImp *ptestFirmwareImp = new FirmwareImp(pSysmanDeviceImp->pFirmwareHandleContext->pOsSysman, mockSupportedFirmwareTypes[0]);
919 pSysmanDeviceImp->pFirmwareHandleContext->handleList.push_back(ptestFirmwareImp);
920 count = 0;
921 ze_result_t result = zesDeviceEnumFirmwares(device->toHandle(), &count, nullptr);
922 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
923 EXPECT_EQ(count, 1u);
924
925 count = 0;
926 std::unique_ptr<DiagnosticsImp> ptestDiagnosticsImp = std::make_unique<DiagnosticsImp>(pSysmanDeviceImp->pDiagnosticsHandleContext->pOsSysman, mockSupportedDiagTypes[0]);
927 pSysmanDeviceImp->pDiagnosticsHandleContext->handleList.push_back(std::move(ptestDiagnosticsImp));
928 result = zesDeviceEnumDiagnosticTestSuites(device->toHandle(), &count, nullptr);
929 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
930 EXPECT_EQ(count, 1u);
931
932 count = 0;
933 RasImp *pRas = new RasImp(pSysmanDeviceImp->pRasHandleContext->pOsSysman, ZES_RAS_ERROR_TYPE_CORRECTABLE, device->toHandle());
934 pLinuxSysmanImp->memType = NEO::DeviceBlobConstants::MemoryType::lpddr4;
935 pSysmanDeviceImp->pRasHandleContext->handleList.push_back(pRas);
936 result = zesDeviceEnumRasErrorSets(device->toHandle(), &count, NULL);
937 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
938 EXPECT_EQ(count, 1u);
939
940 pLinuxSysmanImp->releaseSysmanDeviceResources();
941
942 count = 0;
943 result = zesDeviceEnumFirmwares(device->toHandle(), &count, nullptr);
944 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
945 EXPECT_EQ(count, 0u);
946
947 count = 0;
948 result = zesDeviceEnumDiagnosticTestSuites(device->toHandle(), &count, nullptr);
949 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
950 EXPECT_EQ(count, 0u);
951
952 count = 0;
953 result = zesDeviceEnumRasErrorSets(device->toHandle(), &count, NULL);
954 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
955 EXPECT_EQ(count, 0u);
956 }
957
958 TEST_F(SysmanDeviceFixture, GivenDriverEventsUtilAsNullWhenSysmanDriverDestructorIsCalledThenVerifyNoExceptionOccured) {
959 VariableBackup<L0::OsSysmanDriver *> driverBackup(&globalOsSysmanDriver);
960 auto pPublicLinuxSysmanDriverImp = new PublicLinuxSysmanDriverImp();
961 globalOsSysmanDriver = static_cast<L0::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp);
962
963 auto pUdevLib = new UdevLibMock();
964 pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLib;
965
966 delete pPublicLinuxSysmanDriverImp->pLinuxEventsUtil;
967 pPublicLinuxSysmanDriverImp->pLinuxEventsUtil = nullptr;
968 EXPECT_NO_THROW(L0::osSysmanDriverDestructor());
969 }
970
971 TEST_F(SysmanMultiDeviceFixture, GivenValidDeviceHandleHavingSubdevicesWhenValidatingSysmanHandlesForSubdevicesThenSysmanHandleForSubdeviceWillBeSameAsSysmanHandleForDevice) {
972 ze_device_handle_t hSysman = device->toHandle();
973 auto pSysmanDeviceOriginal = device->getSysmanHandle();
974 auto pSysmanDeviceLocal = L0::SysmanDeviceHandleContext::init(hSysman);
975 EXPECT_EQ(pSysmanDeviceLocal, nullptr);
976 device->setSysmanHandle(pSysmanDeviceLocal);
977
978 uint32_t count = 0;
979 EXPECT_EQ(ZE_RESULT_SUCCESS, device->getSubDevices(&count, nullptr));
980 std::vector<ze_device_handle_t> subDeviceHandles(count, nullptr);
981 EXPECT_EQ(ZE_RESULT_SUCCESS, device->getSubDevices(&count, subDeviceHandles.data()));
982 for (auto subDeviceHandle : subDeviceHandles) {
983 L0::Device *subDeviceHandleImp = static_cast<Device *>(Device::fromHandle(subDeviceHandle));
984 EXPECT_EQ(subDeviceHandleImp->getSysmanHandle(), device->getSysmanHandle());
985 }
986 device->setSysmanHandle(pSysmanDeviceOriginal);
987 }
988
989 TEST_F(SysmanMultiDeviceFixture, GivenValidEffectiveUserIdCheckWhetherPermissionsReturnedByIsRootUserAreCorrect) {
990 int euid = geteuid();
991 auto pFsAccess = pLinuxSysmanImp->getFsAccess();
992 if (euid == 0) {
993 EXPECT_EQ(true, pFsAccess.isRootUser());
994 } else {
995 EXPECT_EQ(false, pFsAccess.isRootUser());
996 }
997 }
998
999 TEST_F(SysmanMultiDeviceFixture, GivenSysmanEnvironmentVariableSetWhenCreateL0DeviceThenSysmanHandleCreateIsAttempted) {
1000 driverHandle->enableSysman = true;
1001 // In SetUp of SysmanMultiDeviceFixture, sysman handle for device is already created, so new sysman handle should not be created
1002 device->createSysmanHandle(true);
1003 EXPECT_EQ(device->getSysmanHandle(), pSysmanDevice);
1004
1005 device->createSysmanHandle(false);
1006 EXPECT_EQ(device->getSysmanHandle(), pSysmanDevice);
1007
1008 // delete previously allocated sysman handle and then attempt to create sysman handle again
1009 delete pSysmanDevice;
1010 device->setSysmanHandle(nullptr);
1011 device->createSysmanHandle(true);
1012 EXPECT_EQ(device->getSysmanHandle(), nullptr);
1013
1014 device->createSysmanHandle(false);
1015 EXPECT_EQ(device->getSysmanHandle(), nullptr);
1016 }
1017
1018 using SysmanUnknownDriverModelTest = Test<DeviceFixture>;
1019 TEST_F(SysmanUnknownDriverModelTest, GivenDriverModelTypeIsNotDrmWhenExecutingSysmanOnLinuxThenErrorIsReturned) {
1020 neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[device->getRootDeviceIndex()]->osInterface = std::make_unique<NEO::OSInterface>();
1021 auto &osInterface = *device->getOsInterface();
1022 osInterface.setDriverModel(std::make_unique<NEO::MockDriverModel>());
1023 auto pSysmanDeviceImp = std::make_unique<SysmanDeviceImp>(device->toHandle());
1024 auto pLinuxSysmanImp = static_cast<PublicLinuxSysmanImp *>(pSysmanDeviceImp->pOsSysman);
1025 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pLinuxSysmanImp->init());
1026 }
1027
1028 class MockOsSysman : public L0::OsSysman {
1029 L0::SysmanDeviceImp *pParentSysmanDeviceImp;
1030
1031 public:
1032 ze_bool_t mockDriverVersionSupported = false;
1033 ze_result_t mockInitResult = ZE_RESULT_SUCCESS;
1034 MockOsSysman(L0::SysmanDeviceImp *pParentSysmanDeviceImp) {
1035 this->pParentSysmanDeviceImp = pParentSysmanDeviceImp;
1036 }
1037 ze_result_t init() override { return mockInitResult; }
1038 ze_bool_t isDriverModelSupported() override { return mockDriverVersionSupported; }
1039 std::vector<ze_device_handle_t> &getDeviceHandles() override {
1040 return pParentSysmanDeviceImp->deviceHandles;
1041 }
1042 ze_device_handle_t getCoreDeviceHandle() override {
1043 return pParentSysmanDeviceImp->hCoreDevice;
1044 }
1045 static MockOsSysman *create(L0::SysmanDeviceImp *pParentSysmanDeviceImp) {
1046 MockOsSysman *pTestSysmanImp = new MockOsSysman(pParentSysmanDeviceImp);
1047 return static_cast<MockOsSysman *>(pTestSysmanImp);
1048 }
1049 };
1050
1051 TEST_F(SysmanDeviceFixture, GivenValidDeviceHandleWhenisDriverModelSupportedReturnsTrueThenSuccessIsReturned) {
1052 auto osSysmanOriginal = pSysmanDeviceImp->pOsSysman;
1053 MockOsSysman *testOsSysman = MockOsSysman::create(pSysmanDeviceImp);
1054 testOsSysman->mockInitResult = ZE_RESULT_SUCCESS;
1055 testOsSysman->mockDriverVersionSupported = true;
1056 pSysmanDeviceImp->pOsSysman = testOsSysman;
1057 EXPECT_EQ(ZE_RESULT_SUCCESS, pSysmanDeviceImp->init());
1058 pSysmanDeviceImp->pOsSysman = osSysmanOriginal;
1059 delete testOsSysman;
1060 }
1061
1062 TEST_F(SysmanDeviceFixture, GivenValidDeviceHandleWhenisDriverModelSupportedReturnsFalseThenUnSupportedIsReturned) {
1063 auto osSysmanOriginal = pSysmanDeviceImp->pOsSysman;
1064 MockOsSysman *testOsSysman = MockOsSysman::create(pSysmanDeviceImp);
1065 testOsSysman->mockInitResult = ZE_RESULT_SUCCESS;
1066 testOsSysman->mockDriverVersionSupported = false;
1067 pSysmanDeviceImp->pOsSysman = testOsSysman;
1068 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pSysmanDeviceImp->init());
1069 pSysmanDeviceImp->pOsSysman = osSysmanOriginal;
1070 delete testOsSysman;
1071 }
1072
1073 TEST_F(SysmanDeviceFixture, GivenValidSysmanDeviceImpWhenOsSysmanInitFailsThenUnSupportedIsReturned) {
1074 auto osSysmanOriginal = pSysmanDeviceImp->pOsSysman;
1075 MockOsSysman *testOsSysman = MockOsSysman::create(pSysmanDeviceImp);
1076 testOsSysman->mockInitResult = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
1077 pSysmanDeviceImp->pOsSysman = testOsSysman;
1078 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pSysmanDeviceImp->init());
1079 pSysmanDeviceImp->pOsSysman = osSysmanOriginal;
1080 delete testOsSysman;
1081 }
1082
1083 TEST_F(SysmanDeviceFixture, GivenValidLinuxSysmanImpWhenDrmVersionIsXeThenFalseIsReturned) {
1084 VariableBackup<decltype(SysCalls::sysCallsIoctl)> mockIoctl(&SysCalls::sysCallsIoctl, [](int fileDescriptor, unsigned long int request, void *arg) -> int {
1085 const char *drmVersion = "xe";
1086 if (request == DRM_IOCTL_VERSION) {
1087 auto pVersion = static_cast<DrmVersion *>(arg);
1088 memcpy_s(pVersion->name, pVersion->nameLen, drmVersion, std::min(pVersion->nameLen, strlen(drmVersion) + 1));
1089 }
1090 return 0;
1091 });
1092 EXPECT_EQ(false, pLinuxSysmanImp->isDriverModelSupported());
1093 }
1094
1095 TEST_F(SysmanDeviceFixture, GivenValidLinuxSysmanImpWhenDrmVersionIsi915ThenTrueIsReturned) {
1096 VariableBackup<decltype(SysCalls::sysCallsIoctl)> mockIoctl(&SysCalls::sysCallsIoctl, [](int fileDescriptor, unsigned long int request, void *arg) -> int {
1097 const char *drmVersion = "i915";
1098 if (request == DRM_IOCTL_VERSION) {
1099 auto pVersion = static_cast<DrmVersion *>(arg);
1100 memcpy_s(pVersion->name, pVersion->nameLen, drmVersion, std::min(pVersion->nameLen, strlen(drmVersion) + 1));
1101 }
1102 return 0;
1103 });
1104 EXPECT_EQ(true, pLinuxSysmanImp->isDriverModelSupported());
1105 }
1106
1107 TEST_F(SysmanDeviceFixture, GivenValidLinuxSysmanImpWhenCallingInitDeviceAfterReleasingDeviceResourcesThenSuccessIsReturned) {
1108 pLinuxSysmanImp->releaseDeviceResources();
1109 EXPECT_EQ(ZE_RESULT_SUCCESS, pLinuxSysmanImp->initDevice());
1110 }
1111
1112 } // namespace ult
1113 } // namespace L0