fix: Fix sysman abort on destruction

Invoking close on invalid fd result in undesired behaviour.
Pass proper file descriptor for close to avoid unnecessary
aborts during destruction.

Related-To: GSD-6816

Signed-off-by: Bellekallu Rajkiran <bellekallu.rajkiran@intel.com>

Author: bellekal

level_zero/sysman/source/linux/sysman_fs_access.cpp

@@ -67,7 +67,7 @@ int FdCache::getFd(std::string file) {
 
 FdCache::~FdCache() {
     for (auto it = fdMap.begin(); it != fdMap.end(); ++it) {
-        NEO::SysCalls::close(it->second.second);
+        NEO::SysCalls::close(it->second.first);
     }
     fdMap.clear();
 }

level_zero/sysman/source/linux/sysman_fs_access.h

@@ -37,6 +37,7 @@ class FdCache {
     int getFd(std::string file);
 
   protected:
+    // Map of File name to pair of file descriptor and reference count to file.
     std::map<std::string, std::pair<int, uint32_t>> fdMap = {};
 
   private:

level_zero/sysman/source/shared/linux/sysman_fs_access_interface.cpp

@@ -64,7 +64,7 @@ int FdCacheInterface::getFd(std::string file) {
 
 FdCacheInterface::~FdCacheInterface() {
     for (auto it = fdMap.begin(); it != fdMap.end(); ++it) {
-        NEO::SysCalls::close(it->second.second);
+        NEO::SysCalls::close(it->second.first);
     }
     fdMap.clear();
 }

level_zero/sysman/source/shared/linux/sysman_fs_access_interface.h

@@ -27,6 +27,7 @@ class FdCacheInterface {
     int getFd(std::string file);
 
   protected:
+    // Map of File name to pair of file descriptor and reference count to file.
     std::map<std::string, std::pair<int, uint32_t>> fdMap = {};
 
   private:

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

@@ -250,13 +250,58 @@ TEST(FdCacheTest, GivenValidFdCacheWhenCallingGetFdOnSameFileThenVerifyCacheIsUp
     // Get Fd after the cache is full.
     EXPECT_LE(0, pFdCache->getFd("dummy.txt"));
 
-    // Verify Cache have the elemets that are accessed more number of times
+    // Verify Cache have the elements that are accessed more number of times
     EXPECT_NE(pFdCache->fdMap.end(), pFdCache->fdMap.find("mockfile0.txt"));
 
     // Verify cache doesn't have an element that is accessed less number of times.
     EXPECT_EQ(pFdCache->fdMap.end(), pFdCache->fdMap.find("mockfile9.txt"));
 }
 
+TEST(FdCacheTest, GivenValidFdCacheWhenClearingCacheThenVerifyProperFdsAreClosedAndCacheIsUpdatedProperly) {
+
+    class MockFdCache : public FdCache {
+      public:
+        using FdCache::fdMap;
+    };
+
+    VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int {
+        return 1;
+    });
+
+    VariableBackup<decltype(NEO::SysCalls::sysCallsClose)> mockClose(&NEO::SysCalls::sysCallsClose, [](int fileDescriptor) -> int {
+        EXPECT_EQ(fileDescriptor, 1);
+        return 0;
+    });
+
+    MockFdCache *pFdCache = new MockFdCache();
+    std::string fileName = {};
+    for (auto i = 0; i < L0::Sysman::FdCache::maxSize; i++) {
+        fileName = "mockfile" + std::to_string(i) + ".txt";
+        EXPECT_LE(0, pFdCache->getFd(fileName));
+    }
+
+    fileName = "mockfile0.txt";
+    for (auto i = 0; i < 3; i++) {
+        EXPECT_LE(0, pFdCache->getFd(fileName));
+    }
+
+    for (auto i = 1; i < L0::Sysman::FdCache::maxSize - 1; i++) {
+        fileName = "mockfile" + std::to_string(i) + ".txt";
+        EXPECT_LE(0, pFdCache->getFd(fileName));
+    }
+
+    // Get Fd after the cache is full.
+    EXPECT_LE(0, pFdCache->getFd("dummy.txt"));
+
+    // Verify Cache have the elements that are accessed more number of times
+    EXPECT_NE(pFdCache->fdMap.end(), pFdCache->fdMap.find("mockfile0.txt"));
+
+    // Verify cache doesn't have an element that is accessed less number of times.
+    EXPECT_EQ(pFdCache->fdMap.end(), pFdCache->fdMap.find("mockfile9.txt"));
+
+    delete pFdCache;
+}
+
 TEST_F(SysmanDeviceFixture, GivenSysfsAccessClassAndOpenSysCallFailsWhenCallingReadThenFailureIsReturned) {
 
     VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int {

level_zero/tools/source/sysman/linux/fs_access.cpp

@@ -65,7 +65,7 @@ int FdCache::getFd(std::string file) {
 
 FdCache::~FdCache() {
     for (auto it = fdMap.begin(); it != fdMap.end(); ++it) {
-        NEO::SysCalls::close(it->second.second);
+        NEO::SysCalls::close(it->second.first);
     }
     fdMap.clear();
 }

level_zero/tools/source/sysman/linux/fs_access.h

@@ -37,6 +37,7 @@ class FdCache {
     int getFd(std::string file);
 
   protected:
+    // Map of File name to pair of file descriptor and reference count to file.
     std::map<std::string, std::pair<int, uint32_t>> fdMap = {};
 
   private:

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

@@ -488,13 +488,58 @@ TEST(FdCacheTest, GivenValidFdCacheWhenCallingGetFdOnSameFileThenVerifyCacheIsUp
     // Get Fd after the cache is full.
     EXPECT_LE(0, pFdCache->getFd("dummy.txt"));
 
-    // Verify Cache have the elemets that are accessed more number of times
+    // Verify Cache have the elements that are accessed more number of times
     EXPECT_NE(pFdCache->fdMap.end(), pFdCache->fdMap.find("mockfile0.txt"));
 
     // Verify cache doesn't have an element that is accessed less number of times.
     EXPECT_EQ(pFdCache->fdMap.end(), pFdCache->fdMap.find("mockfile9.txt"));
 }
 
+TEST(FdCacheTest, GivenValidFdCacheWhenClearingCacheThenVerifyProperFdsAreClosedAndCacheIsUpdatedProperly) {
+
+    class MockFdCache : public FdCache {
+      public:
+        using FdCache::fdMap;
+    };
+
+    VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int {
+        return 1;
+    });
+
+    VariableBackup<decltype(NEO::SysCalls::sysCallsClose)> mockClose(&NEO::SysCalls::sysCallsClose, [](int fileDescriptor) -> int {
+        EXPECT_EQ(fileDescriptor, 1);
+        return 0;
+    });
+
+    MockFdCache *pFdCache = new MockFdCache();
+    std::string fileName = {};
+    for (auto i = 0; i < L0::FdCache::maxSize; i++) {
+        fileName = "mockfile" + std::to_string(i) + ".txt";
+        EXPECT_LE(0, pFdCache->getFd(fileName));
+    }
+
+    fileName = "mockfile0.txt";
+    for (auto i = 0; i < 3; i++) {
+        EXPECT_LE(0, pFdCache->getFd(fileName));
+    }
+
+    for (auto i = 1; i < L0::FdCache::maxSize - 1; i++) {
+        fileName = "mockfile" + std::to_string(i) + ".txt";
+        EXPECT_LE(0, pFdCache->getFd(fileName));
+    }
+
+    // Get Fd after the cache is full.
+    EXPECT_LE(0, pFdCache->getFd("dummy.txt"));
+
+    // Verify Cache have the elements that are accessed more number of times
+    EXPECT_NE(pFdCache->fdMap.end(), pFdCache->fdMap.find("mockfile0.txt"));
+
+    // Verify cache doesn't have an element that is accessed less number of times.
+    EXPECT_EQ(pFdCache->fdMap.end(), pFdCache->fdMap.find("mockfile9.txt"));
+
+    delete pFdCache;
+}
+
 TEST_F(SysmanDeviceFixture, GivenSysfsAccessClassAndUnsignedIntegerWhenCallingReadThenSuccessIsReturned) {
 
     VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int {

shared/test/common/os_interface/linux/sys_calls_linux_ult.h

@@ -47,6 +47,7 @@ extern DIR *(*sysCallsOpendir)(const char *name);
 extern struct dirent *(*sysCallsReaddir)(DIR *dir);
 extern int (*sysCallsClosedir)(DIR *dir);
 extern int (*sysCallsGetDevicePath)(int deviceFd, char *buf, size_t &bufSize);
+extern int (*sysCallsClose)(int fileDescriptor);
 
 extern int flockRetVal;
 extern int openFuncRetVal;