fsinfo.c File Reference

#include "fsutil.h"

Include dependency graph for fsinfo.c:

Go to the source code of this file.

Macros
#define	HANDLE_FLAG(Flags, Flag, Desc)
#define	DUMP_VALUE(stats, value)   fprintf(stdout, "%s: %lu\n", #value, stats->value)
#define	GET_NEXT(stats, length, iter, type)   (type)((ULONG_PTR)stats + (length * iter))
#define	SUM_VALUE(stats, new, value)   stats->value += new->value

Functions
static int	DrivesMain (int argc, const TCHAR *argv[])
static int	DriveTypeMain (int argc, const TCHAR *argv[])
static int	VolumeInfoMain (int argc, const TCHAR *argv[])
static int	NtfsInfoMain (int argc, const TCHAR *argv[])
static void	DumpBase (PFILESYSTEM_STATISTICS Base, TCHAR *Name)
static void	DumpExFat (PVOID Statistics, PVOID Specific)
static void	DumpFat (PVOID Statistics, PVOID Specific)
static void	DumpNtfs (PVOID Statistics, PVOID Specific)
static int	ValidateSizes (ULONG Length, DWORD ProcCount, DWORD BytesRead, DWORD SpecificSize)
static void	SumBase (PFILESYSTEM_STATISTICS Base, PFILESYSTEM_STATISTICS NextBase)
static int	SumExFat (PVOID Statistics, PVOID Specific, ULONG Length, DWORD ProcCount, DWORD BytesRead)
static int	SumFat (PVOID Statistics, PVOID Specific, ULONG Length, DWORD ProcCount, DWORD BytesRead)
static int	SumNtfs (PVOID Statistics, PVOID Specific, ULONG Length, DWORD ProcCount, DWORD BytesRead)
static int	StatisticsMain (int argc, const TCHAR *argv[])
static void	PrintUsage (const TCHAR *Command)
int	FsInfoMain (int argc, const TCHAR *argv[])

Variables
static HandlerProc	DrivesMain
static HandlerProc	DriveTypeMain
static HandlerProc	VolumeInfoMain
static HandlerProc	NtfsInfoMain
static HandlerProc	StatisticsMain
static HandlerItem	HandlersList []

Macro Definition Documentation

DUMP_VALUE

#define DUMP_VALUE	(		stats,
			value
	)		fprintf(stdout, "%s: %lu\n", #value, stats->value)

Definition at line 225 of file fsinfo.c.

GET_NEXT

#define GET_NEXT	(		stats,
			length,
			iter,
			type
	)		(type)((ULONG_PTR)stats + (length * iter))

Definition at line 339 of file fsinfo.c.

HANDLE_FLAG

#define HANDLE_FLAG	(		Flags,
			Flag,
			Desc
	)

Value:

    if (Flags & Flag)                  \
        _ftprintf(stdout, Desc)

SUM_VALUE

#define SUM_VALUE	(		stats,
			new,
			value
	)		stats->value += new->value

Definition at line 340 of file fsinfo.c.

Function Documentation

DrivesMain()

static int DrivesMain ( int  argc, const TCHAR *  argv[]  )

static

Definition at line 28 of file fsinfo.c.

{
    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;
}

DriveTypeMain()

static int DriveTypeMain ( int  argc, const TCHAR *  argv[]  )

static

Definition at line 56 of file fsinfo.c.

{
    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;
}

DumpBase()

static void DumpBase ( PFILESYSTEM_STATISTICS  Base, TCHAR *  Name  )

static

Definition at line 228 of file fsinfo.c.

{
    /* 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"));
}

Referenced by DumpExFat(), DumpFat(), and DumpNtfs().

DumpExFat()

static void DumpExFat ( PVOID  Statistics, PVOID  Specific  )

static

Definition at line 251 of file fsinfo.c.

{
    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);
}

Referenced by StatisticsMain().

DumpFat()

static void DumpFat ( PVOID  Statistics, PVOID  Specific  )

static

Definition at line 275 of file fsinfo.c.

{
    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);
}

Referenced by StatisticsMain().

DumpNtfs()

static void DumpNtfs ( PVOID  Statistics, PVOID  Specific  )

static

Definition at line 299 of file fsinfo.c.

{
    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);
}

Referenced by StatisticsMain().

FsInfoMain()

int FsInfoMain	(	int	argc,
		const TCHAR *	argv[]
	)

Definition at line 643 of file fsinfo.c.

{
    return FindHandler(argc, argv, (HandlerItem *)&HandlersList,
                       (sizeof(HandlersList) / sizeof(HandlersList[0])),
                       PrintUsage);
}

NtfsInfoMain()

static int NtfsInfoMain ( int  argc, const TCHAR *  argv[]  )

static

Definition at line 164 of file fsinfo.c.

{
    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;
}

PrintUsage()

static void PrintUsage ( const TCHAR *  Command )

static

Definition at line 636 of file fsinfo.c.

{
    PrintDefaultUsage(_T(" FSINFO "), Command, (HandlerItem *)&HandlersList,
                      (sizeof(HandlersList) / sizeof(HandlersList[0])));
}

StatisticsMain()

static int StatisticsMain ( int  argc, const TCHAR *  argv[]  )

static

Definition at line 524 of file fsinfo.c.

{
    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;
}

SumBase()

static void SumBase ( PFILESYSTEM_STATISTICS  Base, PFILESYSTEM_STATISTICS  NextBase  )

inlinestatic

Definition at line 363 of file fsinfo.c.

{
    /* 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);
}

Referenced by SumExFat(), SumFat(), and SumNtfs().

SumExFat()

static int SumExFat ( PVOID  Statistics, PVOID  Specific, ULONG  Length, DWORD  ProcCount, DWORD  BytesRead  )

static

Definition at line 381 of file fsinfo.c.

{
    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;
}

Referenced by StatisticsMain().

SumFat()

static int SumFat ( PVOID  Statistics, PVOID  Specific, ULONG  Length, DWORD  ProcCount, DWORD  BytesRead  )

static

Definition at line 423 of file fsinfo.c.

{
    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;
}

Referenced by StatisticsMain().

SumNtfs()

static int SumNtfs ( PVOID  Statistics, PVOID  Specific, ULONG  Length, DWORD  ProcCount, DWORD  BytesRead  )

static

Definition at line 465 of file fsinfo.c.

{
    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;
}

Referenced by StatisticsMain().

ValidateSizes()

static int ValidateSizes ( ULONG  Length, DWORD  ProcCount, DWORD  BytesRead, DWORD  SpecificSize  )

inlinestatic

Definition at line 343 of file fsinfo.c.

{
    /* 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;
}

Referenced by SumExFat(), SumFat(), and SumNtfs().

VolumeInfoMain()

static int VolumeInfoMain ( int  argc, const TCHAR *  argv[]  )

static

Definition at line 105 of file fsinfo.c.

{
    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;
}

Variable Documentation

DrivesMain

HandlerProc DrivesMain

static

Definition at line 12 of file fsinfo.c.

DriveTypeMain

HandlerProc DriveTypeMain

static

Definition at line 13 of file fsinfo.c.

HandlersList

HandlerItem HandlersList[]

static

Initial value:

=
{
    
    { 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") },
}

Definition at line 17 of file fsinfo.c.

Referenced by FsInfoMain(), and PrintUsage().

NtfsInfoMain

HandlerProc NtfsInfoMain

static

Definition at line 15 of file fsinfo.c.

StatisticsMain

HandlerProc StatisticsMain

static

Definition at line 16 of file fsinfo.c.

VolumeInfoMain

HandlerProc VolumeInfoMain

static

Definition at line 14 of file fsinfo.c.