|
@@ -4,6 +4,7 @@
|
|
#include <string.h>
|
|
#include <string.h>
|
|
#include <string>
|
|
#include <string>
|
|
#include <vector>
|
|
#include <vector>
|
|
|
|
+//#include <regex>
|
|
#include <map>
|
|
#include <map>
|
|
#include <ext/stdio_filebuf.h>
|
|
#include <ext/stdio_filebuf.h>
|
|
#include <iostream>
|
|
#include <iostream>
|
|
@@ -17,9 +18,8 @@
|
|
#include <limits.h>
|
|
#include <limits.h>
|
|
#include <libudev.h>
|
|
#include <libudev.h>
|
|
#include <poll.h>
|
|
#include <poll.h>
|
|
-//#include <usb.h>
|
|
|
|
|
|
+#include <errno.h>
|
|
#include <gfa/gfasitarautils.h>
|
|
#include <gfa/gfasitarautils.h>
|
|
-//#include <gfa/gfaipc.h>
|
|
|
|
#include "../../src/gfaipc.h"
|
|
#include "../../src/gfaipc.h"
|
|
#include "../../src/ipcpriv.h"
|
|
#include "../../src/ipcpriv.h"
|
|
|
|
|
|
@@ -34,14 +34,22 @@
|
|
#define UNUSED(v) (void)v
|
|
#define UNUSED(v) (void)v
|
|
#define _countof(a) (sizeof(a) / sizeof(*a))
|
|
#define _countof(a) (sizeof(a) / sizeof(*a))
|
|
|
|
|
|
|
|
+/////////////////////////////////////////////////////////////////////////////
|
|
|
|
+
|
|
|
|
+#define _BYTE_SIZE_KIB (1ULL << 10) // Kibibyte
|
|
|
|
+#define _BYTE_SIZE_MIB (1ULL << 20) // Mebibyte
|
|
|
|
+#define _BYTE_SIZE_GIB (1ULL << 30) // Gibibyte
|
|
|
|
+#define _BYTE_SIZE_TIB (1ULL << 40) // Tebibyte
|
|
|
|
+#define _BYTE_SIZE_PIB (1ULL << 50) // Pebibyte
|
|
|
|
+#define _BYTE_SIZE_EIB (1ULL << 60) // Exbibyte
|
|
|
|
+
|
|
#define _APPID GFA_APPCTRL_APPID_SYSINFO
|
|
#define _APPID GFA_APPCTRL_APPID_SYSINFO
|
|
#define _APPNAME "SysInfo"
|
|
#define _APPNAME "SysInfo"
|
|
#define _CYCLE_INTV 500
|
|
#define _CYCLE_INTV 500
|
|
|
|
|
|
#define _STR_EQUALS(s, t) (!!s && !strcmp(s, t))
|
|
#define _STR_EQUALS(s, t) (!!s && !strcmp(s, t))
|
|
-#define _NUM_TO_BIT(i) (0x01 << (i))
|
|
|
|
-#define _MOUNTS_FILE "/proc/mounts"
|
|
|
|
|
|
|
|
|
|
+#define _MOUNTS_FILE "/proc/mounts"
|
|
#define _INTERNAL_EMMC_DISK "mmcblk1"
|
|
#define _INTERNAL_EMMC_DISK "mmcblk1"
|
|
#define _INTERNAL_EMMC_PART1 "mmcblk1p1"
|
|
#define _INTERNAL_EMMC_PART1 "mmcblk1p1"
|
|
#define _INTERNAL_EMMC_PART2 "mmcblk1p2"
|
|
#define _INTERNAL_EMMC_PART2 "mmcblk1p2"
|
|
@@ -52,21 +60,35 @@ typedef std::map<std::string, std::string> MountMap;
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
-static long long _NumberFromString(const char *pszString, int base = 10, bool *pbErr = NULL);
|
|
|
|
-static const char* _ReadDevPropertyValue(struct udev_device* dev, const char *pszKey, char *pszValue, size_t nCChValue, bool bTruncate = false);
|
|
|
|
-static long long _ReadDevPropertyValue(struct udev_device* dev, const char *pszKey, int base = 10, bool *pbErr = NULL);
|
|
|
|
|
|
+static volatile bool g_fRun = false;
|
|
|
|
+static volatile bool g_fPause = false;
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
-// console=ttyO0,115200 root=/dev/mmcblk0p2 rw rootwait vram=50M cma=50M
|
|
|
|
|
|
+static const char *g_pszStateNames[] =
|
|
|
|
+{
|
|
|
|
+ "Not running",
|
|
|
|
+ "Initializing",
|
|
|
|
+ "Running",
|
|
|
|
+ "Paused",
|
|
|
|
+ "Hanging",
|
|
|
|
+ "Terminating",
|
|
|
|
+ "Invalid"
|
|
|
|
+};
|
|
|
|
+
|
|
|
|
+/////////////////////////////////////////////////////////////////////////////
|
|
|
|
+
|
|
|
|
+static long long _NumberFromString(const char *pszString, int base = 10, bool *pbErr = NULL);
|
|
|
|
+static const char* _ReadDevPropertyValue(struct udev_device* dev, const char *pszKey, char *pszValue, size_t nCChValue, bool bTruncate = false);
|
|
|
|
+static long long _ReadDevPropertyValue(struct udev_device* dev, const char *pszKey, int base = 10, bool *pbErr = NULL);
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
-ssize_t _LookupPartition(const GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, const char *pszDevNode)
|
|
|
|
|
|
+static int _LookupPartition(const GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, const char *pszDevNode)
|
|
{
|
|
{
|
|
- ssize_t nIndex = -1;
|
|
|
|
|
|
+ int nIndex = -1;
|
|
|
|
|
|
if(pszDevNode && *pszDevNode)
|
|
if(pszDevNode && *pszDevNode)
|
|
{
|
|
{
|
|
@@ -83,9 +105,9 @@ ssize_t _LookupPartition(const GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, const char *
|
|
return nIndex;
|
|
return nIndex;
|
|
}
|
|
}
|
|
|
|
|
|
-ssize_t _AddPartition(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, const GFA_SYSINFO_PARTITION &part, bool &bChange)
|
|
|
|
|
|
+static int _AddPartition(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, const GFA_SYSINFO_PARTITION &part, bool &bChange)
|
|
{
|
|
{
|
|
- ssize_t nIndex = -1;
|
|
|
|
|
|
+ int nIndex = -1;
|
|
bChange = false;
|
|
bChange = false;
|
|
|
|
|
|
if((nIndex = _LookupPartition(sdm, part.szDevNode)) >= 0)
|
|
if((nIndex = _LookupPartition(sdm, part.szDevNode)) >= 0)
|
|
@@ -106,71 +128,79 @@ ssize_t _AddPartition(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, const GFA_SYSINFO_PAR
|
|
return nIndex;
|
|
return nIndex;
|
|
}
|
|
}
|
|
|
|
|
|
-ssize_t _RemovePartition(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, ssize_t nIndex, bool &bChange)
|
|
|
|
|
|
+static int _RemovePartition(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, int nIndex, bool &bChange)
|
|
{
|
|
{
|
|
bChange = false;
|
|
bChange = false;
|
|
- if(nIndex >= 0 && nIndex < (ssize_t)_countof(sdm.parts))
|
|
|
|
|
|
+
|
|
|
|
+ if(nIndex >= 0 && nIndex < (int)_countof(sdm.parts))
|
|
{
|
|
{
|
|
bChange = sdm.parts[nIndex].valid;
|
|
bChange = sdm.parts[nIndex].valid;
|
|
sdm.parts[nIndex].valid = false;
|
|
sdm.parts[nIndex].valid = false;
|
|
}
|
|
}
|
|
|
|
+
|
|
return nIndex;
|
|
return nIndex;
|
|
}
|
|
}
|
|
|
|
|
|
-ssize_t _RemovePartition(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, const char *pszDevNode, bool &bChange)
|
|
|
|
|
|
+#if 0
|
|
|
|
+static int _RemovePartition(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, const char *pszDevNode, bool &bChange)
|
|
{
|
|
{
|
|
- ssize_t nIndex = _LookupPartition(sdm, pszDevNode);
|
|
|
|
|
|
+ int nIndex = _LookupPartition(sdm, pszDevNode);
|
|
return _RemovePartition(sdm, nIndex, bChange);
|
|
return _RemovePartition(sdm, nIndex, bChange);
|
|
}
|
|
}
|
|
|
|
+#endif
|
|
|
|
|
|
-bool _PartitionSetDisk(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, ssize_t nPartIdx, ssize_t nDiskIdx, bool &bChange)
|
|
|
|
|
|
+static bool _PartitionSetDisk(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, int nPartIdx, int nDiskIdx, bool &bChange)
|
|
{
|
|
{
|
|
bChange = false;
|
|
bChange = false;
|
|
- if( (nPartIdx >= 0) && (nPartIdx < (ssize_t)_countof(sdm.parts)) &&
|
|
|
|
- (nDiskIdx >= 0) && (nDiskIdx < (ssize_t)_countof(sdm.disks)))
|
|
|
|
|
|
+
|
|
|
|
+ if( (nPartIdx >= 0) && (nPartIdx < (int)_countof(sdm.parts)) &&
|
|
|
|
+ (nDiskIdx >= 0) && (nDiskIdx < (int)_countof(sdm.disks)))
|
|
{
|
|
{
|
|
if(sdm.parts[nPartIdx].nDiskIdx != nDiskIdx)
|
|
if(sdm.parts[nPartIdx].nDiskIdx != nDiskIdx)
|
|
{
|
|
{
|
|
sdm.parts[nPartIdx].nDiskIdx = nDiskIdx;
|
|
sdm.parts[nPartIdx].nDiskIdx = nDiskIdx;
|
|
bChange = true;
|
|
bChange = true;
|
|
}
|
|
}
|
|
|
|
+
|
|
return true;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
+
|
|
return false;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
-ssize_t _PartitionGetDisk(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, ssize_t nPartIdx)
|
|
|
|
|
|
+static int _PartitionGetDisk(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, int nPartIdx)
|
|
{
|
|
{
|
|
- if((nPartIdx >= 0) && (nPartIdx < (ssize_t)_countof(sdm.parts)))
|
|
|
|
|
|
+ if((nPartIdx >= 0) && (nPartIdx < (int)_countof(sdm.parts)))
|
|
return sdm.parts[nPartIdx].nDiskIdx;
|
|
return sdm.parts[nPartIdx].nDiskIdx;
|
|
return -1;
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
|
|
-void _ClearMapChanges(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm)
|
|
|
|
|
|
+static void _ClearMapChanges(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm)
|
|
{
|
|
{
|
|
sdm.nPartChangeMask = 0;
|
|
sdm.nPartChangeMask = 0;
|
|
}
|
|
}
|
|
|
|
|
|
-bool _MapChanged(const GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm)
|
|
|
|
|
|
+static bool _DeviceMapChanged(const GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm)
|
|
{
|
|
{
|
|
return !!sdm.nPartChangeMask;
|
|
return !!sdm.nPartChangeMask;
|
|
}
|
|
}
|
|
|
|
|
|
-unsigned int _SetPartitionChange(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, ssize_t nPartIdx)
|
|
|
|
|
|
+static unsigned int _SetPartitionChange(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, int nPartIdx)
|
|
{
|
|
{
|
|
- if((nPartIdx >= 0) && (nPartIdx < (ssize_t)_countof(sdm.parts)))
|
|
|
|
|
|
+ if((nPartIdx >= 0) && (nPartIdx < (int)_countof(sdm.parts)))
|
|
{
|
|
{
|
|
- unsigned int nChanged = _NUM_TO_BIT(nPartIdx);
|
|
|
|
|
|
+ unsigned int nChanged = (0x01 << nPartIdx);
|
|
sdm.nPartChangeMask |= nChanged;
|
|
sdm.nPartChangeMask |= nChanged;
|
|
}
|
|
}
|
|
|
|
+
|
|
return sdm.nPartChangeMask;
|
|
return sdm.nPartChangeMask;
|
|
}
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
-ssize_t _LookupDisk(const GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, const char *pszDevNode)
|
|
|
|
|
|
+static int _LookupDisk(const GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, const char *pszDevNode)
|
|
{
|
|
{
|
|
- ssize_t nIndex = -1;
|
|
|
|
|
|
+ int nIndex = -1;
|
|
|
|
|
|
if(pszDevNode && *pszDevNode)
|
|
if(pszDevNode && *pszDevNode)
|
|
{
|
|
{
|
|
@@ -187,9 +217,9 @@ ssize_t _LookupDisk(const GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, const char *pszDe
|
|
return nIndex;
|
|
return nIndex;
|
|
}
|
|
}
|
|
|
|
|
|
-ssize_t _AddDisk(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, const GFA_SYSINFO_DISK &disk, bool &bChange)
|
|
|
|
|
|
+static int _AddDisk(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, const GFA_SYSINFO_DISK &disk, bool &bChange)
|
|
{
|
|
{
|
|
- ssize_t nIndex = -1;
|
|
|
|
|
|
+ int nIndex = -1;
|
|
bChange = false;
|
|
bChange = false;
|
|
|
|
|
|
if((nIndex = _LookupDisk(sdm, disk.szDevNode)) >= 0)
|
|
if((nIndex = _LookupDisk(sdm, disk.szDevNode)) >= 0)
|
|
@@ -210,28 +240,33 @@ ssize_t _AddDisk(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, const GFA_SYSINFO_DISK &di
|
|
return nIndex;
|
|
return nIndex;
|
|
}
|
|
}
|
|
|
|
|
|
-ssize_t _RemoveDisk(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, ssize_t nIndex, bool &bChange)
|
|
|
|
|
|
+static int _RemoveDisk(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, int nIndex, bool &bChange)
|
|
{
|
|
{
|
|
bChange = false;
|
|
bChange = false;
|
|
- if(nIndex >= 0 && nIndex < (ssize_t)_countof(sdm.disks))
|
|
|
|
|
|
+
|
|
|
|
+ if(nIndex >= 0 && nIndex < (int)_countof(sdm.disks))
|
|
{
|
|
{
|
|
bChange = sdm.disks[nIndex].valid;
|
|
bChange = sdm.disks[nIndex].valid;
|
|
sdm.disks[nIndex].valid = false;
|
|
sdm.disks[nIndex].valid = false;
|
|
}
|
|
}
|
|
|
|
+
|
|
return nIndex;
|
|
return nIndex;
|
|
}
|
|
}
|
|
|
|
|
|
-ssize_t _RemoveDisk(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, const char *pszDevNode, bool &bChange)
|
|
|
|
|
|
+#if 0
|
|
|
|
+static int _RemoveDisk(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, const char *pszDevNode, bool &bChange)
|
|
{
|
|
{
|
|
- ssize_t nIndex = _LookupDisk(sdm, pszDevNode);
|
|
|
|
|
|
+ int nIndex = _LookupDisk(sdm, pszDevNode);
|
|
return _RemoveDisk(sdm, nIndex, bChange);
|
|
return _RemoveDisk(sdm, nIndex, bChange);
|
|
}
|
|
}
|
|
|
|
+#endif
|
|
|
|
|
|
-unsigned int _DiskAddPartition(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, ssize_t nDiskIdx, ssize_t nPartIdx, bool &bChange)
|
|
|
|
|
|
+static unsigned int _DiskAddPartition(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, int nDiskIdx, int nPartIdx, bool &bChange)
|
|
{
|
|
{
|
|
bChange = false;
|
|
bChange = false;
|
|
- if( (nPartIdx >= 0) && (nPartIdx < (ssize_t)_countof(sdm.parts)) &&
|
|
|
|
- (nDiskIdx >= 0) && (nDiskIdx < (ssize_t)_countof(sdm.disks)))
|
|
|
|
|
|
+
|
|
|
|
+ if( (nPartIdx >= 0) && (nPartIdx < (int)_countof(sdm.parts)) &&
|
|
|
|
+ (nDiskIdx >= 0) && (nDiskIdx < (int)_countof(sdm.disks)))
|
|
{
|
|
{
|
|
GFA_SYSINFO_DISK &disk = sdm.disks[nDiskIdx];
|
|
GFA_SYSINFO_DISK &disk = sdm.disks[nDiskIdx];
|
|
|
|
|
|
@@ -248,14 +283,16 @@ unsigned int _DiskAddPartition(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, ssize_t nDis
|
|
return disk.nPartCount;
|
|
return disk.nPartCount;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
+
|
|
return 0;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
|
|
-unsigned int _DiskRemovePartition(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, ssize_t nDiskIdx, ssize_t nPartIdx, bool &bChange)
|
|
|
|
|
|
+static unsigned int _DiskRemovePartition(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, int nDiskIdx, int nPartIdx, bool &bChange)
|
|
{
|
|
{
|
|
bChange = false;
|
|
bChange = false;
|
|
- if( (nPartIdx >= 0) && (nPartIdx < (ssize_t)_countof(sdm.parts)) &&
|
|
|
|
- (nDiskIdx >= 0) && (nDiskIdx < (ssize_t)_countof(sdm.disks)))
|
|
|
|
|
|
+
|
|
|
|
+ if( (nPartIdx >= 0) && (nPartIdx < (int)_countof(sdm.parts)) &&
|
|
|
|
+ (nDiskIdx >= 0) && (nDiskIdx < (int)_countof(sdm.disks)))
|
|
{
|
|
{
|
|
unsigned int i, j;
|
|
unsigned int i, j;
|
|
GFA_SYSINFO_DISK &disk = sdm.disks[nDiskIdx];
|
|
GFA_SYSINFO_DISK &disk = sdm.disks[nDiskIdx];
|
|
@@ -275,39 +312,15 @@ unsigned int _DiskRemovePartition(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, ssize_t n
|
|
bChange = true;
|
|
bChange = true;
|
|
return --disk.nPartCount;
|
|
return --disk.nPartCount;
|
|
}
|
|
}
|
|
|
|
+
|
|
return disk.nPartCount;
|
|
return disk.nPartCount;
|
|
}
|
|
}
|
|
|
|
+
|
|
return 0;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
-
|
|
|
|
-static const char *g_pszStateNames[] =
|
|
|
|
-{
|
|
|
|
- "Not running",
|
|
|
|
- "Initializing",
|
|
|
|
- "Running",
|
|
|
|
- "Paused",
|
|
|
|
- "Hanging",
|
|
|
|
- "Terminating",
|
|
|
|
- "Invalid"
|
|
|
|
-};
|
|
|
|
-
|
|
|
|
-/////////////////////////////////////////////////////////////////////////////
|
|
|
|
-
|
|
|
|
-static volatile bool g_fRun = false;
|
|
|
|
-static volatile bool g_fPause = false;
|
|
|
|
-
|
|
|
|
-/////////////////////////////////////////////////////////////////////////////
|
|
|
|
-
|
|
|
|
-static void _SigHandler(int sig)
|
|
|
|
-{
|
|
|
|
- UNUSED(sig);
|
|
|
|
- g_fPause = false;
|
|
|
|
- g_fRun = false;
|
|
|
|
-}
|
|
|
|
-
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
static bool _LookupMountPoint(MountMap &mm, const char *pszNode, char *pszMntPoint, size_t nCChMntPoint)
|
|
static bool _LookupMountPoint(MountMap &mm, const char *pszNode, char *pszMntPoint, size_t nCChMntPoint)
|
|
@@ -326,7 +339,7 @@ static bool _LookupMountPoint(MountMap &mm, const char *pszNode, char *pszMntPoi
|
|
return false;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
-static bool _UpdatePartitionSizeInfo(MountMap &mm, GFA_SYSINFO_PARTITION &part)
|
|
|
|
|
|
+static bool _UpdatePartitionFsInfo(MountMap &mm, GFA_SYSINFO_PARTITION &part)
|
|
{
|
|
{
|
|
if(_LookupMountPoint(mm, part.szDevNode, part.szMntPoint, sizeof(part.szMntPoint)))
|
|
if(_LookupMountPoint(mm, part.szDevNode, part.szMntPoint, sizeof(part.szMntPoint)))
|
|
{
|
|
{
|
|
@@ -340,6 +353,8 @@ static bool _UpdatePartitionSizeInfo(MountMap &mm, GFA_SYSINFO_PARTITION &part)
|
|
}
|
|
}
|
|
else
|
|
else
|
|
{
|
|
{
|
|
|
|
+ TRACE("statvfs failed on \"%s\": %s\n", part.szMntPoint, strerror(errno));
|
|
|
|
+ memset(part.szMntPoint, 0, sizeof(part.szMntPoint));
|
|
part.nKiBSize = 0;
|
|
part.nKiBSize = 0;
|
|
part.nKiBFree = 0;
|
|
part.nKiBFree = 0;
|
|
part.nKiBUsed = 0;
|
|
part.nKiBUsed = 0;
|
|
@@ -360,6 +375,33 @@ static bool _UpdatePartitionSizeInfo(MountMap &mm, GFA_SYSINFO_PARTITION &part)
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
+static std::string _StrReplace(std::string &s, const char *pszFind, const char *pszRepl)
|
|
|
|
+{
|
|
|
|
+ std::string r = s;
|
|
|
|
+
|
|
|
|
+ if(pszFind && *pszFind && pszRepl)
|
|
|
|
+ {
|
|
|
|
+ size_t nFind, nLen = strlen(pszFind);
|
|
|
|
+
|
|
|
|
+ while((nFind = r.find(pszFind)) != std::string::npos)
|
|
|
|
+ {
|
|
|
|
+ r = r.replace(nFind, nLen, pszRepl);
|
|
|
|
+ }
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ return r;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static std::string _UnescapeMountpointString(std::string &s)
|
|
|
|
+{
|
|
|
|
+ std::string r = s;
|
|
|
|
+ r = _StrReplace(r, "\\040", " ");
|
|
|
|
+ r = _StrReplace(r, "\\011", "\t");
|
|
|
|
+ r = _StrReplace(r, "\\012", "\n");
|
|
|
|
+ r = _StrReplace(r, "\\134", "\\");
|
|
|
|
+ return r;
|
|
|
|
+}
|
|
|
|
+
|
|
static void _UpdateMountMap(MountMap &mm)
|
|
static void _UpdateMountMap(MountMap &mm)
|
|
{
|
|
{
|
|
char szLine[512], szNode[512], szMount[512];
|
|
char szLine[512], szNode[512], szMount[512];
|
|
@@ -371,7 +413,9 @@ static void _UpdateMountMap(MountMap &mm)
|
|
if((sscanf(szLine, "%s %s", szNode, szMount) == 2))
|
|
if((sscanf(szLine, "%s %s", szNode, szMount) == 2))
|
|
{
|
|
{
|
|
std::string key(szNode);
|
|
std::string key(szNode);
|
|
|
|
+ key = _UnescapeMountpointString(key);
|
|
std::string val(szMount);
|
|
std::string val(szMount);
|
|
|
|
+ val = _UnescapeMountpointString(val);
|
|
mm.emplace(key, val);
|
|
mm.emplace(key, val);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
@@ -395,17 +439,15 @@ static bool _ProcessMounts(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, MountMap &mm)
|
|
|
|
|
|
if(!bMountedOld && bMountedNew)
|
|
if(!bMountedOld && bMountedNew)
|
|
{
|
|
{
|
|
-// TRACE("Partition %s: mounted at %s\n", part.szDevNode, szMntPoint);
|
|
|
|
memcpy(part.szMntPoint, szMntPoint, sizeof(part.szMntPoint));
|
|
memcpy(part.szMntPoint, szMntPoint, sizeof(part.szMntPoint));
|
|
- _UpdatePartitionSizeInfo(mm, part);
|
|
|
|
|
|
+ _UpdatePartitionFsInfo(mm, part);
|
|
_SetPartitionChange(sdm, i);
|
|
_SetPartitionChange(sdm, i);
|
|
bChange = true;
|
|
bChange = true;
|
|
}
|
|
}
|
|
else if(bMountedOld && !bMountedNew)
|
|
else if(bMountedOld && !bMountedNew)
|
|
{
|
|
{
|
|
-// TRACE("Partition %s: unmounted from %s\n", part.szDevNode, part.szMntPoint);
|
|
|
|
memset(part.szMntPoint, 0, sizeof(part.szMntPoint));
|
|
memset(part.szMntPoint, 0, sizeof(part.szMntPoint));
|
|
- _UpdatePartitionSizeInfo(mm, part);
|
|
|
|
|
|
+ _UpdatePartitionFsInfo(mm, part);
|
|
_SetPartitionChange(sdm, i);
|
|
_SetPartitionChange(sdm, i);
|
|
bChange = true;
|
|
bChange = true;
|
|
}
|
|
}
|
|
@@ -413,15 +455,15 @@ static bool _ProcessMounts(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, MountMap &mm)
|
|
{
|
|
{
|
|
if(strcmp(part.szMntPoint, szMntPoint))
|
|
if(strcmp(part.szMntPoint, szMntPoint))
|
|
{
|
|
{
|
|
-// TRACE("Partition %s: mount point changed: %s -> %s\n", part.szDevNode, part.szMntPoint, szMntPoint);
|
|
|
|
memcpy(part.szMntPoint, szMntPoint, sizeof(part.szMntPoint));
|
|
memcpy(part.szMntPoint, szMntPoint, sizeof(part.szMntPoint));
|
|
- _UpdatePartitionSizeInfo(mm, part);
|
|
|
|
|
|
+ _UpdatePartitionFsInfo(mm, part);
|
|
_SetPartitionChange(sdm, i);
|
|
_SetPartitionChange(sdm, i);
|
|
bChange = true;
|
|
bChange = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
+
|
|
return bChange;
|
|
return bChange;
|
|
}
|
|
}
|
|
|
|
|
|
@@ -461,15 +503,15 @@ static void _ProcessCtrlMessages(HAPPCTRL hAC, HAPPINFO hAI)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
-static const char* _GetFileSpec(const char *pszName)
|
|
|
|
|
|
+static const char* _GetFileSpec(const char *pszPathname)
|
|
{
|
|
{
|
|
- if(pszName && *pszName)
|
|
|
|
|
|
+ if(pszPathname && *pszPathname)
|
|
{
|
|
{
|
|
- const char *pSlash = strrchr(pszName, '/');
|
|
|
|
|
|
+ const char *pSlash = strrchr(pszPathname, '/');
|
|
if(pSlash)
|
|
if(pSlash)
|
|
return ++pSlash;
|
|
return ++pSlash;
|
|
else
|
|
else
|
|
- return pszName;
|
|
|
|
|
|
+ return pszPathname;
|
|
}
|
|
}
|
|
|
|
|
|
return NULL;
|
|
return NULL;
|
|
@@ -480,7 +522,7 @@ static bool _IsInternalEmmc(const char *pszDevNode)
|
|
if(pszDevNode)
|
|
if(pszDevNode)
|
|
{
|
|
{
|
|
const char *pszDevName = _GetFileSpec(pszDevNode);
|
|
const char *pszDevName = _GetFileSpec(pszDevNode);
|
|
- return _STR_EQUALS(pszDevName, _INTERNAL_EMMC_PART1) || _STR_EQUALS(pszDevName, _INTERNAL_EMMC_PART2);
|
|
|
|
|
|
+ return _STR_EQUALS(pszDevName, _INTERNAL_EMMC_PART2) || _STR_EQUALS(pszDevName, _INTERNAL_EMMC_PART1);
|
|
}
|
|
}
|
|
|
|
|
|
return false;
|
|
return false;
|
|
@@ -492,14 +534,14 @@ static void _EnumDevProperties(struct udev_device *dev, int nIndent)
|
|
if(dev)
|
|
if(dev)
|
|
{
|
|
{
|
|
struct udev_list_entry *prop;
|
|
struct udev_list_entry *prop;
|
|
- struct udev_list_entry *props = udev_device_get_properties_list_entry(dev);
|
|
|
|
|
|
+ struct udev_list_entry *props = ::udev_device_get_properties_list_entry(dev);
|
|
|
|
|
|
if(props)
|
|
if(props)
|
|
{
|
|
{
|
|
udev_list_entry_foreach(prop, props)
|
|
udev_list_entry_foreach(prop, props)
|
|
{
|
|
{
|
|
- const char *pszName = udev_list_entry_get_name(prop);
|
|
|
|
- const char *pszValue = udev_list_entry_get_value(prop);
|
|
|
|
|
|
+ const char *pszName = ::udev_list_entry_get_name(prop);
|
|
|
|
+ const char *pszValue = ::udev_list_entry_get_value(prop);
|
|
|
|
|
|
if(pszName && pszValue)
|
|
if(pszName && pszValue)
|
|
{
|
|
{
|
|
@@ -515,13 +557,13 @@ static void _EnumDevSysAttributes(struct udev_device *dev, int nIndent)
|
|
if(dev)
|
|
if(dev)
|
|
{
|
|
{
|
|
struct udev_list_entry *att;
|
|
struct udev_list_entry *att;
|
|
- struct udev_list_entry *atts = udev_device_get_sysattr_list_entry(dev);
|
|
|
|
|
|
+ struct udev_list_entry *atts = ::udev_device_get_sysattr_list_entry(dev);
|
|
if(atts)
|
|
if(atts)
|
|
{
|
|
{
|
|
udev_list_entry_foreach(att, atts)
|
|
udev_list_entry_foreach(att, atts)
|
|
{
|
|
{
|
|
- const char *pszName = udev_list_entry_get_name(att);
|
|
|
|
- const char *pszValue = udev_device_get_sysattr_value(dev, pszName);
|
|
|
|
|
|
+ const char *pszName = ::udev_list_entry_get_name(att);
|
|
|
|
+ const char *pszValue = ::udev_device_get_sysattr_value(dev, pszName);
|
|
|
|
|
|
if(pszName && pszValue && strcmp(pszName, "uevent"))
|
|
if(pszName && pszValue && strcmp(pszName, "uevent"))
|
|
{
|
|
{
|
|
@@ -533,13 +575,6 @@ static void _EnumDevSysAttributes(struct udev_device *dev, int nIndent)
|
|
}
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
|
|
-#define _BYTE_SIZE_KIB (1ULL << 10) // Kibibyte
|
|
|
|
-#define _BYTE_SIZE_MIB (1ULL << 20) // Mebibyte
|
|
|
|
-#define _BYTE_SIZE_GIB (1ULL << 30) // Gibibyte
|
|
|
|
-#define _BYTE_SIZE_TIB (1ULL << 40) // Tebibyte
|
|
|
|
-#define _BYTE_SIZE_PIB (1ULL << 50) // Pebibyte
|
|
|
|
-#define _BYTE_SIZE_EIB (1ULL << 60) // Exbibyte
|
|
|
|
-
|
|
|
|
static const char *_FormatByteSize(unsigned long long nCb, char *pszBuf, size_t nCChBuf)
|
|
static const char *_FormatByteSize(unsigned long long nCb, char *pszBuf, size_t nCChBuf)
|
|
{
|
|
{
|
|
if(pszBuf && nCChBuf)
|
|
if(pszBuf && nCChBuf)
|
|
@@ -549,7 +584,7 @@ static const char *_FormatByteSize(unsigned long long nCb, char *pszBuf, size_t
|
|
|
|
|
|
if(nCb < _BYTE_SIZE_KIB)
|
|
if(nCb < _BYTE_SIZE_KIB)
|
|
{
|
|
{
|
|
- snprintf(pszBuf, nCChBuf, "%llu Byte", nCb); // Byte
|
|
|
|
|
|
+ snprintf(pszBuf, nCChBuf, "%llu B", nCb); // Byte
|
|
}
|
|
}
|
|
else if(nCb < _BYTE_SIZE_MIB)
|
|
else if(nCb < _BYTE_SIZE_MIB)
|
|
{
|
|
{
|
|
@@ -583,7 +618,7 @@ static const char *_FormatByteSize(unsigned long long nCb, char *pszBuf, size_t
|
|
return NULL;
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
|
|
-static void _DumpStorageDeviceMap(const GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm)
|
|
|
|
|
|
+static void _DumpDeviceMap(const GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm)
|
|
{
|
|
{
|
|
TRACE("\n");
|
|
TRACE("\n");
|
|
for(size_t i = 0; i < _countof(sdm.disks); ++i)
|
|
for(size_t i = 0; i < _countof(sdm.disks); ++i)
|
|
@@ -591,17 +626,17 @@ static void _DumpStorageDeviceMap(const GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm)
|
|
char szByteBuf[16];
|
|
char szByteBuf[16];
|
|
const GFA_SYSINFO_DISK &disk = sdm.disks[i];
|
|
const GFA_SYSINFO_DISK &disk = sdm.disks[i];
|
|
|
|
|
|
- if(disk.valid)
|
|
|
|
|
|
+ if(disk.valid && !disk.internal)
|
|
{
|
|
{
|
|
TRACE("Disk:\n");
|
|
TRACE("Disk:\n");
|
|
TRACE(" |-Label: %s\n", disk.szName);
|
|
TRACE(" |-Label: %s\n", disk.szName);
|
|
- TRACE(" |-Vendor: %s\n", *disk.szVendor ? disk.szVendor : "");
|
|
|
|
|
|
+ TRACE(" |-Vendor: %s\n", *disk.szVendor ? disk.szVendor : "n/a");
|
|
TRACE(" |-Node: %s\n", disk.szDevNode);
|
|
TRACE(" |-Node: %s\n", disk.szDevNode);
|
|
TRACE(" |-Type: %s\n", *disk.szBus ? disk.szBus : "mmc");
|
|
TRACE(" |-Type: %s\n", *disk.szBus ? disk.szBus : "mmc");
|
|
|
|
|
|
for(unsigned int j = 0; j < disk.nPartCount; ++j)
|
|
for(unsigned int j = 0; j < disk.nPartCount; ++j)
|
|
{
|
|
{
|
|
- ssize_t nIndex = disk.aPartIdx[j];
|
|
|
|
|
|
+ int nIndex = disk.aPartIdx[j];
|
|
const GFA_SYSINFO_PARTITION &part = sdm.parts[nIndex];
|
|
const GFA_SYSINFO_PARTITION &part = sdm.parts[nIndex];
|
|
bool bMounted = !!*part.szMntPoint;
|
|
bool bMounted = !!*part.szMntPoint;
|
|
|
|
|
|
@@ -662,7 +697,7 @@ static const char* _ReadDevPropertyValue(struct udev_device* dev, const char *ps
|
|
return NULL;
|
|
return NULL;
|
|
memset(pszValue, 0, nCChValue);
|
|
memset(pszValue, 0, nCChValue);
|
|
|
|
|
|
- const char *pszVal = udev_device_get_property_value(dev, pszKey);
|
|
|
|
|
|
+ const char *pszVal = ::udev_device_get_property_value(dev, pszKey);
|
|
|
|
|
|
if(pszVal)
|
|
if(pszVal)
|
|
{
|
|
{
|
|
@@ -692,18 +727,19 @@ static void _ProcessPartition(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, MountMap &mm,
|
|
GFA_SYSINFO_PARTITION part;
|
|
GFA_SYSINFO_PARTITION part;
|
|
memset(&part, 0, sizeof(part));
|
|
memset(&part, 0, sizeof(part));
|
|
part.nDiskIdx = -1;
|
|
part.nDiskIdx = -1;
|
|
- ssize_t nPartIdx = -1;
|
|
|
|
- ssize_t nDiskIdx = -1;
|
|
|
|
|
|
+ int nPartIdx = -1;
|
|
|
|
+ int nDiskIdx = -1;
|
|
|
|
|
|
- const char *pszDevNode = udev_device_get_devnode(dev);
|
|
|
|
|
|
+ const char *pszDevNode = ::udev_device_get_devnode(dev);
|
|
|
|
|
|
if(!pszDevNode)
|
|
if(!pszDevNode)
|
|
return;
|
|
return;
|
|
- if(_IsInternalEmmc(pszDevNode))
|
|
|
|
- return; // skip internal emmc
|
|
|
|
|
|
+// if(_IsInternalEmmc(pszDevNode))
|
|
|
|
+// return; // skip internal emmc
|
|
|
|
+ bool bInternalEmmc = _IsInternalEmmc(pszDevNode);
|
|
strncpy(part.szDevNode, pszDevNode, sizeof(part.szDevNode) - 1);
|
|
strncpy(part.szDevNode, pszDevNode, sizeof(part.szDevNode) - 1);
|
|
|
|
|
|
- const char *pszAction = udev_device_get_action(dev);
|
|
|
|
|
|
+ const char *pszAction = ::udev_device_get_action(dev);
|
|
bool bAdd = _STR_EQUALS(pszAction, "add");
|
|
bool bAdd = _STR_EQUALS(pszAction, "add");
|
|
bool bRem = _STR_EQUALS(pszAction, "remove");
|
|
bool bRem = _STR_EQUALS(pszAction, "remove");
|
|
bool bEnum = !pszAction;
|
|
bool bEnum = !pszAction;
|
|
@@ -713,20 +749,20 @@ static void _ProcessPartition(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, MountMap &mm,
|
|
if(_LookupPartition(sdm, part.szDevNode) >= 0)
|
|
if(_LookupPartition(sdm, part.szDevNode) >= 0)
|
|
return;
|
|
return;
|
|
|
|
|
|
|
|
+ part.internal = bInternalEmmc;
|
|
_ReadDevPropertyValue(dev, "ID_FS_LABEL", part.szFsLabel, sizeof(part.szFsLabel), true);
|
|
_ReadDevPropertyValue(dev, "ID_FS_LABEL", part.szFsLabel, sizeof(part.szFsLabel), true);
|
|
_ReadDevPropertyValue(dev, "ID_FS_TYPE", part.szFsType, sizeof(part.szFsType), true);
|
|
_ReadDevPropertyValue(dev, "ID_FS_TYPE", part.szFsType, sizeof(part.szFsType), true);
|
|
_ReadDevPropertyValue(dev, "ID_FS_VERSION", part.szFsVersion, sizeof(part.szFsVersion), true);
|
|
_ReadDevPropertyValue(dev, "ID_FS_VERSION", part.szFsVersion, sizeof(part.szFsVersion), true);
|
|
part.nKiBPartSize = _ReadDevPropertyValue(dev, "ID_PART_ENTRY_SIZE") / 2;
|
|
part.nKiBPartSize = _ReadDevPropertyValue(dev, "ID_PART_ENTRY_SIZE") / 2;
|
|
-
|
|
|
|
- _UpdatePartitionSizeInfo(mm, part);
|
|
|
|
|
|
+ _UpdatePartitionFsInfo(mm, part);
|
|
|
|
|
|
struct udev_device* cur = dev;
|
|
struct udev_device* cur = dev;
|
|
|
|
|
|
- while((cur = udev_device_get_parent(cur)))
|
|
|
|
|
|
+ while((cur = ::udev_device_get_parent(cur)))
|
|
{
|
|
{
|
|
- const char *pszSs = udev_device_get_subsystem(cur);
|
|
|
|
- const char *pszDt = udev_device_get_devtype(cur);
|
|
|
|
- const char *pszDn = udev_device_get_devnode(cur);
|
|
|
|
|
|
+ const char *pszSs = ::udev_device_get_subsystem(cur);
|
|
|
|
+ const char *pszDt = ::udev_device_get_devtype(cur);
|
|
|
|
+ const char *pszDn = ::udev_device_get_devnode(cur);
|
|
|
|
|
|
if(!pszDn)
|
|
if(!pszDn)
|
|
break;
|
|
break;
|
|
@@ -739,11 +775,15 @@ static void _ProcessPartition(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, MountMap &mm,
|
|
memset(&disk, 0, sizeof(disk));
|
|
memset(&disk, 0, sizeof(disk));
|
|
strncpy(disk.szDevNode, pszDn, sizeof(disk.szDevNode) - 1);
|
|
strncpy(disk.szDevNode, pszDn, sizeof(disk.szDevNode) - 1);
|
|
|
|
|
|
|
|
+ disk.internal = bInternalEmmc;
|
|
if(!_ReadDevPropertyValue(cur, "ID_NAME", disk.szName, sizeof(disk.szName), true))
|
|
if(!_ReadDevPropertyValue(cur, "ID_NAME", disk.szName, sizeof(disk.szName), true))
|
|
_ReadDevPropertyValue(cur, "ID_MODEL", disk.szName, sizeof(disk.szName), true);
|
|
_ReadDevPropertyValue(cur, "ID_MODEL", disk.szName, sizeof(disk.szName), true);
|
|
_ReadDevPropertyValue(cur, "ID_VENDOR", disk.szVendor, sizeof(disk.szVendor), true);
|
|
_ReadDevPropertyValue(cur, "ID_VENDOR", disk.szVendor, sizeof(disk.szVendor), true);
|
|
_ReadDevPropertyValue(cur, "ID_BUS", disk.szBus, sizeof(disk.szBus), true);
|
|
_ReadDevPropertyValue(cur, "ID_BUS", disk.szBus, sizeof(disk.szBus), true);
|
|
|
|
|
|
|
|
+ disk.nVendorID = _ReadDevPropertyValue(cur, "ID_VENDOR_ID", 16);
|
|
|
|
+ disk.nProductID = _ReadDevPropertyValue(cur, "ID_MODEL_ID", 16);
|
|
|
|
+
|
|
if((nDiskIdx = _AddDisk(sdm, disk, bChange)) >= 0)
|
|
if((nDiskIdx = _AddDisk(sdm, disk, bChange)) >= 0)
|
|
{
|
|
{
|
|
if((nPartIdx = _AddPartition(sdm, part, bChange)) < 0)
|
|
if((nPartIdx = _AddPartition(sdm, part, bChange)) < 0)
|
|
@@ -781,26 +821,34 @@ static void _ProcessPartition(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, MountMap &mm,
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
-static void _EnumStorageDevices(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, MountMap &mm, struct udev* udev)
|
|
|
|
|
|
+static void _EnumStorageDevices(GFA_SYSINFO_STORAGE_DEVICE_MAP &sdm, MountMap &mm, struct udev *pUdev)
|
|
{
|
|
{
|
|
- struct udev_enumerate* enumerate = udev_enumerate_new(udev);
|
|
|
|
- udev_enumerate_add_match_subsystem(enumerate, "block");
|
|
|
|
- udev_enumerate_add_match_property(enumerate, "DEVTYPE", "partition");
|
|
|
|
- udev_enumerate_scan_devices(enumerate);
|
|
|
|
|
|
+ struct udev_enumerate *pEnum = ::udev_enumerate_new(pUdev);
|
|
|
|
+ ::udev_enumerate_add_match_subsystem(pEnum, "block");
|
|
|
|
+ ::udev_enumerate_add_match_property(pEnum, "DEVTYPE", "partition");
|
|
|
|
+ ::udev_enumerate_scan_devices(pEnum);
|
|
|
|
|
|
- struct udev_list_entry *devices = udev_enumerate_get_list_entry(enumerate);
|
|
|
|
|
|
+ struct udev_list_entry *devices = ::udev_enumerate_get_list_entry(pEnum);
|
|
struct udev_list_entry *entry;
|
|
struct udev_list_entry *entry;
|
|
|
|
|
|
udev_list_entry_foreach(entry, devices)
|
|
udev_list_entry_foreach(entry, devices)
|
|
{
|
|
{
|
|
- const char *pszPath = udev_list_entry_get_name(entry);
|
|
|
|
- struct udev_device* dev = udev_device_new_from_syspath(udev, pszPath);
|
|
|
|
|
|
+ const char *pszPath = ::udev_list_entry_get_name(entry);
|
|
|
|
+ struct udev_device* dev = ::udev_device_new_from_syspath(pUdev, pszPath);
|
|
|
|
|
|
_ProcessPartition(sdm, mm, dev);
|
|
_ProcessPartition(sdm, mm, dev);
|
|
- udev_device_unref(dev);
|
|
|
|
|
|
+ ::udev_device_unref(dev);
|
|
}
|
|
}
|
|
|
|
|
|
- udev_enumerate_unref(enumerate);
|
|
|
|
|
|
+ ::udev_enumerate_unref(pEnum);
|
|
|
|
+}
|
|
|
|
+/////////////////////////////////////////////////////////////////////////////
|
|
|
|
+
|
|
|
|
+static void _SigHandler(int sig)
|
|
|
|
+{
|
|
|
|
+ UNUSED(sig);
|
|
|
|
+ g_fPause = false;
|
|
|
|
+ g_fRun = false;
|
|
}
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
@@ -816,7 +864,7 @@ int main(int argc, char *argv[])
|
|
HAPPINFO hAI;
|
|
HAPPINFO hAI;
|
|
CCycleTimer ct(_CYCLE_INTV);
|
|
CCycleTimer ct(_CYCLE_INTV);
|
|
cy_time_t wStart, wEnd, wCur = 0;
|
|
cy_time_t wStart, wEnd, wCur = 0;
|
|
- struct udev* udev = NULL;
|
|
|
|
|
|
+ struct udev *pUdev = NULL;
|
|
struct timeval tv;
|
|
struct timeval tv;
|
|
memset(&tv, 0, sizeof(tv));
|
|
memset(&tv, 0, sizeof(tv));
|
|
struct udev_monitor *pUdevMon = NULL;
|
|
struct udev_monitor *pUdevMon = NULL;
|
|
@@ -857,39 +905,53 @@ int main(int argc, char *argv[])
|
|
do
|
|
do
|
|
{
|
|
{
|
|
if(!(hAC = ::GfaIpcAppCtrlAcquire(_APPID, _APPNAME, _CYCLE_INTV * 1000, _CYCLE_INTV * 3000)))
|
|
if(!(hAC = ::GfaIpcAppCtrlAcquire(_APPID, _APPNAME, _CYCLE_INTV * 1000, _CYCLE_INTV * 3000)))
|
|
|
|
+ {
|
|
|
|
+ TRACE("GfaIpcAppCtrlAcquire failed\n");
|
|
break;
|
|
break;
|
|
|
|
+ }
|
|
|
|
|
|
if(!::GfaIpcAppCtrlCreateSysInfo(hAC))
|
|
if(!::GfaIpcAppCtrlCreateSysInfo(hAC))
|
|
|
|
+ {
|
|
|
|
+ TRACE("GfaIpcAppCtrlCreateSysInfo failed\n");
|
|
break;
|
|
break;
|
|
|
|
+ }
|
|
|
|
|
|
- if(!(udev = udev_new()))
|
|
|
|
|
|
+ if(!(pUdev = ::udev_new()))
|
|
{
|
|
{
|
|
- fprintf(stderr, "udev_new() failed\n");
|
|
|
|
- return 1;
|
|
|
|
|
|
+ TRACE("udev_new failed\n");
|
|
|
|
+ break;
|
|
}
|
|
}
|
|
|
|
|
|
_UpdateMountMap(mm);
|
|
_UpdateMountMap(mm);
|
|
- _EnumStorageDevices(sdm, mm, udev);
|
|
|
|
- _DumpStorageDeviceMap(sdm);
|
|
|
|
|
|
+ _EnumStorageDevices(sdm, mm, pUdev);
|
|
|
|
|
|
- if((pUdevMon = udev_monitor_new_from_netlink(udev, "udev")))
|
|
|
|
|
|
+ if(!(pUdevMon = ::udev_monitor_new_from_netlink(pUdev, "udev")))
|
|
{
|
|
{
|
|
- udev_monitor_filter_add_match_subsystem_devtype(pUdevMon, "block", "partition");
|
|
|
|
- udev_monitor_enable_receiving(pUdevMon);
|
|
|
|
-
|
|
|
|
- pfd[0].fd = udev_monitor_get_fd(pUdevMon);
|
|
|
|
- pfd[0].events = POLLIN;
|
|
|
|
- pfd[0].revents = 0;
|
|
|
|
- pfd[1].fd = open(_MOUNTS_FILE, O_RDONLY, 0);
|
|
|
|
- pfd[1].events = POLLPRI;
|
|
|
|
- pfd[1].revents = 0;
|
|
|
|
|
|
+ TRACE("udev_monitor_new_from_netlink failed\n");
|
|
|
|
+ break;
|
|
}
|
|
}
|
|
|
|
|
|
-// ;;GfaIpcDumpSHMROT();
|
|
|
|
- ::GfaIpcAppCtrlSetState(hAC, GIAS_Initializing);
|
|
|
|
|
|
+ if(::udev_monitor_filter_add_match_subsystem_devtype(pUdevMon, "block", "partition") < 0)
|
|
|
|
+ {
|
|
|
|
+ TRACE("udev_monitor_filter_add_match_subsystem_devtype failed\n");
|
|
|
|
+ break;
|
|
|
|
+ }
|
|
|
|
|
|
-// if(!::GfaIpcAppCtrlSubscribeStateEvents(hAC, GFA_APPCTRL_APPID_USER_01))
|
|
|
|
-// break;
|
|
|
|
|
|
+ if(::udev_monitor_enable_receiving(pUdevMon) < 0)
|
|
|
|
+ {
|
|
|
|
+ TRACE("udev_monitor_enable_receiving failed\n");
|
|
|
|
+ break;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ pfd[0].fd = ::udev_monitor_get_fd(pUdevMon);
|
|
|
|
+ pfd[0].events = POLLIN;
|
|
|
|
+ pfd[0].revents = 0;
|
|
|
|
+ pfd[1].fd = open(_MOUNTS_FILE, O_RDONLY, 0);
|
|
|
|
+ pfd[1].events = POLLPRI;
|
|
|
|
+ pfd[1].revents = 0;
|
|
|
|
+
|
|
|
|
+ ;;GfaIpcDumpSHMROT();
|
|
|
|
+ ::GfaIpcAppCtrlSetState(hAC, GIAS_Initializing);
|
|
|
|
|
|
TRACE("My Name: %s\n", _APPNAME);
|
|
TRACE("My Name: %s\n", _APPNAME);
|
|
TRACE("My AppID: %llu\n", _APPID);
|
|
TRACE("My AppID: %llu\n", _APPID);
|
|
@@ -899,6 +961,7 @@ int main(int argc, char *argv[])
|
|
g_fRun = true;
|
|
g_fRun = true;
|
|
::GfaIpcAppCtrlSetState(hAC, GIAS_Running);
|
|
::GfaIpcAppCtrlSetState(hAC, GIAS_Running);
|
|
::GfaIpcAppCtrlUpdateStorageDeviceMap(hAC, sdm);
|
|
::GfaIpcAppCtrlUpdateStorageDeviceMap(hAC, sdm);
|
|
|
|
+// _DumpDeviceMap(sdm);
|
|
}
|
|
}
|
|
while(false);
|
|
while(false);
|
|
|
|
|
|
@@ -920,7 +983,6 @@ int main(int argc, char *argv[])
|
|
if((hAI = ::GfaIpcAppCtrlInfoUpdate(hAC, wCur)))
|
|
if((hAI = ::GfaIpcAppCtrlInfoUpdate(hAC, wCur)))
|
|
{
|
|
{
|
|
_ProcessCtrlMessages(hAC, hAI);
|
|
_ProcessCtrlMessages(hAC, hAI);
|
|
-// _ProcessStateEvents(hAC, hAI);
|
|
|
|
}
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////
|
|
@@ -943,7 +1005,7 @@ int main(int argc, char *argv[])
|
|
{
|
|
{
|
|
struct udev_device* dev;
|
|
struct udev_device* dev;
|
|
|
|
|
|
- while((dev = udev_monitor_receive_device(pUdevMon)))
|
|
|
|
|
|
+ while((dev = ::udev_monitor_receive_device(pUdevMon)))
|
|
{
|
|
{
|
|
_ProcessPartition(sdm, mm, dev);
|
|
_ProcessPartition(sdm, mm, dev);
|
|
}
|
|
}
|
|
@@ -955,10 +1017,10 @@ int main(int argc, char *argv[])
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
- if(_MapChanged(sdm))
|
|
|
|
|
|
+ if(_DeviceMapChanged(sdm))
|
|
{
|
|
{
|
|
::GfaIpcAppCtrlUpdateStorageDeviceMap(hAC, sdm);
|
|
::GfaIpcAppCtrlUpdateStorageDeviceMap(hAC, sdm);
|
|
- _DumpStorageDeviceMap(sdm);
|
|
|
|
|
|
+// _DumpDeviceMap(sdm);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
@@ -979,9 +1041,9 @@ int main(int argc, char *argv[])
|
|
if(pfd[1].fd >= 0)
|
|
if(pfd[1].fd >= 0)
|
|
close(pfd[1].fd);
|
|
close(pfd[1].fd);
|
|
if(pUdevMon)
|
|
if(pUdevMon)
|
|
- udev_monitor_unref(pUdevMon);
|
|
|
|
- if(udev)
|
|
|
|
- udev_unref(udev);
|
|
|
|
|
|
+ ::udev_monitor_unref(pUdevMon);
|
|
|
|
+ if(pUdev)
|
|
|
|
+ ::udev_unref(pUdev);
|
|
|
|
|
|
if(hAC)
|
|
if(hAC)
|
|
{
|
|
{
|