Prozess aktualisiert nun auf Anforderung die Storage-Device-Infos.

src/main.cpp

@@ -65,7 +65,7 @@ static const char *g_pszStateNames[] =
 
 /////////////////////////////////////////////////////////////////////////////
 
-static void _ProcessCtrlMessages(HAPPCTRL hAC, HAPPINFO hAI, bool &bStateTransition)
+static void _ProcessCtrlMessages(HAPPCTRL hAC, HAPPINFO hAI, bool &bStateTransition, bool &bUpdateStgDevInfo)
 {
     ctrlmsg_t nCtrlMsg;
 
@@ -96,6 +96,9 @@ static void _ProcessCtrlMessages(HAPPCTRL hAC, HAPPINFO hAI, bool &bStateTransit
 				TRACE("%-8s: State: %s\n", "Me", g_pszStateNames[GIAS_Running]);
 			}
 			break;
+		case GFA_APPCTRL_CTRLMSG_SYSINFO_UPDATE_STGDEV:
+			bUpdateStgDevInfo = true;
+			break;
 		default:
 			break;
 		}
@@ -139,7 +142,7 @@ int main(int argc, char *argv[])
 	CSpiInfo spiInfo;
 	bool bOsIsHypervised = stgDevInfo.IsSystemHypervised();
 	bool bTargetHasTiva = spiInfo.TargetHasTiva();
-	bool bStateTransition;
+	bool bStateTransition, bUpdateStgDevInfo;
 
 	/////////////////////////////////////////////////////////////////////////
 	// parse command line options
@@ -246,6 +249,7 @@ int main(int argc, char *argv[])
 	while(g_fRun)
 	{
 		bStateTransition = false;
+		bUpdateStgDevInfo = false;
 
 		/////////////////////////////////////////////////////////////////////
 		// trigger cycle timer
@@ -257,7 +261,7 @@ int main(int argc, char *argv[])
 
 		if((hAI = ::GfaIpcAppCtrlInfoUpdate(hAC, wCur)))
 		{
-			_ProcessCtrlMessages(hAC, hAI, bStateTransition);
+			_ProcessCtrlMessages(hAC, hAI, bStateTransition, bUpdateStgDevInfo);
 		}
 
 		/////////////////////////////////////////////////////////////////////
@@ -288,6 +292,12 @@ int main(int argc, char *argv[])
 						spiInfo.Signal(CSpiInfo::S_Resume);
 				}
 			}
+			
+			if(bUpdateStgDevInfo)
+			{
+				if(!bOsIsHypervised)
+					stgDevInfo.Signal(CStgDevInfo::S_Update);
+			}
 
 			if(!g_fPause)
 			{

src/stgdevinfo.cpp

@@ -393,6 +393,7 @@ static bool _ProcessMounts(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, MountMap &mm)
 		{
 			bool bMountedOld = !!*part.szMntPoint;
 			bool bMountedNew = _LookupMountPoint(mm, part.szDevNode, szMntPoint, sizeof(szMntPoint));
+			bool bIsRootDevice = CStgDevInfo::IsRootDevice(part.szDevNode);
 
 			if(!bMountedOld && bMountedNew)
 			{
@@ -404,6 +405,8 @@ static bool _ProcessMounts(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, MountMap &mm)
 			else if(bMountedOld && !bMountedNew)
 			{
 				memset(part.szMntPoint, 0, sizeof(part.szMntPoint));
+				if(bIsRootDevice)
+					part.szMntPoint[0] = '/';
 				_UpdatePartitionFsInfo(mm, part);
 				_SetPartitionChange(sdm, i);
 				bChange = true;
@@ -650,6 +653,48 @@ static void _ProcessPartition(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, MountMap &mm,
 	}
 }
 
+static void _SortStorageDeviceMap(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm)
+{
+	qsort(sdm.disks, GFA_APPCTRL_MAX_DISKS, sizeof(GFA_SYSINFO_DISK), [](const void *p1, const void *p2){
+		const GFA_SYSINFO_DISK *pDisk1 = (const GFA_SYSINFO_DISK*)p1;
+		const GFA_SYSINFO_DISK *pDisk2 = (const GFA_SYSINFO_DISK*)p2;
+		if(pDisk1->valid && !pDisk2->valid)
+			return -1;
+		else if(!pDisk1->valid && pDisk2->valid)
+			return 1;
+		else if(!pDisk1->valid && !pDisk2->valid)
+			return 0;
+		else if(pDisk1->internal && !pDisk2->internal)
+			return -1;
+		else if(!pDisk1->internal && pDisk2->internal)
+			return 1;
+		else
+			return strcmp(pDisk1->szDevNode, pDisk2->szDevNode);
+	});
+
+	for(int i = 0; i < GFA_APPCTRL_MAX_DISKS; ++i)
+	{
+		GFA_SYSINFO_DISK &disk = sdm.disks[i];
+		if(disk.valid)
+		{
+			for(int j = 0; j < (int)disk.nPartCount; ++j)
+			{
+				GFA_SYSINFO_PARTITION &part = sdm.parts[disk.aPartIdx[j]];
+				part.nDiskIdx = i;
+			}
+			
+			qsort_r(disk.aPartIdx, disk.nPartCount, sizeof(int), [](const void *p1, const void *p2, void *psdm){
+				const int n1 = *((const int*)p1);
+				const int n2 = *((const int*)p2);
+				GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm = *((GFA_SYSINFO_STORAGE_DEVICE_MAP*)psdm);
+				const GFA_SYSINFO_PARTITION &pa1 = sdm.parts[n1];
+				const GFA_SYSINFO_PARTITION &pa2 = sdm.parts[n2];
+				return strcmp(pa1.szDevNode, pa2.szDevNode);
+			}, &sdm);
+		}
+	}
+}
+
 static void _EnumStorageDevices(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, MountMap &mm, struct udev *pUdev)
 {
 	struct udev_enumerate *pEnum = ::udev_enumerate_new(pUdev);
@@ -670,6 +715,7 @@ static void _EnumStorageDevices(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, MountMap &m
 	}
 
 	::udev_enumerate_unref(pEnum);
+	_SortStorageDeviceMap(sdm);
 }
 
 /////////////////////////////////////////////////////////////////////////////
@@ -678,7 +724,7 @@ static void _EnumStorageDevices(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, MountMap &m
 
 std::string CStgDevInfo::m_strRootDev;
 
-CStgDevInfo::CStgDevInfo(void) : m_bPaused(false), m_bStateTransition(false)
+CStgDevInfo::CStgDevInfo(void) : m_bPaused(false), m_bStateTransition(false), m_bUpdateRequest(false), m_nUpdateCookie(0)
 {
 	m_bOsIsHypervised = ::GfAIpcSystemIsHypervised();
 	if(m_strRootDev.empty())
@@ -703,6 +749,13 @@ bool CStgDevInfo::IsRootDevice(const char *pszDevice)
 
 /////////////////////////////////////////////////////////////////////////////
 
+void CStgDevInfo::UpdateCookie(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm)
+{
+	sdm.nUpdateCookie = m_nUpdateCookie++;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+
 void* CStgDevInfo::ThreadRoutine(void *pParam)
 {
 	LPEXEC_PARAMS pep = (LPEXEC_PARAMS)pParam;
@@ -758,7 +811,9 @@ void* CStgDevInfo::ThreadRoutine(void *pParam)
 			pfd[1].revents = 0;
 
 			bRun = true;
-			::GfaIpcAppCtrlUpdateStorageDeviceMap(pep->hAC, sdm);
+			_SortStorageDeviceMap(sdm);
+			UpdateCookie(sdm);
+			::GfaIpcAppCtrlUpdateStorageDeviceMap(pep->hAC, sdm, false, true);
 			sleep(1);
 		}
 		while(false);
@@ -793,19 +848,24 @@ void* CStgDevInfo::ThreadRoutine(void *pParam)
 						}
 					}
 
-					if(_DeviceMapChanged(sdm) || m_bStateTransition)
+					if(_DeviceMapChanged(sdm) || m_bStateTransition || m_bUpdateRequest)
 					{
-						if(m_bStateTransition)
+						if(m_bStateTransition || m_bUpdateRequest)
 						{
 							_UpdateMountMap(mm);
 							memset(&sdm, 0, sizeof(sdm));
 							_EnumStorageDevices(sdm, mm, pUdev);
 						}
-						::GfaIpcAppCtrlUpdateStorageDeviceMap(pep->hAC, sdm);
+						else
+							_SortStorageDeviceMap(sdm);
+
+						UpdateCookie(sdm);
+						::GfaIpcAppCtrlUpdateStorageDeviceMap(pep->hAC, sdm, false, true /*m_bUpdateRequest*/);
 					}
 				}
 				
 				m_bStateTransition = false;
+				m_bUpdateRequest = false;
 			}
 			else if(!nRet) // signal received
 			{
@@ -816,9 +876,11 @@ void* CStgDevInfo::ThreadRoutine(void *pParam)
 				case S_Init:
 					break;
 				case S_Update:
+					m_bUpdateRequest = true;
 					break;
 				case S_Pause:
 					memset(&sdm, 0, sizeof(sdm));
+					UpdateCookie(sdm);
 					::GfaIpcAppCtrlUpdateStorageDeviceMap(pep->hAC, sdm, true);
 					m_bStateTransition = !m_bPaused;
 					m_bPaused = true;

src/stgdevinfo.h

@@ -38,10 +38,15 @@ public:
 protected:
 	virtual void* ThreadRoutine(void *pParam);
 
+private:
+	void UpdateCookie(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm);
+
 private:
 	bool m_bPaused;
 	bool m_bStateTransition;
+	bool m_bUpdateRequest;
 	bool m_bOsIsHypervised;
+	unsigned int m_nUpdateCookie;
 	static std::string m_strRootDev;
 };