Something went wrong. Try again.
Reactos
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649/* * COPYRIGHT: See COPYING in the top level directory * PROJECT: ReactOS FS utility tool * FILE: base/applications/cmdutils/fsinfo.c * PURPOSE: FSutil file systems information * PROGRAMMERS: Pierre Schweitzer <pierre@reactos.org> */
#include "fsutil.h"
/* Add handlers here for subcommands */static HandlerProc DrivesMain;static HandlerProc DriveTypeMain;static HandlerProc VolumeInfoMain;static HandlerProc NtfsInfoMain;static HandlerProc StatisticsMain;static HandlerItem HandlersList[] ={ /* Proc, name, help */ { DrivesMain, _T("drives"), _T("Enumerates the drives") }, { DriveTypeMain, _T("drivetype"), _T("Provides the type of a drive") }, { VolumeInfoMain, _T("volumeinfo"), _T("Provides informations about a volume") }, { NtfsInfoMain, _T("ntfsinfo"), _T("Displays informations about a NTFS volume") }, { StatisticsMain, _T("statistics"), _T("Displays volume statistics") },};
static intDrivesMain(int argc, const TCHAR *argv[]){ UINT i; DWORD Drives;
/* Get the drives bitmap */ Drives = GetLogicalDrives(); if (Drives == 0) { PrintErrorMessage(GetLastError()); return 1; }
/* And output any found drive */ _ftprintf(stdout, _T("Drives:")); for (i = 0; i < 26; i++) { if (Drives & (1 << i)) { _ftprintf(stdout, _T(" %c:\\"), 'A' + i); } } _ftprintf(stdout, _T("\n"));
return 0;}
static intDriveTypeMain(int argc, const TCHAR *argv[]){ UINT Type;
/* We need a volume (letter) */ if (argc < 2) { _ftprintf(stderr, _T("Usage: fsutil fsinfo drivetype <volume>\n")); _ftprintf(stderr, _T("\tFor example: fsutil fsinfo drivetype c:\n")); return 1; }
/* Get its drive type and make it readable */ Type = GetDriveType(argv[1]); switch (Type) { case DRIVE_UNKNOWN: _ftprintf(stdout, _T("%s - unknown drive type\n"), argv[1]); break;
case DRIVE_NO_ROOT_DIR: _ftprintf(stdout, _T("%s - not a root directory\n"), argv[1]); break;
case DRIVE_REMOVABLE: _ftprintf(stdout, _T("%s - removable drive\n"), argv[1]); break;
case DRIVE_FIXED: _ftprintf(stdout, _T("%s - fixed drive\n"), argv[1]); break;
case DRIVE_REMOTE: _ftprintf(stdout, _T("%s - remote or network drive\n"), argv[1]); break;
case DRIVE_CDROM: _ftprintf(stdout, _T("%s - CD-ROM drive\n"), argv[1]); break;
case DRIVE_RAMDISK: _ftprintf(stdout, _T("%s - RAM disk drive\n"), argv[1]); break; }
return 0;}
static intVolumeInfoMain(int argc, const TCHAR *argv[]){ DWORD Serial, MaxComponentLen, Flags; TCHAR VolumeName[MAX_PATH + 1], FileSystem[MAX_PATH + 1];
#define HANDLE_FLAG(Flags, Flag, Desc) \ if (Flags & Flag) \ _ftprintf(stdout, Desc)
/* We need a volume (path) */ if (argc < 2) { _ftprintf(stderr, _T("Usage: fsutil fsinfo volumeinfo <volume_path>\n")); _ftprintf(stderr, _T("\tFor example: fsutil fsinfo volumeinfo c:\\\n")); return 1; }
/* Gather information */ if (!GetVolumeInformation(argv[1], VolumeName, MAX_PATH + 1, &Serial, &MaxComponentLen, &Flags, FileSystem, MAX_PATH + 1)) { PrintErrorMessage(GetLastError()); return 1; }
/* Display general information */ _ftprintf(stdout, _T("Volume name: %s\n"), VolumeName); _ftprintf(stdout, _T("Volume serial number: 0x%x\n"), Serial); _ftprintf(stdout, _T("Maximum component length: %u\n"), MaxComponentLen); _ftprintf(stdout, _T("File system name: %s\n"), FileSystem);
/* Display specific flags */ HANDLE_FLAG(Flags, FILE_CASE_SENSITIVE_SEARCH, _T("Supports case-sensitive file names\n")); HANDLE_FLAG(Flags, FILE_CASE_PRESERVED_NAMES, _T("Supports preserved case of file names\n")); HANDLE_FLAG(Flags, FILE_UNICODE_ON_DISK, _T("Supports unicode file names\n")); HANDLE_FLAG(Flags, FILE_PERSISTENT_ACLS, _T("Preserves and applies ACLs\n")); HANDLE_FLAG(Flags, FILE_FILE_COMPRESSION, _T("Supports compression per file\n")); HANDLE_FLAG(Flags, FILE_VOLUME_QUOTAS, _T("Supports disk quotas\n")); HANDLE_FLAG(Flags, FILE_SUPPORTS_SPARSE_FILES, _T("Supports sparse files\n")); HANDLE_FLAG(Flags, FILE_SUPPORTS_REPARSE_POINTS, _T("Supports reparse points\n")); HANDLE_FLAG(Flags, FILE_VOLUME_IS_COMPRESSED, _T("Is a compressed volume\n")); HANDLE_FLAG(Flags, FILE_SUPPORTS_OBJECT_IDS, _T("Supports object identifiers\n")); HANDLE_FLAG(Flags, FILE_SUPPORTS_ENCRYPTION, _T("Supports the Encrypted File System (EFS)\n")); HANDLE_FLAG(Flags, FILE_NAMED_STREAMS, _T("Supports named streams\n")); HANDLE_FLAG(Flags, FILE_READ_ONLY_VOLUME, _T("Is a read-only volume\n")); HANDLE_FLAG(Flags, FILE_SEQUENTIAL_WRITE_ONCE, _T("Supports a single sequential write\n")); HANDLE_FLAG(Flags, FILE_SUPPORTS_TRANSACTIONS, _T("Supports transactions\n")); HANDLE_FLAG(Flags, FILE_SUPPORTS_HARD_LINKS, _T("Supports hard links\n")); HANDLE_FLAG(Flags, FILE_SUPPORTS_EXTENDED_ATTRIBUTES, _T("Supports extended attributes\n")); HANDLE_FLAG(Flags, FILE_SUPPORTS_OPEN_BY_FILE_ID, _T("Supports opening files per file identifier\n")); HANDLE_FLAG(Flags, FILE_SUPPORTS_USN_JOURNAL, _T("Supports Update Sequence Number (USN) journals\n")); HANDLE_FLAG(Flags, FILE_DAX_VOLUME, _T("Is a direct access volume\n"));
#undef HANDLE_FLAGS
return 0;}
static intNtfsInfoMain(int argc, const TCHAR *argv[]){ HANDLE Volume; DWORD BytesRead; struct { NTFS_VOLUME_DATA_BUFFER; NTFS_EXTENDED_VOLUME_DATA; } Data;
/* We need a volume (letter or GUID) */ if (argc < 2) { _ftprintf(stderr, _T("Usage: fsutil fsinfo ntfsinfo <volume>\n")); _ftprintf(stderr, _T("\tFor example: fsutil fsinfo ntfsinfo c:\n")); return 1; }
/* Get a handle for the volume */ Volume = OpenVolume(argv[1], FALSE, TRUE); if (Volume == INVALID_HANDLE_VALUE) { return 1; }
/* And query the NTFS data */ if (DeviceIoControl(Volume, FSCTL_GET_NTFS_VOLUME_DATA, NULL, 0, &Data, sizeof(Data), &BytesRead, NULL) == FALSE) { PrintErrorMessage(GetLastError()); CloseHandle(Volume); return 1; }
/* We no longer need the volume */ CloseHandle(Volume);
/* Dump data */ _ftprintf(stdout, _T("NTFS volume serial number:\t\t0x%0.16I64x\n"), Data.VolumeSerialNumber.QuadPart); /* Only print version if extended structure was returned */ if (BytesRead > sizeof(NTFS_VOLUME_DATA_BUFFER)) { _ftprintf(stdout, _T("Version:\t\t\t\t%u.%u\n"), Data.MajorVersion, Data.MinorVersion); } _ftprintf(stdout, _T("Number of sectors:\t\t\t0x%0.16I64x\n"), Data.NumberSectors.QuadPart); _ftprintf(stdout, _T("Total number of clusters:\t\t0x%0.16I64x\n"), Data.TotalClusters.QuadPart); _ftprintf(stdout, _T("Free clusters:\t\t\t\t0x%0.16I64x\n"), Data.FreeClusters.QuadPart); _ftprintf(stdout, _T("Total number of reserved clusters:\t0x%0.16I64x\n"), Data.TotalReserved.QuadPart); _ftprintf(stdout, _T("Bytes per sector:\t\t\t%d\n"), Data.BytesPerSector); _ftprintf(stdout, _T("Bytes per cluster:\t\t\t%d\n"), Data.BytesPerCluster); _ftprintf(stdout, _T("Bytes per file record segment:\t\t%d\n"), Data.BytesPerFileRecordSegment); _ftprintf(stdout, _T("Clusters per file record segment:\t%d\n"), Data.ClustersPerFileRecordSegment); _ftprintf(stdout, _T("MFT valid data length:\t\t\t0x%0.16I64x\n"), Data.MftValidDataLength.QuadPart); _ftprintf(stdout, _T("MFT start LCN:\t\t\t\t0x%0.16I64x\n"), Data.MftStartLcn.QuadPart); _ftprintf(stdout, _T("MFT2 start LCN:\t\t\t\t0x%0.16I64x\n"), Data.Mft2StartLcn.QuadPart); _ftprintf(stdout, _T("MFT zone start:\t\t\t\t0x%0.16I64x\n"), Data.MftZoneStart.QuadPart); _ftprintf(stdout, _T("MFT zone end:\t\t\t\t0x%0.16I64x\n"), Data.MftZoneEnd.QuadPart);
return 0;}
#define DUMP_VALUE(stats, value) fprintf(stdout, "%s: %lu\n", #value, stats->value)
static voidDumpBase(PFILESYSTEM_STATISTICS Base, TCHAR * Name){ /* Print FS name */ _ftprintf(stdout, _T("File system type: %s\n\n"), Name);
/* And then, dump any base stat */ DUMP_VALUE(Base, UserFileReads); DUMP_VALUE(Base, UserFileReadBytes); DUMP_VALUE(Base, UserDiskReads); DUMP_VALUE(Base, UserFileWrites); DUMP_VALUE(Base, UserFileWriteBytes); DUMP_VALUE(Base, UserDiskWrites); DUMP_VALUE(Base, MetaDataReads); DUMP_VALUE(Base, MetaDataReadBytes); DUMP_VALUE(Base, MetaDataDiskReads); DUMP_VALUE(Base, MetaDataWrites); DUMP_VALUE(Base, MetaDataWriteBytes); DUMP_VALUE(Base, MetaDataDiskWrites);
_ftprintf(stdout, _T("\n"));}
static voidDumpExFat(PVOID Statistics, PVOID Specific){ PEXFAT_STATISTICS ExFat; PFILESYSTEM_STATISTICS Base;
Base = Statistics; ExFat = Specific;
/* First, display the generic stats */ DumpBase(Base, _T("EXFAT"));
/* Then, display the EXFAT specific ones */ DUMP_VALUE(ExFat, CreateHits); DUMP_VALUE(ExFat, SuccessfulCreates); DUMP_VALUE(ExFat, FailedCreates); DUMP_VALUE(ExFat, NonCachedReads); DUMP_VALUE(ExFat, NonCachedReadBytes); DUMP_VALUE(ExFat, NonCachedWrites); DUMP_VALUE(ExFat, NonCachedWriteBytes); DUMP_VALUE(ExFat, NonCachedDiskReads); DUMP_VALUE(ExFat, NonCachedDiskWrites);}
static voidDumpFat(PVOID Statistics, PVOID Specific){ PFAT_STATISTICS Fat; PFILESYSTEM_STATISTICS Base;
Base = Statistics; Fat = Specific;
/* First, display the generic stats */ DumpBase(Base, _T("FAT"));
/* Then, display the FAT specific ones */ DUMP_VALUE(Fat, CreateHits); DUMP_VALUE(Fat, SuccessfulCreates); DUMP_VALUE(Fat, FailedCreates); DUMP_VALUE(Fat, NonCachedReads); DUMP_VALUE(Fat, NonCachedReadBytes); DUMP_VALUE(Fat, NonCachedWrites); DUMP_VALUE(Fat, NonCachedWriteBytes); DUMP_VALUE(Fat, NonCachedDiskReads); DUMP_VALUE(Fat, NonCachedDiskWrites);}
static voidDumpNtfs(PVOID Statistics, PVOID Specific){ PNTFS_STATISTICS Ntfs; PFILESYSTEM_STATISTICS Base;
Base = Statistics; Ntfs = Specific;
/* First, display the generic stats */ DumpBase(Base, _T("NTFS"));
/* Then, display the NTFS specific ones */ DUMP_VALUE(Ntfs, MftReads); DUMP_VALUE(Ntfs, MftReadBytes); DUMP_VALUE(Ntfs, MftWrites); DUMP_VALUE(Ntfs, MftWriteBytes); DUMP_VALUE(Ntfs, Mft2Writes); DUMP_VALUE(Ntfs, Mft2WriteBytes); DUMP_VALUE(Ntfs, RootIndexReads); DUMP_VALUE(Ntfs, RootIndexReadBytes); DUMP_VALUE(Ntfs, RootIndexWrites); DUMP_VALUE(Ntfs, RootIndexWriteBytes); DUMP_VALUE(Ntfs, BitmapReads); DUMP_VALUE(Ntfs, BitmapReadBytes); DUMP_VALUE(Ntfs, BitmapWrites); DUMP_VALUE(Ntfs, BitmapWriteBytes); DUMP_VALUE(Ntfs, MftBitmapReads); DUMP_VALUE(Ntfs, MftBitmapReadBytes); DUMP_VALUE(Ntfs, MftBitmapWrites); DUMP_VALUE(Ntfs, MftBitmapWriteBytes); DUMP_VALUE(Ntfs, UserIndexReads); DUMP_VALUE(Ntfs, UserIndexReadBytes); DUMP_VALUE(Ntfs, UserIndexWrites); DUMP_VALUE(Ntfs, UserIndexWriteBytes); DUMP_VALUE(Ntfs, LogFileReads); DUMP_VALUE(Ntfs, LogFileReadBytes); DUMP_VALUE(Ntfs, LogFileWrites); DUMP_VALUE(Ntfs, LogFileWriteBytes);}
#define GET_NEXT(stats, length, iter, type) (type)((ULONG_PTR)stats + (length * iter))#define SUM_VALUE(stats, new, value) stats->value += new->value
static inline intValidateSizes(ULONG Length, DWORD ProcCount, DWORD BytesRead, DWORD SpecificSize){ /* Check whether we could read our base length for every processor */ if (Length * ProcCount > BytesRead) { _ftprintf(stderr, _T("Only performed a partial read: %lu (expected: %lu)\n"), BytesRead, Length * ProcCount); return 1; }
/* Check whether this covers a specific entry and a generic entry for every processor */ if ((sizeof(FILESYSTEM_STATISTICS) + SpecificSize) * ProcCount > BytesRead) { _ftprintf(stderr, _T("Only performed a partial read: %lu (expected: %Iu)\n"), BytesRead, (sizeof(FILESYSTEM_STATISTICS) + SpecificSize)); return 1; }
return 0;}
static inline voidSumBase(PFILESYSTEM_STATISTICS Base, PFILESYSTEM_STATISTICS NextBase){ /* Sum any entry in the generic structures */ SUM_VALUE(Base, NextBase, UserFileReads); SUM_VALUE(Base, NextBase, UserFileReadBytes); SUM_VALUE(Base, NextBase, UserDiskReads); SUM_VALUE(Base, NextBase, UserFileWrites); SUM_VALUE(Base, NextBase, UserFileWriteBytes); SUM_VALUE(Base, NextBase, UserDiskWrites); SUM_VALUE(Base, NextBase, MetaDataReads); SUM_VALUE(Base, NextBase, MetaDataReadBytes); SUM_VALUE(Base, NextBase, MetaDataDiskReads); SUM_VALUE(Base, NextBase, MetaDataWrites); SUM_VALUE(Base, NextBase, MetaDataWriteBytes); SUM_VALUE(Base, NextBase, MetaDataDiskWrites);}
static intSumExFat(PVOID Statistics, PVOID Specific, ULONG Length, DWORD ProcCount, DWORD BytesRead){ DWORD i; PEXFAT_STATISTICS ExFat; PFILESYSTEM_STATISTICS Base;
/* First, validate we won't read beyond allocation */ if (ValidateSizes(Length, ProcCount, BytesRead, sizeof(EXFAT_STATISTICS))) { return 1; }
Base = Statistics; ExFat = Specific;
/* And for every processor, sum every relevant value in first entry */ for (i = 1; i < ProcCount; ++i) { PEXFAT_STATISTICS NextExFat; PFILESYSTEM_STATISTICS NextBase;
NextBase = GET_NEXT(Base, Length, i, PFILESYSTEM_STATISTICS); NextExFat = GET_NEXT(ExFat, Length, i, PEXFAT_STATISTICS);
/* Generic first */ SumBase(Base, NextBase); /* Specific then */ SUM_VALUE(ExFat, NextExFat, CreateHits); SUM_VALUE(ExFat, NextExFat, SuccessfulCreates); SUM_VALUE(ExFat, NextExFat, FailedCreates); SUM_VALUE(ExFat, NextExFat, NonCachedReads); SUM_VALUE(ExFat, NextExFat, NonCachedReadBytes); SUM_VALUE(ExFat, NextExFat, NonCachedWrites); SUM_VALUE(ExFat, NextExFat, NonCachedWriteBytes); SUM_VALUE(ExFat, NextExFat, NonCachedDiskReads); SUM_VALUE(ExFat, NextExFat, NonCachedDiskWrites); }
return 0;}
static intSumFat(PVOID Statistics, PVOID Specific, ULONG Length, DWORD ProcCount, DWORD BytesRead){ DWORD i; PFAT_STATISTICS Fat; PFILESYSTEM_STATISTICS Base;
/* First, validate we won't read beyond allocation */ if (ValidateSizes(Length, ProcCount, BytesRead, sizeof(FAT_STATISTICS))) { return 1; }
Base = Statistics; Fat = Specific;
/* And for every processor, sum every relevant value in first entry */ for (i = 1; i < ProcCount; ++i) { PFAT_STATISTICS NextFat; PFILESYSTEM_STATISTICS NextBase;
NextBase = GET_NEXT(Base, Length, i, PFILESYSTEM_STATISTICS); NextFat = GET_NEXT(Fat, Length, i, PFAT_STATISTICS);
/* Generic first */ SumBase(Base, NextBase); /* Specific then */ SUM_VALUE(Fat, NextFat, CreateHits); SUM_VALUE(Fat, NextFat, SuccessfulCreates); SUM_VALUE(Fat, NextFat, FailedCreates); SUM_VALUE(Fat, NextFat, NonCachedReads); SUM_VALUE(Fat, NextFat, NonCachedReadBytes); SUM_VALUE(Fat, NextFat, NonCachedWrites); SUM_VALUE(Fat, NextFat, NonCachedWriteBytes); SUM_VALUE(Fat, NextFat, NonCachedDiskReads); SUM_VALUE(Fat, NextFat, NonCachedDiskWrites); }
return 0;}
static intSumNtfs(PVOID Statistics, PVOID Specific, ULONG Length, DWORD ProcCount, DWORD BytesRead){ DWORD i; PNTFS_STATISTICS Ntfs; PFILESYSTEM_STATISTICS Base;
/* First, validate we won't read beyond allocation */ if (ValidateSizes(Length, ProcCount, BytesRead, sizeof(NTFS_STATISTICS))) { return 1; }
Base = Statistics; Ntfs = Specific;
/* And for every processor, sum every relevant value in first entry */ for (i = 1; i < ProcCount; ++i) { PNTFS_STATISTICS NextNtfs; PFILESYSTEM_STATISTICS NextBase;
NextBase = GET_NEXT(Base, Length, i, PFILESYSTEM_STATISTICS); NextNtfs = GET_NEXT(Ntfs, Length, i, PNTFS_STATISTICS);
/* Generic first */ SumBase(Base, NextBase); /* Specific then */ SUM_VALUE(Ntfs, NextNtfs, MftReads); SUM_VALUE(Ntfs, NextNtfs, MftReadBytes); SUM_VALUE(Ntfs, NextNtfs, MftWrites); SUM_VALUE(Ntfs, NextNtfs, MftWriteBytes); SUM_VALUE(Ntfs, NextNtfs, Mft2Writes); SUM_VALUE(Ntfs, NextNtfs, Mft2WriteBytes); SUM_VALUE(Ntfs, NextNtfs, RootIndexReads); SUM_VALUE(Ntfs, NextNtfs, RootIndexReadBytes); SUM_VALUE(Ntfs, NextNtfs, RootIndexWrites); SUM_VALUE(Ntfs, NextNtfs, RootIndexWriteBytes); SUM_VALUE(Ntfs, NextNtfs, BitmapReads); SUM_VALUE(Ntfs, NextNtfs, BitmapReadBytes); SUM_VALUE(Ntfs, NextNtfs, BitmapWrites); SUM_VALUE(Ntfs, NextNtfs, BitmapWriteBytes); SUM_VALUE(Ntfs, NextNtfs, MftBitmapReads); SUM_VALUE(Ntfs, NextNtfs, MftBitmapReadBytes); SUM_VALUE(Ntfs, NextNtfs, MftBitmapWrites); SUM_VALUE(Ntfs, NextNtfs, MftBitmapWriteBytes); SUM_VALUE(Ntfs, NextNtfs, UserIndexReads); SUM_VALUE(Ntfs, NextNtfs, UserIndexReadBytes); SUM_VALUE(Ntfs, NextNtfs, UserIndexWrites); SUM_VALUE(Ntfs, NextNtfs, UserIndexWriteBytes); SUM_VALUE(Ntfs, NextNtfs, LogFileReads); SUM_VALUE(Ntfs, NextNtfs, LogFileReadBytes); SUM_VALUE(Ntfs, NextNtfs, LogFileWrites); SUM_VALUE(Ntfs, NextNtfs, LogFileWriteBytes); }
return 0;}
static intStatisticsMain(int argc, const TCHAR *argv[]){ HANDLE Volume; SYSTEM_INFO SystemInfo; FILESYSTEM_STATISTICS Buffer; PFILESYSTEM_STATISTICS Statistics; DWORD BytesRead, Length, ProcCount; /* +1 because 0 isn't assigned to a filesystem */ void (*DumpFct[FILESYSTEM_STATISTICS_TYPE_EXFAT + 1])(PVOID, PVOID) = { NULL, DumpNtfs, DumpFat, DumpExFat }; int (*SumFct[FILESYSTEM_STATISTICS_TYPE_EXFAT + 1])(PVOID, PVOID, ULONG, DWORD, DWORD) = { NULL, SumNtfs, SumFat, SumExFat };
/* We need a volume (letter or GUID) */ if (argc < 2) { _ftprintf(stderr, _T("Usage: fsutil fsinfo statistics <volume>\n")); _ftprintf(stderr, _T("\tFor example: fsutil fsinfo statistics c:\n")); return 1; }
/* Get a handle for the volume */ Volume = OpenVolume(argv[1], FALSE, FALSE); if (Volume == INVALID_HANDLE_VALUE) { return 1; }
/* And query the statistics status - this call is expected to fail */ Statistics = &Buffer; Length = sizeof(Buffer); /* Assume we have a single proc for now */ ProcCount = 1; if (DeviceIoControl(Volume, FSCTL_FILESYSTEM_GET_STATISTICS, NULL, 0, Statistics, Length, &BytesRead, NULL) == FALSE) { DWORD Error;
/* Check we failed because we provided a too small buffer */ Error = GetLastError(); if (Error == ERROR_MORE_DATA) { /* Get proc count */ GetSystemInfo(&SystemInfo); ProcCount = SystemInfo.dwNumberOfProcessors; /* Get the maximum size to allocate: it's the total size (generic + specific) for every proc */ Length = Statistics->SizeOfCompleteStructure * ProcCount;
Statistics = LocalAlloc(LPTR, Length); if (Statistics == NULL) { _ftprintf(stderr, _T("Failed to allocate memory!\n")); CloseHandle(Volume); return 1; }
/* Reissue the FSCTL, it's supposed to succeed now! */ if (DeviceIoControl(Volume, FSCTL_FILESYSTEM_GET_STATISTICS, NULL, 0, Statistics, Length, &BytesRead, NULL) == FALSE) { PrintErrorMessage(GetLastError()); LocalFree(Statistics); CloseHandle(Volume); return 1; } } else { PrintErrorMessage(Error); CloseHandle(Volume); return 1; } }
/* No need to deal with the volume any longer */ CloseHandle(Volume);
/* We only support FAT, EXFAT and NTFS for now */ if (Statistics->FileSystemType > FILESYSTEM_STATISTICS_TYPE_EXFAT || Statistics->FileSystemType < FILESYSTEM_STATISTICS_TYPE_NTFS) { _ftprintf(stderr, _T("Unrecognized file system type: %d\n"), Statistics->FileSystemType); if (Statistics != &Buffer) { LocalFree(Statistics); }
return 1; }
/* Sum all the statistics (both generic and specific) from all the processors in the first entry */ if (SumFct[Statistics->FileSystemType](Statistics, (PVOID)((ULONG_PTR)Statistics + sizeof(FILESYSTEM_STATISTICS)), Statistics->SizeOfCompleteStructure, ProcCount, BytesRead)) { if (Statistics != &Buffer) { LocalFree(Statistics); }
return 1; }
/* And finally, display the statistics (both generic and specific) */ DumpFct[Statistics->FileSystemType](Statistics, (PVOID)((ULONG_PTR)Statistics + sizeof(FILESYSTEM_STATISTICS)));
/* If we allocated memory, release it */ if (Statistics != &Buffer) { LocalFree(Statistics); }
return 0;}
static voidPrintUsage(const TCHAR * Command){ PrintDefaultUsage(_T(" FSINFO "), Command, (HandlerItem *)&HandlersList, (sizeof(HandlersList) / sizeof(HandlersList[0])));}
intFsInfoMain(int argc, const TCHAR *argv[]){ return FindHandler(argc, argv, (HandlerItem *)&HandlersList, (sizeof(HandlersList) / sizeof(HandlersList[0])), PrintUsage);}