mirror of
https://github.com/reactos/reactos.git
synced 2024-08-30 07:08:19 +00:00
2685 lines
52 KiB
C
2685 lines
52 KiB
C
/* $Id: qsi.c,v 1.7 2001/07/12 11:58:57 ekohl Exp $
|
|
*
|
|
* PROJECT : ReactOS Operating System (see http://www.reactos.com/)
|
|
* DESCRIPTION: Tool to query system information
|
|
* FILE : rosapps/sysutils/qsi.c
|
|
* AUTHOR : Emanuele Aliberti
|
|
* LICENSE : GNU GPL (see http://www.gnu.org/)
|
|
* DATE : 1999-07-28
|
|
*
|
|
* BUILD INSTRUCTIONS
|
|
* If you got this code directly from the CVS repository on
|
|
* mok.lcvm.com, it should be ok to run "make sqi.exe" from the
|
|
* current directory. Otherwise, be sure the directories
|
|
* "rosapps" and "reactos" are siblings (see the FILE file
|
|
* in the header).
|
|
*
|
|
* REVISIONS
|
|
* 2000-02-12 (ea)
|
|
* Partially rewritten to run as a tool to query
|
|
* every system information class data.
|
|
* 2000-04-23 (ea)
|
|
* Added almost all structures for getting system
|
|
* information (from UNDOCNT.H by Dabak et alii).
|
|
* 2001-01-13 (ea)
|
|
* New QSI class names used by E.Kohl.
|
|
*/
|
|
#include <windows.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <wchar.h>
|
|
|
|
#define NTOS_MODE_USER
|
|
#include <ntos.h>
|
|
|
|
typedef
|
|
struct _FLAGS
|
|
{
|
|
DWORD Verbose:1; /* print unknown, unused, service fields */
|
|
DWORD Dump:1; /* raw dump output buffer */
|
|
DWORD Batch:1; /* no shell (for future use) */
|
|
} FLAGS;
|
|
|
|
static
|
|
struct
|
|
{
|
|
FLAGS Flag;
|
|
BOOL Active;
|
|
HANDLE Heap;
|
|
INT ExitCode;
|
|
|
|
} Application =
|
|
{
|
|
{0, 0},
|
|
FALSE
|
|
};
|
|
|
|
#define ONOFF(b) ((b)?"on":"off")
|
|
|
|
#define ARGV_SIZE 64
|
|
|
|
#define BUFFER_SIZE_DEFAULT 65536
|
|
|
|
#define TF(b) ((b)?"true":"false")
|
|
|
|
typedef
|
|
INT (* COMMAND_CALL) (INT ArgC,LPCSTR ArgV []);
|
|
|
|
|
|
|
|
VOID STDCALL PrintStatus (NTSTATUS Status);
|
|
|
|
#define CMD_REF(n) CMD_##n
|
|
#define CMD_DEF(n) INT CMD_REF(n) (INT argc, LPCSTR argv [])
|
|
#define CMD_NOT_IMPLEMENTED {printf("%s not implemented\n", argv[0]);return(0);}
|
|
|
|
typedef
|
|
struct _COMMAND_DESCRIPTOR
|
|
{
|
|
LPCSTR Name;
|
|
COMMAND_CALL EntryPoint;
|
|
LPCSTR Description;
|
|
|
|
} COMMAND_DESCRIPTOR, * PCOMMAND_DESCRIPTOR;
|
|
|
|
|
|
/* Fast BYTE to binary representation */
|
|
|
|
#define BIT(n,m) (((n)&(m))?'1':'0')
|
|
LPSTR
|
|
STDCALL
|
|
ByteToBinaryString (
|
|
BYTE Byte,
|
|
CHAR Binary [8]
|
|
)
|
|
{
|
|
Binary [7] = BIT(Byte,0x01);
|
|
Binary [6] = BIT(Byte,0x02);
|
|
Binary [5] = BIT(Byte,0x04);
|
|
Binary [4] = BIT(Byte,0x08);
|
|
Binary [3] = BIT(Byte,0x10);
|
|
Binary [2] = BIT(Byte,0x20);
|
|
Binary [1] = BIT(Byte,0x40);
|
|
Binary [0] = BIT(Byte,0x80);
|
|
return (LPSTR) Binary;
|
|
}
|
|
|
|
/* --- */
|
|
VOID
|
|
STDCALL
|
|
DumpData (int Size, PVOID pData )
|
|
{
|
|
PBYTE Buffer = (PBYTE) pData;
|
|
PBYTE Base = Buffer;
|
|
int i;
|
|
const int Width = 16;
|
|
|
|
if (! Application.Flag.Dump)
|
|
{
|
|
return;
|
|
}
|
|
while (Size > 0)
|
|
{
|
|
printf ("%04x: ", (Buffer - Base));
|
|
for ( i = 0;
|
|
(i < Width);
|
|
++i
|
|
)
|
|
{
|
|
if (Size - i > 0)
|
|
{
|
|
printf (
|
|
"%02x%c",
|
|
Buffer[i],
|
|
(i % 4 == 3) ? '|' : ' '
|
|
);
|
|
}
|
|
else
|
|
{
|
|
printf (" ");
|
|
}
|
|
}
|
|
printf (" ");
|
|
for ( i = 0;
|
|
(i < Width);
|
|
++i
|
|
)
|
|
{
|
|
if (Size - i > 0)
|
|
{
|
|
printf (
|
|
"%c",
|
|
( (Buffer[i] > ' ')
|
|
&& (Buffer[i] < 127)
|
|
)
|
|
? Buffer[i]
|
|
: ' '
|
|
);
|
|
}
|
|
}
|
|
printf ("\n");
|
|
Buffer += Width;
|
|
Size -= Width;
|
|
}
|
|
printf ("\n");
|
|
}
|
|
|
|
/* --- */
|
|
|
|
static
|
|
LPTSTR
|
|
KernelObjectName [] =
|
|
{
|
|
_T("0"), /* FIXME */
|
|
_T("1"), /* FIXME */
|
|
_T("Directory"),
|
|
_T("SymbolicLink"),
|
|
_T("Token"),
|
|
_T("Process"),
|
|
_T("Thread"),
|
|
_T("Event"),
|
|
_T("8"), /* FIXME */
|
|
_T("Mutant"),
|
|
_T("Semaphore"),
|
|
_T("Timer"),
|
|
_T("12"), /* FIXME */
|
|
_T("WindowStation"),
|
|
_T("Desktop"),
|
|
_T("Section"),
|
|
_T("Key"),
|
|
_T("Port"),
|
|
_T("18"), /* FIXME */
|
|
_T("19"), /* FIXME */
|
|
_T("20"), /* FIXME */
|
|
_T("21"), /* FIXME */
|
|
_T("IoCompletion"),
|
|
_T("File"),
|
|
NULL
|
|
};
|
|
|
|
|
|
LPTSTR
|
|
STDCALL
|
|
HandleTypeToObjectName (
|
|
DWORD HandleType
|
|
)
|
|
{
|
|
if (HandleType > 23) /* FIXME: use a symbol not a literal */
|
|
{
|
|
return _T("Unknown");
|
|
}
|
|
return KernelObjectName [HandleType];
|
|
}
|
|
|
|
|
|
/* --- */
|
|
|
|
int
|
|
STDCALL
|
|
FindRequiredBufferSize (int i, int step)
|
|
{
|
|
NTSTATUS Status = STATUS_INFO_LENGTH_MISMATCH;
|
|
BYTE Buffer [BUFFER_SIZE_DEFAULT];
|
|
INT Size;
|
|
LONG Length = 0;
|
|
|
|
|
|
Size = step = (step > 0 ? step : 1);
|
|
while ( (Size < sizeof Buffer)
|
|
&& (Status == STATUS_INFO_LENGTH_MISMATCH)
|
|
)
|
|
{
|
|
if (Application.Flag.Verbose)
|
|
{
|
|
printf ("\tTry %d", Size);
|
|
}
|
|
RtlZeroMemory (Buffer, sizeof Buffer);
|
|
Length = 0;
|
|
Status = NtQuerySystemInformation (
|
|
i,
|
|
& Buffer,
|
|
Size,
|
|
& Length
|
|
);
|
|
if (STATUS_SUCCESS == Status)
|
|
{
|
|
printf ("Length = %d\n", Size);
|
|
return Size;
|
|
}
|
|
if (Length > 0)
|
|
{
|
|
Size = Length;
|
|
}
|
|
else
|
|
{
|
|
/* FIXME: slow linear search! */
|
|
Size += step;
|
|
}
|
|
}
|
|
printf ("No valid buffer length found!\n");
|
|
return -1;
|
|
}
|
|
|
|
|
|
VOID
|
|
STDCALL
|
|
PrintStatus (NTSTATUS Status)
|
|
{
|
|
LPCSTR StatusName = NULL;
|
|
|
|
switch (Status)
|
|
{
|
|
case STATUS_INVALID_INFO_CLASS:
|
|
StatusName = "STATUS_INVALID_INFO_CLASS";
|
|
break;
|
|
case STATUS_INFO_LENGTH_MISMATCH:
|
|
StatusName = "STATUS_INFO_LENGTH_MISMATCH";
|
|
break;
|
|
case STATUS_ACCESS_VIOLATION:
|
|
StatusName = "STATUS_ACCESS_VIOLATION";
|
|
break;
|
|
case STATUS_NOT_IMPLEMENTED:
|
|
StatusName = "STATUS_NOT_IMPLEMENTED";
|
|
break;
|
|
case STATUS_BREAKPOINT:
|
|
StatusName = "STATUS_BREAKPOINT";
|
|
break;
|
|
}
|
|
if (NULL != StatusName)
|
|
{
|
|
printf ("\tStatus = %s\n", StatusName);
|
|
return;
|
|
}
|
|
printf ("\tStatus = 0x%08lX\n", Status );
|
|
}
|
|
|
|
/* Auxiliary functions */
|
|
|
|
PCHAR
|
|
DaysOfWeek [] =
|
|
{
|
|
"Sunday",
|
|
"Monday",
|
|
"Tuesday",
|
|
"Wednesday",
|
|
"Thursday",
|
|
"Friday",
|
|
"Saturday",
|
|
"Sunday"
|
|
};
|
|
|
|
VOID
|
|
STDCALL
|
|
PrintUtcDateTime (LPCSTR Template, PTIME UtcTime)
|
|
{
|
|
CHAR UtcTimeString [64];
|
|
TIME_FIELDS UtcTimeFields;
|
|
|
|
RtlTimeToTimeFields (
|
|
(PLARGE_INTEGER) UtcTime,
|
|
& UtcTimeFields
|
|
);
|
|
sprintf (
|
|
UtcTimeString,
|
|
"%s %d-%02d-%02d %02d:%02d:%02d.%03d UTC",
|
|
DaysOfWeek[UtcTimeFields.Weekday],
|
|
UtcTimeFields.Year,
|
|
UtcTimeFields.Month,
|
|
UtcTimeFields.Day,
|
|
UtcTimeFields.Hour,
|
|
UtcTimeFields.Minute,
|
|
UtcTimeFields.Second,
|
|
UtcTimeFields.Milliseconds
|
|
);
|
|
printf (
|
|
Template,
|
|
UtcTimeString
|
|
);
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
* Dumpers
|
|
**********************************************************************/
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
* Dump whatever we get by calling NtQuerySystemInformation with
|
|
* a user provided system information class id.
|
|
* NOTE
|
|
* NtQuerySystemInformation called with user class id.
|
|
*/
|
|
CMD_DEF(unknown)
|
|
{
|
|
int _id = atoi ((char*)(argv[0] + 1)); /* "#24" */
|
|
/* ^ */
|
|
int Size = -1;
|
|
PBYTE Buffer = NULL;
|
|
NTSTATUS Status;
|
|
|
|
|
|
printf ("SystemInformation %d:\n", _id);
|
|
/* Find buffer size */
|
|
Size = FindRequiredBufferSize (_id, 1);
|
|
if (-1 == Size)
|
|
{
|
|
printf("\t(no data)\n");
|
|
return EXIT_FAILURE;
|
|
}
|
|
/* Allocate the buffer */
|
|
Buffer = GlobalAlloc (GMEM_ZEROINIT, Size);
|
|
if (NULL == Buffer)
|
|
{
|
|
printf ("#%d: could not allocate %d bytes\n", _id, Size);
|
|
return EXIT_FAILURE;
|
|
}
|
|
/* Query the executive */
|
|
Status = NtQuerySystemInformation (
|
|
_id,
|
|
Buffer,
|
|
Size,
|
|
NULL
|
|
);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
PrintStatus (Status);
|
|
FindRequiredBufferSize (_id, 1);
|
|
GlobalFree (Buffer);
|
|
return EXIT_FAILURE;
|
|
}
|
|
/* Print the data */
|
|
DumpData (Size, Buffer);
|
|
/* --- */
|
|
GlobalFree (Buffer);
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 0.
|
|
*/
|
|
CMD_DEF(0)
|
|
{
|
|
NTSTATUS Status;
|
|
SYSTEM_BASIC_INFORMATION Info;
|
|
|
|
RtlZeroMemory (
|
|
(PVOID) & Info,
|
|
sizeof Info
|
|
);
|
|
Status = NtQuerySystemInformation (
|
|
0,
|
|
& Info,
|
|
sizeof Info,
|
|
NULL
|
|
);
|
|
if (STATUS_SUCCESS != Status)
|
|
{
|
|
PrintStatus (Status);
|
|
return EXIT_FAILURE;
|
|
}
|
|
printf (" Reserved 0x%08lx\n", Info.Reserved);
|
|
printf (" TimerResolution %ld\n", Info.TimerResolution);
|
|
printf (" PageSize %ld\n", Info.PageSize);
|
|
printf (" NumberOfPhysicalPages %ld\n", Info.NumberOfPhysicalPages);
|
|
printf (" LowestPhysicalPageNumber %ld\n", Info.LowestPhysicalPageNumber);
|
|
printf (" HighestPhysicalPageNumber %ld\n", Info.HighestPhysicalPageNumber);
|
|
printf (" AllocationGranularity %ld\n", Info.AllocationGranularity);
|
|
printf (" MinimumUserModeAddress 0x%08lx (%ld)\n", Info.MinimumUserModeAddress, Info.MinimumUserModeAddress);
|
|
printf (" MaximumUserModeAddress 0x%08lx (%ld)\n", Info.MaximumUserModeAddress, Info.MaximumUserModeAddress);
|
|
printf (" ActiveProcessorsAffinityMask 0x%08lx\n", Info.ActiveProcessorsAffinityMask);
|
|
printf (" NumberOfProcessors %d\n", (int) Info.NumberOfProcessors);
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 1.
|
|
*/
|
|
CMD_DEF(1)
|
|
{
|
|
NTSTATUS Status;
|
|
SYSTEM_PROCESSOR_INFORMATION Info;
|
|
|
|
RtlZeroMemory (
|
|
(PVOID) & Info,
|
|
sizeof Info
|
|
);
|
|
Status = NtQuerySystemInformation (
|
|
1,
|
|
& Info,
|
|
sizeof Info,
|
|
NULL
|
|
);
|
|
if (STATUS_SUCCESS != Status)
|
|
{
|
|
PrintStatus (Status);
|
|
return EXIT_FAILURE;
|
|
}
|
|
printf (" ProcessorArchitecture %d\n", Info.ProcessorArchitecture);
|
|
printf (" ProcessorLevel %d\n", Info.ProcessorLevel);
|
|
printf (" ProcessorRevision %d\n", Info.ProcessorRevision);
|
|
printf (" Reserved 0x%08x\n", Info.Reserved);
|
|
printf (" FeatureBits %08lx\n", Info.ProcessorFeatureBits);
|
|
/* FIXME: decode feature bits */
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
* System performance information.
|
|
*
|
|
* NOTE
|
|
* Class 2.
|
|
*/
|
|
CMD_DEF(2)
|
|
{
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
PSYSTEM_PERFORMANCE_INFO Info;
|
|
LONG Length = 0;
|
|
|
|
|
|
Status = NtQuerySystemInformation (
|
|
2,
|
|
& Info,
|
|
sizeof Info,
|
|
& Length
|
|
);
|
|
if (STATUS_SUCCESS != Status)
|
|
{
|
|
PrintStatus (Status);
|
|
return EXIT_FAILURE;
|
|
}
|
|
printf ("Not implemented.\n");
|
|
#if 0
|
|
LARGE_INTEGER TotalProcessorTime;
|
|
LARGE_INTEGER IoReadTransferCount;
|
|
LARGE_INTEGER IoWriteTransferCount;
|
|
LARGE_INTEGER IoOtherTransferCount;
|
|
ULONG IoReadOperationCount;
|
|
ULONG IoWriteOperationCount;
|
|
ULONG IoOtherOperationCount;
|
|
ULONG MmAvailablePages;
|
|
ULONG MmTotalCommitedPages;
|
|
ULONG MmTotalCommitLimit;
|
|
ULONG MmPeakLimit;
|
|
ULONG PageFaults;
|
|
ULONG WriteCopies;
|
|
ULONG TransitionFaults;
|
|
ULONG Unknown1;
|
|
ULONG DemandZeroFaults;
|
|
ULONG PagesInput;
|
|
ULONG PagesRead;
|
|
ULONG Unknown2;
|
|
ULONG Unknown3;
|
|
ULONG PagesOutput;
|
|
ULONG PageWrites;
|
|
ULONG Unknown4;
|
|
ULONG Unknown5;
|
|
ULONG PoolPagedBytes;
|
|
ULONG PoolNonPagedBytes;
|
|
ULONG Unknown6;
|
|
ULONG Unknown7;
|
|
ULONG Unknown8;
|
|
ULONG Unknown9;
|
|
ULONG MmTotalSystemFreePtes;
|
|
ULONG MmSystemCodepage;
|
|
ULONG MmTotalSystemDriverPages;
|
|
ULONG MmTotalSystemCodePages;
|
|
ULONG Unknown10;
|
|
ULONG Unknown11;
|
|
ULONG Unknown12;
|
|
ULONG MmSystemCachePage;
|
|
ULONG MmPagedPoolPage;
|
|
ULONG MmSystemDriverPage;
|
|
ULONG CcFastReadNoWait;
|
|
ULONG CcFastReadWait;
|
|
ULONG CcFastReadResourceMiss;
|
|
ULONG CcFastReadNotPossible;
|
|
ULONG CcFastMdlReadNoWait;
|
|
ULONG CcFastMdlReadWait;
|
|
ULONG CcFastMdlReadResourceMiss;
|
|
ULONG CcFastMdlReadNotPossible;
|
|
ULONG CcMapDataNoWait;
|
|
ULONG CcMapDataWait;
|
|
ULONG CcMapDataNoWaitMiss;
|
|
ULONG CcMapDataWaitMiss;
|
|
ULONG CcPinMappedDataCount;
|
|
ULONG CcPinReadNoWait;
|
|
ULONG CcPinReadWait;
|
|
ULONG CcPinReadNoWaitMiss;
|
|
ULONG CcPinReadWaitMiss;
|
|
ULONG CcCopyReadNoWait;
|
|
ULONG CcCopyReadWait;
|
|
ULONG CcCopyReadNoWaitMiss;
|
|
ULONG CcCopyReadWaitMiss;
|
|
ULONG CcMdlReadNoWait;
|
|
ULONG CcMdlReadWait;
|
|
ULONG CcMdlReadNoWaitMiss;
|
|
ULONG CcMdlReadWaitMiss;
|
|
ULONG CcReadaheadIos;
|
|
ULONG CcLazyWriteIos;
|
|
ULONG CcLazyWritePages;
|
|
ULONG CcDataFlushes;
|
|
ULONG CcDataPages;
|
|
ULONG ContextSwitches;
|
|
ULONG Unknown13;
|
|
ULONG Unknown14;
|
|
ULONG SystemCalls;
|
|
#endif
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 3.
|
|
*/
|
|
CMD_DEF(3)
|
|
{
|
|
NTSTATUS Status;
|
|
SYSTEM_TIMEOFDAY_INFORMATION Info;
|
|
|
|
Status = NtQuerySystemInformation (
|
|
3,
|
|
& Info,
|
|
sizeof Info,
|
|
NULL
|
|
);
|
|
if (STATUS_SUCCESS != Status)
|
|
{
|
|
PrintStatus (Status);
|
|
return EXIT_FAILURE;
|
|
}
|
|
PrintUtcDateTime (" BootTime %s\n", (PTIME) & Info.BootTime);
|
|
PrintUtcDateTime (" CurrentTime %s\n", (PTIME) & Info.CurrentTime);
|
|
PrintUtcDateTime (" TimeZoneBias %s\n", (PTIME) & Info.TimeZoneBias); /* FIXME */
|
|
printf (" TimeZoneId %ld\n", Info.TimeZoneId);
|
|
printf (" Reserved %08lx\n", Info.Reserved);
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 4.
|
|
*/
|
|
CMD_DEF(4)
|
|
{
|
|
NTSTATUS Status;
|
|
SYSTEM_PATH_INFORMATION Info;
|
|
CHAR _Info [_MAX_PATH];
|
|
ULONG Length = 0;
|
|
|
|
RtlZeroMemory (& Info, _MAX_PATH);
|
|
Status = NtQuerySystemInformation (
|
|
4,
|
|
& _Info,
|
|
_MAX_PATH,
|
|
& Length
|
|
);
|
|
if (STATUS_SUCCESS != Status)
|
|
{
|
|
PrintStatus (Status);
|
|
DumpData (_MAX_PATH, & _Info);
|
|
return EXIT_FAILURE;
|
|
}
|
|
DumpData (_MAX_PATH, & _Info);
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
* A snapshot of the process+thread tables.
|
|
*
|
|
* NOTE
|
|
* Class 5.
|
|
*/
|
|
CMD_DEF(5)
|
|
{
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
PSYSTEM_PROCESS_INFORMATION pInfo = NULL;
|
|
LONG Length = 0;
|
|
ULONG ThreadIndex;
|
|
|
|
pInfo = GlobalAlloc (GMEM_ZEROINIT, BUFFER_SIZE_DEFAULT);
|
|
/* FIXME: check NULL==pInfo */
|
|
|
|
/*
|
|
* Obtain required buffer size
|
|
*/
|
|
Status = NtQuerySystemInformation (
|
|
5,
|
|
pInfo,
|
|
BUFFER_SIZE_DEFAULT,
|
|
& Length
|
|
);
|
|
if (STATUS_SUCCESS != Status)
|
|
{
|
|
if (STATUS_INFO_LENGTH_MISMATCH == Status)
|
|
{
|
|
/*
|
|
* Allocate buffer
|
|
*/
|
|
pInfo = GlobalReAlloc (pInfo, Length, GMEM_ZEROINIT);
|
|
if (NULL == pInfo)
|
|
{
|
|
printf ("\tCould not allocate memory.\n");
|
|
return EXIT_FAILURE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
PrintStatus (Status);
|
|
GlobalFree (pInfo);
|
|
return EXIT_FAILURE;
|
|
}
|
|
}
|
|
/*
|
|
* Get process+thread list from ntoskrnl.exe
|
|
*/
|
|
Status = NtQuerySystemInformation (
|
|
SystemProcessInformation,
|
|
pInfo,
|
|
Length,
|
|
& Length
|
|
);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
PrintStatus (Status);
|
|
GlobalFree (pInfo);
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
while (1)
|
|
{
|
|
wprintf (L"%s:\n", (pInfo->Name.Length ? pInfo->Name.Buffer : L"*idle*") );
|
|
if (Application.Flag.Verbose)
|
|
{
|
|
wprintf (L"\tRelativeOffset = 0x%08x\n", pInfo->RelativeOffset);
|
|
}
|
|
wprintf (L"\tThreads = %ld\n", pInfo->ThreadCount);
|
|
wprintf (L"\tHandles = %ld\n", pInfo->HandleCount);
|
|
wprintf (L"\tBasePriority = %ld\n", pInfo->BasePriority);
|
|
wprintf (L"\tPID = %ld\n", pInfo->ProcessId);
|
|
wprintf (L"\tPPID = %ld\n", pInfo->ParentProcessId);
|
|
wprintf (L"\tVirtualSize:\t\tWorkingSetSize:\n");
|
|
wprintf (L"\t\tPeak : %ld\t\t\tPeak : %ld\n",
|
|
pInfo->PeakVirtualSizeBytes,
|
|
pInfo->PeakWorkingSetSizeBytes
|
|
);
|
|
wprintf (L"\t\tTotal: %ld\t\t\tTotal: %ld\n",
|
|
pInfo->TotalVirtualSizeBytes,
|
|
pInfo->TotalWorkingSetSizeBytes
|
|
);
|
|
wprintf (L"\tPagedPoolUsage:\t\tNonPagedPoolUsage:\n");
|
|
wprintf (L"\t\tPeak : %ld\t\t\tPeak : %ld\n",
|
|
pInfo->PeakPagedPoolUsagePages,
|
|
pInfo->TotalPagedPoolUsagePages
|
|
);
|
|
wprintf (L"\t\tTotal: %ld\t\t\tTotal: %ld\n",
|
|
pInfo->PeakNonPagedPoolUsagePages,
|
|
pInfo->TotalNonPagedPoolUsagePages
|
|
);
|
|
wprintf (L"\tPageFileUsage:\n");
|
|
wprintf (L"\t\tPeak : %ld\n", pInfo->PeakPageFileUsageBytes);
|
|
wprintf (L"\t\tTotal: %ld\n", pInfo->TotalPageFileUsageBytes);
|
|
|
|
wprintf (L"\tPageFaultCount = %ld\n", pInfo->PageFaultCount);
|
|
wprintf (L"\tTotalPrivateBytes = %ld\n", pInfo->TotalPrivateBytes);
|
|
/* Threads */
|
|
for ( ThreadIndex = 0;
|
|
(ThreadIndex < pInfo->ThreadCount);
|
|
ThreadIndex ++
|
|
)
|
|
{
|
|
wprintf (L"\t%x in %x:\n",
|
|
pInfo->ThreadSysInfo[ThreadIndex].ClientId.UniqueThread,
|
|
pInfo->ThreadSysInfo[ThreadIndex].ClientId.UniqueProcess
|
|
);
|
|
PrintUtcDateTime (
|
|
"\t\tKernelTime = %s\n",
|
|
& (pInfo->ThreadSysInfo[ThreadIndex].KernelTime)
|
|
);
|
|
PrintUtcDateTime (
|
|
"\t\tUserTime = %s\n",
|
|
& (pInfo->ThreadSysInfo[ThreadIndex].UserTime)
|
|
);
|
|
PrintUtcDateTime (
|
|
"\t\tCreateTime = %s\n",
|
|
& (pInfo->ThreadSysInfo[ThreadIndex].CreateTime)
|
|
);
|
|
wprintf (L"\t\tTickCount = %ld\n",
|
|
pInfo->ThreadSysInfo[ThreadIndex].TickCount
|
|
);
|
|
wprintf (L"\t\tStartEIP = 0x%08x\n",
|
|
pInfo->ThreadSysInfo[ThreadIndex].StartEIP
|
|
);
|
|
/* CLIENT_ID ClientId; */
|
|
wprintf (L"\t\tDynamicPriority = %d\n",
|
|
pInfo->ThreadSysInfo[ThreadIndex].DynamicPriority
|
|
);
|
|
wprintf (L"\t\tBasePriority = %d\n",
|
|
pInfo->ThreadSysInfo[ThreadIndex].BasePriority
|
|
);
|
|
wprintf (L"\t\tnSwitches = %ld\n",
|
|
pInfo->ThreadSysInfo[ThreadIndex].nSwitches
|
|
);
|
|
wprintf (L"\t\tState = 0x%08x\n",
|
|
pInfo->ThreadSysInfo[ThreadIndex].State
|
|
);
|
|
wprintf (L"\t\tWaitReason = %ld\n",
|
|
pInfo->ThreadSysInfo[ThreadIndex].WaitReason
|
|
);
|
|
}
|
|
/* Next */
|
|
if (0 == pInfo->RelativeOffset)
|
|
{
|
|
break;
|
|
}
|
|
(ULONG) pInfo += pInfo->RelativeOffset;
|
|
}
|
|
|
|
DumpData (Length, pInfo);
|
|
|
|
GlobalFree (pInfo);
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 6.
|
|
*/
|
|
CMD_DEF(6)
|
|
{
|
|
NTSTATUS Status;
|
|
SYSTEM_SDT_INFORMATION Info;
|
|
ULONG Length = 0;
|
|
|
|
/* FIXME */
|
|
RtlZeroMemory (& Info, sizeof Info);
|
|
Status = NtQuerySystemInformation (
|
|
6,
|
|
& Info,
|
|
sizeof Info,
|
|
& Length
|
|
);
|
|
if (STATUS_SUCCESS != Status)
|
|
{
|
|
PrintStatus (Status);
|
|
DumpData (Length, & Info);
|
|
return EXIT_FAILURE;
|
|
}
|
|
printf (" BufferLength = %ld\n", Info.BufferLength);
|
|
printf (" NumberOfSystemServiceTables = %ld\n", Info.NumberOfSystemServiceTables);
|
|
printf (" NumberOfServices = %ld\n", Info.NumberOfServices [0]);
|
|
printf (" ServiceCounters = %ld\n", Info.ServiceCounters [0]);
|
|
|
|
DumpData (Length, & Info);
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 7.
|
|
*/
|
|
CMD_DEF(7)
|
|
{
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
SYSTEM_DEVICE_INFORMATION Info;
|
|
ULONG Length = 0;
|
|
|
|
Status = NtQuerySystemInformation (
|
|
7,
|
|
& Info,
|
|
sizeof Info,
|
|
& Length
|
|
);
|
|
if (STATUS_SUCCESS != Status)
|
|
{
|
|
PrintStatus (Status);
|
|
return EXIT_FAILURE;
|
|
}
|
|
printf (" Number Of Disks %ld\n", Info.NumberOfDisks);
|
|
printf (" Number Of Floppies %ld\n", Info.NumberOfFloppies);
|
|
printf (" Number Of CD-ROMs %ld\n", Info.NumberOfCdRoms);
|
|
printf (" Number Of Tapes %ld\n", Info.NumberOfTapes);
|
|
printf (" Number Of Serial Ports %ld\n", Info.NumberOfSerialPorts);
|
|
printf (" Number Of Parallel Ports %ld\n", Info.NumberOfParallelPorts);
|
|
|
|
DumpData (Length, & Info);
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 8.
|
|
*/
|
|
CMD_DEF(8)
|
|
{
|
|
NTSTATUS Status;
|
|
SYSTEM_PROCESSORTIME_INFO Info;
|
|
ULONG Length = 0;
|
|
|
|
Status = NtQuerySystemInformation (
|
|
8,
|
|
& Info,
|
|
sizeof Info,
|
|
& Length
|
|
);
|
|
if (STATUS_SUCCESS != Status)
|
|
{
|
|
PrintStatus (Status);
|
|
return EXIT_FAILURE;
|
|
}
|
|
PrintUtcDateTime (" TotalProcessorRunTime : %s\n", & Info.TotalProcessorRunTime);
|
|
PrintUtcDateTime (" TotalProcessorTime : %s\n", & Info.TotalProcessorTime);
|
|
PrintUtcDateTime (" TotalProcessorUserTime: %s\n", & Info.TotalProcessorUserTime);
|
|
PrintUtcDateTime (" TotalDPCTime : %s\n", & Info.TotalDPCTime);
|
|
PrintUtcDateTime (" TotalInterruptTime : %s\n", & Info.TotalInterruptTime);
|
|
printf (" TotalInterrupts : %ld\n", Info.TotalInterrupts);
|
|
printf (" Unused : %08lx\n", Info.Unused);
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 9.
|
|
*/
|
|
CMD_DEF(9)
|
|
{
|
|
NTSTATUS Status;
|
|
SYSTEM_FLAGS_INFORMATION Info;
|
|
ULONG Length = 0;
|
|
|
|
Status = NtQuerySystemInformation (
|
|
9,
|
|
& Info,
|
|
sizeof Info,
|
|
& Length
|
|
);
|
|
if (STATUS_SUCCESS != Status)
|
|
{
|
|
PrintStatus (Status);
|
|
return EXIT_FAILURE;
|
|
}
|
|
printf (" NtGlobalFlag: %08lx\n", Info.Flags);
|
|
if (FLG_STOP_ON_EXCEPTION & Info.Flags) printf ("\tSTOP_ON_EXCEPTION\n");
|
|
if (FLG_STOP_ON_HANG_GUI & Info.Flags) printf ("\tSTOP_ON_HANG_GUI\n");
|
|
if (FLG_SHOW_LDR_SNAPS & Info.Flags) printf ("\tSHOW_LDR_SNAPS\n");
|
|
if (FLG_DEBUG_INITIAL_COMMAND & Info.Flags) printf ("\tDEBUG_INITIAL_COMMAND\n");
|
|
if (FLG_HEAP_ENABLE_TAIL_CHECK & Info.Flags) printf ("\tHEAP_ENABLE_TAIL_CHECK\n");
|
|
if (FLG_HEAP_ENABLE_FREE_CHECK & Info.Flags) printf ("\tHEAP_ENABLE_FREE_CHECK\n");
|
|
if (FLG_HEAP_ENABLE_TAGGING & Info.Flags) printf ("\tHEAP_ENABLE_TAGGING\n");
|
|
if (FLG_HEAP_ENABLE_TAG_BY_DLL & Info.Flags) printf ("\tHEAP_ENABLE_TAG_BY_DLL\n");
|
|
if (FLG_HEAP_ENABLE_CALL_TRACING & Info.Flags) printf ("\tHEAP_ENABLE_CALL_TRACING\n");
|
|
if (FLG_HEAP_DISABLE_COALESCING & Info.Flags) printf ("\tHEAP_DISABLE_COALESCING\n");
|
|
if (FLG_HEAP_VALIDATE_PARAMETERS & Info.Flags) printf ("\tHEAP_VALIDATE_PARAMETERS\n");
|
|
if (FLG_HEAP_VALIDATE_ALL & Info.Flags) printf ("\tHEAP_VALIDATE_ALL\n");
|
|
if (FLG_POOL_ENABLE_TAIL_CHECK & Info.Flags) printf ("\tPOOL_ENABLE_TAIL_CHECK\n");
|
|
if (FLG_POOL_ENABLE_FREE_CHECK & Info.Flags) printf ("\tPOOL_ENABLE_FREE_CHECK\n");
|
|
if (FLG_POOL_ENABLE_TAGGING & Info.Flags) printf ("\tPOOL_ENABLE_TAGGING\n");
|
|
if (FLG_USER_STACK_TRACE_DB & Info.Flags) printf ("\tUSER_STACK_TRACE_DB\n");
|
|
if (FLG_KERNEL_STACK_TRACE_DB & Info.Flags) printf ("\tKERNEL_STACK_TRACE_DB\n");
|
|
if (FLG_MAINTAIN_OBJECT_TYPELIST & Info.Flags) printf ("\tMAINTAIN_OBJECT_TYPELIST\n");
|
|
if (FLG_IGNORE_DEBUG_PRIV & Info.Flags) printf ("\tIGNORE_DEBUG_PRIV\n");
|
|
if (FLG_ENABLE_CSRDEBUG & Info.Flags) printf ("\tENABLE_CSRDEBUG\n");
|
|
if (FLG_ENABLE_KDEBUG_SYMBOL_LOAD & Info.Flags) printf ("\tENABLE_KDEBUG_SYMBOL_LOAD\n");
|
|
if (FLG_DISABLE_PAGE_KERNEL_STACKS & Info.Flags) printf ("\tDISABLE_PAGE_KERNEL_STACKS\n");
|
|
if (FLG_ENABLE_CLOSE_EXCEPTION & Info.Flags) printf ("\tENABLE_CLOSE_EXCEPTION\n");
|
|
if (FLG_ENABLE_EXCEPTION_LOGGING & Info.Flags) printf ("\tENABLE_EXCEPTION_LOGGING\n");
|
|
if (FLG_ENABLE_DBGPRINT_BUFFERING & Info.Flags) printf ("\tENABLE_DBGPRINT_BUFFERING\n");
|
|
if (FLG_UNKNOWN_01000000 & Info.Flags) printf ("\tUNKNOWN_01000000\n");
|
|
if (FLG_UNKNOWN_02000000 & Info.Flags) printf ("\tUNKNOWN_02000000\n");
|
|
if (FLG_UNKNOWN_04000000 & Info.Flags) printf ("\tUNKNOWN_04000000\n");
|
|
if (FLG_UNKNOWN_10000000 & Info.Flags) printf ("\tUNKNOWN_10000000\n");
|
|
if (FLG_UNKNOWN_20000000 & Info.Flags) printf ("\tUNKNOWN_20000000\n");
|
|
if (FLG_UNKNOWN_40000000 & Info.Flags) printf ("\tUNKNOWN_40000000\n");
|
|
if (FLG_UNKNOWN_80000000 & Info.Flags) printf ("\tUNKNOWN_80000000\n");
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 10.
|
|
*/
|
|
CMD_DEF(10)
|
|
CMD_NOT_IMPLEMENTED
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 11.
|
|
*
|
|
* NOTE
|
|
* Code originally in Yariv Kaplan's NtDriverList,
|
|
* at http://www.internals.com/, adapted to ReactOS
|
|
* structures layout.
|
|
*/
|
|
CMD_DEF(11)
|
|
{
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
PSYSTEM_MODULE_INFORMATION pInfo = NULL;
|
|
LONG Length = 0;
|
|
INT Index;
|
|
const PCHAR hr =
|
|
"-------- -------- -------- ---------------------------------------\n";
|
|
|
|
|
|
/*
|
|
* Obtain required buffer size
|
|
*/
|
|
Status = NtQuerySystemInformation (
|
|
11,
|
|
& pInfo,
|
|
0, /* query size */
|
|
& Length
|
|
);
|
|
if (STATUS_INFO_LENGTH_MISMATCH == Status)
|
|
{
|
|
/*
|
|
* Allocate buffer
|
|
*/
|
|
pInfo = GlobalAlloc (GMEM_ZEROINIT, Length);
|
|
if (NULL == pInfo)
|
|
{
|
|
printf ("Could not allocate memory.\n");
|
|
return EXIT_FAILURE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
PrintStatus (Status);
|
|
return EXIT_FAILURE;
|
|
}
|
|
/*
|
|
* Get module list from ntoskrnl.exe
|
|
*/
|
|
Status = NtQuerySystemInformation (
|
|
11,
|
|
pInfo,
|
|
Length,
|
|
& Length
|
|
);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
PrintStatus (Status);
|
|
return EXIT_FAILURE;
|
|
}
|
|
printf ("Index Address Size Name\n");
|
|
printf (hr);
|
|
|
|
for ( Index = 0;
|
|
(Index < (int) pInfo->Count);
|
|
Index ++
|
|
)
|
|
{
|
|
printf (
|
|
"%8lx %8p %8lx %s\n",
|
|
pInfo->Module[Index].EntryIndex,
|
|
pInfo->Module[Index].BaseAddress,
|
|
pInfo->Module[Index].Size,
|
|
pInfo->Module[Index].Name
|
|
);
|
|
}
|
|
printf (hr);
|
|
|
|
GlobalFree (pInfo);
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 12.
|
|
*/
|
|
CMD_DEF(12)
|
|
{
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
PSYSTEM_RESOURCE_LOCK_INFO pInfo = NULL;
|
|
LONG Length = 0;
|
|
INT Index;
|
|
const PCHAR hr =
|
|
"-------- -------- -------- -------- -------- -------- ------------\n";
|
|
|
|
pInfo = GlobalAlloc (GMEM_ZEROINIT, BUFFER_SIZE_DEFAULT);
|
|
/* FIXME: check NULL==pInfo */
|
|
|
|
/*
|
|
* Obtain required buffer size
|
|
*/
|
|
Status = NtQuerySystemInformation (
|
|
12,
|
|
pInfo,
|
|
BUFFER_SIZE_DEFAULT, /* query size */
|
|
& Length
|
|
);
|
|
if (STATUS_SUCCESS != Status)
|
|
{
|
|
if (STATUS_INFO_LENGTH_MISMATCH == Status)
|
|
{
|
|
/*
|
|
* Allocate buffer
|
|
*/
|
|
pInfo = GlobalReAlloc (pInfo, Length, GMEM_ZEROINIT);
|
|
if (NULL == pInfo)
|
|
{
|
|
printf ("Could not allocate memory.\n");
|
|
return EXIT_FAILURE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
PrintStatus (Status);
|
|
GlobalFree (pInfo);
|
|
return EXIT_FAILURE;
|
|
}
|
|
}
|
|
/*
|
|
* Get locked resource list from ntoskrnl.exe
|
|
*/
|
|
Status = NtQuerySystemInformation (
|
|
12,
|
|
pInfo,
|
|
Length,
|
|
& Length
|
|
);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
PrintStatus (Status);
|
|
GlobalFree (pInfo);
|
|
return EXIT_FAILURE;
|
|
}
|
|
printf ("Address Active # Content# Sh/Wait Exc/Wait\n");
|
|
printf (hr);
|
|
|
|
for ( Index = 0;
|
|
(Index < (int) pInfo->Count);
|
|
Index ++
|
|
)
|
|
{
|
|
printf (
|
|
"%08lx %8ld %8ld %8ld %8ld %08lx\n",
|
|
pInfo->Lock[Index].ResourceAddress,
|
|
pInfo->Lock[Index].ActiveCount,
|
|
pInfo->Lock[Index].ContentionCount,
|
|
pInfo->Lock[Index].NumberOfSharedWaiters,
|
|
pInfo->Lock[Index].NumberOfExclusiveWaiters,
|
|
pInfo->Lock[Index].Unknown
|
|
);
|
|
}
|
|
printf (hr);
|
|
|
|
GlobalFree (pInfo);
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 13.
|
|
*/
|
|
CMD_DEF(13)
|
|
CMD_NOT_IMPLEMENTED
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 14.
|
|
*/
|
|
CMD_DEF(14)
|
|
CMD_NOT_IMPLEMENTED
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 15.
|
|
*/
|
|
CMD_DEF(15)
|
|
CMD_NOT_IMPLEMENTED
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 16. You can not pass 0 as the initial output buffer's
|
|
* size to get back the needed buffer size.
|
|
*/
|
|
CMD_DEF(16)
|
|
{
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
PSYSTEM_HANDLE_INFORMATION pInfo = NULL;
|
|
LONG Length = 0;
|
|
INT Index;
|
|
const PCHAR hr =
|
|
"-------- -------- -------- -------- -------- ----------\n";
|
|
CHAR FlagsString [9] = {0};
|
|
|
|
pInfo = GlobalAlloc (GMEM_ZEROINIT, BUFFER_SIZE_DEFAULT);
|
|
|
|
/*
|
|
* Obtain required buffer size
|
|
*/
|
|
Status = NtQuerySystemInformation (
|
|
16,
|
|
pInfo,
|
|
BUFFER_SIZE_DEFAULT,
|
|
& Length
|
|
);
|
|
if (STATUS_SUCCESS != Status)
|
|
{
|
|
if (STATUS_INFO_LENGTH_MISMATCH == Status)
|
|
{
|
|
/*
|
|
* Allocate buffer
|
|
*/
|
|
pInfo = GlobalReAlloc (pInfo, Length, GMEM_ZEROINIT);
|
|
if (NULL == pInfo)
|
|
{
|
|
printf ("\tCould not allocate memory.\n");
|
|
return EXIT_FAILURE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
PrintStatus (Status);
|
|
GlobalFree (pInfo);
|
|
return EXIT_FAILURE;
|
|
}
|
|
}
|
|
/*
|
|
* Get handle table from ntoskrnl.exe
|
|
*/
|
|
Status = NtQuerySystemInformation (
|
|
16,
|
|
pInfo,
|
|
Length,
|
|
& Length
|
|
);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
PrintStatus (Status);
|
|
GlobalFree (pInfo);
|
|
return EXIT_FAILURE;
|
|
}
|
|
printf ("Handle OwnerPID ObjPtr Access Flags Type\n");
|
|
printf (hr);
|
|
|
|
for ( Index = 0;
|
|
(Index < (int) pInfo->Count);
|
|
Index ++
|
|
)
|
|
{
|
|
printf (
|
|
"%8x %8lx %8p %8lx %s %s\n",
|
|
pInfo->Handle[Index].HandleValue,
|
|
pInfo->Handle[Index].OwnerPid,
|
|
pInfo->Handle[Index].ObjectPointer,
|
|
pInfo->Handle[Index].AccessMask,
|
|
ByteToBinaryString (
|
|
pInfo->Handle[Index].HandleFlags,
|
|
FlagsString
|
|
),
|
|
HandleTypeToObjectName (pInfo->Handle[Index].ObjectType)
|
|
);
|
|
}
|
|
printf (hr);
|
|
|
|
DumpData (Length, pInfo);
|
|
|
|
GlobalFree (pInfo);
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 17.
|
|
*/
|
|
CMD_DEF(17)
|
|
CMD_NOT_IMPLEMENTED
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 18.
|
|
*/
|
|
CMD_DEF(18)
|
|
{
|
|
NTSTATUS Status;
|
|
PSYSTEM_PAGEFILE_INFORMATION pInfo = NULL;
|
|
LONG Length = 0;
|
|
|
|
pInfo = GlobalAlloc (GMEM_ZEROINIT, BUFFER_SIZE_DEFAULT);
|
|
/* FIXME: check pInfo */
|
|
|
|
Status = NtQuerySystemInformation(
|
|
18,
|
|
pInfo,
|
|
BUFFER_SIZE_DEFAULT,
|
|
& Length
|
|
);
|
|
if (STATUS_SUCCESS != Status)
|
|
{
|
|
if (STATUS_INFO_LENGTH_MISMATCH == Status)
|
|
{
|
|
/*
|
|
* Allocate buffer
|
|
*/
|
|
pInfo = GlobalReAlloc (pInfo, Length, GMEM_ZEROINIT);
|
|
if (NULL == pInfo)
|
|
{
|
|
printf ("Could not allocate memory.\n");
|
|
return EXIT_FAILURE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
PrintStatus (Status);
|
|
GlobalFree (pInfo);
|
|
return EXIT_FAILURE;
|
|
}
|
|
}
|
|
Status = NtQuerySystemInformation (
|
|
18,
|
|
pInfo,
|
|
Length,
|
|
& Length
|
|
);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
PrintStatus (Status);
|
|
GlobalFree (pInfo);
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
while (1)
|
|
{
|
|
wprintf (L" \"%s\":\n", pInfo->PagefileFileName.Buffer);
|
|
wprintf (L"\tRelativeOffset %08x\n", pInfo->RelativeOffset);
|
|
wprintf (L"\tCurrentSizePages %ld\n", pInfo->CurrentSizePages);
|
|
wprintf (L"\tTotalUsedPages %ld\n", pInfo->TotalUsedPages);
|
|
wprintf (L"\tPeakUsedPages %ld\n", pInfo->PeakUsedPages);
|
|
|
|
if (0 == pInfo->RelativeOffset)
|
|
{
|
|
break;
|
|
}
|
|
printf ("\n");
|
|
(ULONG) pInfo += pInfo->RelativeOffset;
|
|
}
|
|
|
|
DumpData (Length, pInfo);
|
|
|
|
GlobalFree (pInfo);
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 19.
|
|
*/
|
|
CMD_DEF(19)
|
|
{
|
|
NTSTATUS Status;
|
|
SYSTEM_VDM_INFORMATION Info;
|
|
|
|
RtlZeroMemory (& Info, sizeof Info);
|
|
Status = NtQuerySystemInformation (
|
|
19,
|
|
& Info,
|
|
sizeof Info,
|
|
NULL
|
|
);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
PrintStatus (Status);
|
|
return EXIT_FAILURE;
|
|
}
|
|
printf (" VdmSegmentNotPresentCount = %ld\n", Info.VdmSegmentNotPresentCount);
|
|
printf (" VdmINSWCount = %ld\n", Info.VdmINSWCount);
|
|
printf (" VdmESPREFIXCount = %ld\n", Info.VdmESPREFIXCount);
|
|
printf (" VdmCSPREFIXCount = %ld\n", Info.VdmCSPREFIXCount);
|
|
printf (" VdmSSPREFIXCount = %ld\n", Info.VdmSSPREFIXCount);
|
|
printf (" VdmDSPREFIXCount = %ld\n", Info.VdmDSPREFIXCount);
|
|
printf (" VdmFSPREFIXCount = %ld\n", Info.VdmFSPREFIXCount);
|
|
printf (" VdmGSPREFIXCount = %ld\n", Info.VdmGSPREFIXCount);
|
|
printf (" VdmOPER32PREFIXCount = %ld\n", Info.VdmOPER32PREFIXCount);
|
|
printf (" VdmADDR32PREFIXCount = %ld\n", Info.VdmADDR32PREFIXCount);
|
|
printf (" VdmINSBCount = %ld\n", Info.VdmINSBCount);
|
|
printf (" VdmINSWV86Count = %ld\n", Info.VdmINSWV86Count);
|
|
printf (" VdmOUTSBCount = %ld\n", Info.VdmOUTSBCount);
|
|
printf (" VdmOUTSWCount = %ld\n", Info.VdmOUTSWCount);
|
|
printf (" VdmPUSHFCount = %ld\n", Info.VdmPUSHFCount);
|
|
printf (" VdmPOPFCount = %ld\n", Info.VdmPOPFCount);
|
|
printf (" VdmINTNNCount = %ld\n", Info.VdmINTNNCount);
|
|
printf (" VdmINTOCount = %ld\n", Info.VdmINTOCount);
|
|
printf (" VdmIRETCount = %ld\n", Info.VdmIRETCount);
|
|
printf (" VdmINBIMMCount = %ld\n", Info.VdmINBIMMCount);
|
|
printf (" VdmINWIMMCount = %ld\n", Info.VdmINWIMMCount);
|
|
printf (" VdmOUTBIMMCount = %ld\n", Info.VdmOUTBIMMCount);
|
|
printf (" VdmOUTWIMMCount = %ld\n", Info.VdmOUTWIMMCount);
|
|
printf (" VdmINBCount = %ld\n", Info.VdmINBCount);
|
|
printf (" VdmINWCount = %ld\n", Info.VdmINWCount);
|
|
printf (" VdmOUTBCount = %ld\n", Info.VdmOUTBCount);
|
|
printf (" VdmOUTWCount = %ld\n", Info.VdmOUTWCount);
|
|
printf (" VdmLOCKPREFIXCount = %ld\n", Info.VdmLOCKPREFIXCount);
|
|
printf (" VdmREPNEPREFIXCount = %ld\n", Info.VdmREPNEPREFIXCount);
|
|
printf (" VdmREPPREFIXCount = %ld\n", Info.VdmREPPREFIXCount);
|
|
printf (" VdmHLTCount = %ld\n", Info.VdmHLTCount);
|
|
printf (" VdmCLICount = %ld\n", Info.VdmCLICount);
|
|
printf (" VdmSTICount = %ld\n", Info.VdmSTICount);
|
|
printf (" VdmBopCount = %ld\n", Info.VdmBopCount);
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 20.
|
|
*/
|
|
CMD_DEF(20)
|
|
CMD_NOT_IMPLEMENTED
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 21.
|
|
*/
|
|
CMD_DEF(21)
|
|
{
|
|
NTSTATUS Status;
|
|
SYSTEM_CACHE_INFORMATION Si;
|
|
|
|
RtlZeroMemory (
|
|
(PVOID) & Si,
|
|
sizeof Si
|
|
);
|
|
Status = NtQuerySystemInformation (
|
|
21,
|
|
& Si,
|
|
sizeof Si,
|
|
0
|
|
);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
PrintStatus (Status);
|
|
return EXIT_FAILURE;
|
|
}
|
|
printf ("\tSize:\n");
|
|
printf ("\t\tCurrent = %ld\n", Si.CurrentSize);
|
|
printf ("\t\tPeak = %ld\n\n", Si.PeakSize);
|
|
printf ("\tPageFaults:\n\t\tCount = %ld\n\n", Si.PageFaultCount);
|
|
printf ("\tWorking Set:\n");
|
|
printf ("\t\tMinimum = %ld\n", Si.MinimumWorkingSet );
|
|
printf ("\t\tMaximum = %ld\n", Si.MaximumWorkingSet );
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
* Get statistic data about tagged pools. Not implemented in the
|
|
* free build.
|
|
*
|
|
* NOTE
|
|
* Class 22.
|
|
*/
|
|
CMD_DEF(22)
|
|
{
|
|
NTSTATUS Status;
|
|
PSYSTEM_POOL_TAG_INFO pInfo = NULL;
|
|
ULONG Length;
|
|
ULONG PoolIndex;
|
|
|
|
pInfo = GlobalAlloc (GMEM_ZEROINIT, BUFFER_SIZE_DEFAULT);
|
|
/* FIXME: check pInfo */
|
|
|
|
Status = NtQuerySystemInformation(
|
|
22,
|
|
pInfo,
|
|
BUFFER_SIZE_DEFAULT,
|
|
& Length
|
|
);
|
|
if (STATUS_SUCCESS != Status)
|
|
{
|
|
if (STATUS_INFO_LENGTH_MISMATCH == Status)
|
|
{
|
|
/*
|
|
* Allocate buffer
|
|
*/
|
|
pInfo = GlobalReAlloc (pInfo, Length, GMEM_ZEROINIT);
|
|
if (NULL == pInfo)
|
|
{
|
|
printf ("Could not allocate memory.\n");
|
|
return EXIT_FAILURE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
PrintStatus (Status);
|
|
GlobalFree (pInfo);
|
|
return EXIT_FAILURE;
|
|
}
|
|
}
|
|
Status = NtQuerySystemInformation (
|
|
22,
|
|
pInfo,
|
|
Length,
|
|
& Length
|
|
);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
PrintStatus (Status);
|
|
GlobalFree (pInfo);
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
for ( PoolIndex = 0;
|
|
(PoolIndex < pInfo->Count);
|
|
PoolIndex ++
|
|
)
|
|
{
|
|
wprintf (L"\t%08x:\n", pInfo->PoolEntry[PoolIndex].Tag);
|
|
wprintf (L"\t\tPaged:\t\tNon Paged:\n");
|
|
wprintf (
|
|
L"\t\tAllocationCount = %ld\tAllocationCount = %ld\n",
|
|
pInfo->PoolEntry[PoolIndex].Paged.AllocationCount,
|
|
pInfo->PoolEntry[PoolIndex].NonPaged.AllocationCount
|
|
);
|
|
wprintf (
|
|
L"\t\tFreeCount = %ld\tFreeCount = %ld\n",
|
|
pInfo->PoolEntry[PoolIndex].Paged.FreeCount,
|
|
pInfo->PoolEntry[PoolIndex].NonPaged.FreeCount
|
|
);
|
|
wprintf (
|
|
L"\t\tSizeBytes = %ld\tSizeBytes = %ld\n",
|
|
pInfo->PoolEntry[PoolIndex].Paged.SizeBytes,
|
|
pInfo->PoolEntry[PoolIndex].NonPaged.SizeBytes
|
|
);
|
|
}
|
|
|
|
DumpData (Length, pInfo);
|
|
|
|
GlobalFree (pInfo);
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 23.
|
|
*/
|
|
CMD_DEF(23)
|
|
{
|
|
NTSTATUS Status;
|
|
SYSTEM_PROCESSOR_SCHEDULE_INFO Info;
|
|
|
|
RtlZeroMemory (
|
|
& Info,
|
|
sizeof Info
|
|
);
|
|
Status = NtQuerySystemInformation (
|
|
23,
|
|
& Info,
|
|
sizeof Info,
|
|
NULL
|
|
);
|
|
if (STATUS_SUCCESS != Status)
|
|
{
|
|
PrintStatus (Status);
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
printf ("\tnContextSwitches = %ld\n", Info.nContextSwitches);
|
|
printf ("\tnDPCQueued = %ld\n", Info.nDPCQueued);
|
|
printf ("\tnDPCRate = %ld\n", Info.nDPCRate);
|
|
printf ("\tTimerResolution = %ld\n", Info.TimerResolution);
|
|
printf ("\tnDPCBypasses = %ld\n", Info.nDPCBypasses);
|
|
printf ("\tnAPCBypasses = %ld\n", Info.nAPCBypasses);
|
|
|
|
DumpData (sizeof Info, & Info);
|
|
|
|
return EXIT_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 24.
|
|
*/
|
|
CMD_DEF(24)
|
|
{
|
|
NTSTATUS Status;
|
|
SYSTEM_DPC_INFORMATION Info;
|
|
|
|
RtlZeroMemory (
|
|
& Info,
|
|
sizeof Info
|
|
);
|
|
Status = NtQuerySystemInformation (
|
|
24,
|
|
& Info,
|
|
sizeof Info,
|
|
NULL
|
|
);
|
|
if (STATUS_SUCCESS != Status)
|
|
{
|
|
PrintStatus (Status);
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
if (Application.Flag.Verbose)
|
|
{
|
|
printf ("\tUnused = %ld\n", Info.Unused);
|
|
}
|
|
printf ("\tKiMaximumDpcQueueDepth = %ld\n", Info.KiMaximumDpcQueueDepth);
|
|
printf ("\tKiMinimumDpcRate = %ld\n", Info.KiMinimumDpcRate);
|
|
printf ("\tKiAdjustDpcThreshold = %ld\n", Info.KiAdjustDpcThreshold);
|
|
printf ("\tKiIdealDpcRate = %ld\n", Info.KiIdealDpcRate);
|
|
|
|
DumpData (sizeof Info, & Info);
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 25.
|
|
*/
|
|
CMD_DEF(25)
|
|
CMD_NOT_IMPLEMENTED
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 26.
|
|
*/
|
|
CMD_DEF(26)
|
|
CMD_NOT_IMPLEMENTED
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 27.
|
|
*/
|
|
CMD_DEF(27)
|
|
CMD_NOT_IMPLEMENTED
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 28.
|
|
*/
|
|
CMD_DEF(28)
|
|
{
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
SYSTEM_QUERY_TIME_ADJUSTMENT Info;
|
|
|
|
RtlZeroMemory (& Info, sizeof Info);
|
|
Status = NtQuerySystemInformation (
|
|
28,
|
|
& Info,
|
|
sizeof Info,
|
|
0
|
|
);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
PrintStatus (Status);
|
|
return EXIT_FAILURE;
|
|
}
|
|
printf ("\tKeTimeAdjustment = %ld\n", Info.TimeAdjustment);
|
|
printf ("\tKeMaximumIncrement = %ld\n", Info.MaximumIncrement);
|
|
printf ("\tKeTimeSynchronization = %s\n", TF(Info.TimeSynchronization));
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 29.
|
|
*/
|
|
CMD_DEF(29)
|
|
CMD_NOT_IMPLEMENTED
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 30.
|
|
*/
|
|
CMD_DEF(30)
|
|
CMD_NOT_IMPLEMENTED
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 31.
|
|
*/
|
|
CMD_DEF(31)
|
|
CMD_NOT_IMPLEMENTED
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 32.
|
|
*/
|
|
CMD_DEF(32)
|
|
CMD_NOT_IMPLEMENTED
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 33.
|
|
*/
|
|
CMD_DEF(33)
|
|
CMD_NOT_IMPLEMENTED
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 34.
|
|
*/
|
|
CMD_DEF(34)
|
|
CMD_NOT_IMPLEMENTED
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 35.
|
|
*/
|
|
CMD_DEF(35)
|
|
{
|
|
NTSTATUS Status;
|
|
SYSTEM_DEBUGGER_INFO Info;
|
|
|
|
RtlZeroMemory (& Info, sizeof Info);
|
|
Status = NtQuerySystemInformation (
|
|
35,
|
|
& Info,
|
|
sizeof Info,
|
|
NULL
|
|
);
|
|
if (STATUS_SUCCESS != Status)
|
|
{
|
|
PrintStatus (Status);
|
|
return EXIT_FAILURE;
|
|
}
|
|
printf ("\tKdDebuggerEnabled = %s\n", TF(Info.KdDebuggerEnabled));
|
|
printf ("\tKdDebuggerPresent = %s\n", TF(Info.KdDebuggerPresent));
|
|
|
|
DumpData (sizeof Info, & Info);
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 36.
|
|
*/
|
|
CMD_DEF(36)
|
|
CMD_NOT_IMPLEMENTED
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 37.
|
|
*/
|
|
CMD_DEF(37)
|
|
{
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
SYSTEM_QUOTA_INFORMATION Info;
|
|
|
|
RtlZeroMemory (& Info, sizeof Info);
|
|
Status = NtQuerySystemInformation (
|
|
37,
|
|
& Info,
|
|
sizeof Info,
|
|
0
|
|
);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
PrintStatus (Status);
|
|
return EXIT_FAILURE;
|
|
}
|
|
printf ("\tCmpGlobalQuota = %ld\n", Info.CmpGlobalQuota);
|
|
printf ("\tCmpGlobalQuotaUsed = %ld\n", Info.CmpGlobalQuotaUsed);
|
|
printf ("\tMmSizeofPagedPoolInBytes = %ld\n", Info.MmSizeofPagedPoolInBytes);
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 38.
|
|
*/
|
|
CMD_DEF(38)
|
|
CMD_NOT_IMPLEMENTED
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 39.
|
|
*/
|
|
CMD_DEF(39)
|
|
CMD_NOT_IMPLEMENTED
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 40.
|
|
*/
|
|
CMD_DEF(40)
|
|
CMD_NOT_IMPLEMENTED
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 41.
|
|
*/
|
|
CMD_DEF(41)
|
|
CMD_NOT_IMPLEMENTED
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 42.
|
|
*/
|
|
CMD_DEF(42)
|
|
CMD_NOT_IMPLEMENTED
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 43.
|
|
*/
|
|
CMD_DEF(43)
|
|
CMD_NOT_IMPLEMENTED
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
* Dump the system TIME_ZONE_INFORMATION object.
|
|
*
|
|
* NOTE
|
|
* Class 44.
|
|
*/
|
|
CMD_DEF(44)
|
|
{
|
|
NTSTATUS Status;
|
|
SYSTEM_TIME_ZONE_INFORMATION Tzi;
|
|
WCHAR Name [33];
|
|
|
|
RtlZeroMemory (& Tzi, sizeof Tzi);
|
|
Status = NtQuerySystemInformation(
|
|
44,
|
|
& Tzi,
|
|
sizeof Tzi,
|
|
0
|
|
);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
PrintStatus (Status);
|
|
return EXIT_FAILURE;
|
|
}
|
|
printf (
|
|
" Bias........: %ld'\n",
|
|
Tzi.Bias /* LONG */
|
|
);
|
|
|
|
printf (" Standard\n");
|
|
RtlZeroMemory (
|
|
(PVOID) Name,
|
|
sizeof Name
|
|
);
|
|
lstrcpynW (
|
|
Name,
|
|
Tzi.StandardName, /* WCHAR [32] */
|
|
32
|
|
);
|
|
wprintf (
|
|
L"\tName: \"%s\"\n",
|
|
Name
|
|
);
|
|
|
|
PrintUtcDateTime (
|
|
"\tDate: %s\n",
|
|
(PTIME) & Tzi.StandardDate /* SYSTEMTIME */
|
|
);
|
|
|
|
printf ("\tBias: %ld'\n",
|
|
Tzi.StandardBias /* LONG */
|
|
);
|
|
|
|
printf (" Daylight\n");
|
|
RtlZeroMemory (
|
|
(PVOID) Name,
|
|
sizeof Name
|
|
);
|
|
lstrcpynW (
|
|
Name,
|
|
Tzi.DaylightName, /* WCHAR [32] */
|
|
32
|
|
);
|
|
wprintf (
|
|
L"\tName: \"%s\"\n",
|
|
Name
|
|
);
|
|
|
|
PrintUtcDateTime (
|
|
"\tDate: %s\n",
|
|
(PTIME) & Tzi.DaylightDate /* SYSTEMTIME */
|
|
);
|
|
|
|
printf (
|
|
"\tBias: %ld'\n",
|
|
Tzi.DaylightBias /* LONG */
|
|
);
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 45.
|
|
*/
|
|
CMD_DEF(45)
|
|
CMD_NOT_IMPLEMENTED
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 46.
|
|
*/
|
|
CMD_DEF(46)
|
|
CMD_NOT_IMPLEMENTED
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 47.
|
|
*/
|
|
CMD_DEF(47)
|
|
CMD_NOT_IMPLEMENTED
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 48.
|
|
*/
|
|
CMD_DEF(48)
|
|
CMD_NOT_IMPLEMENTED
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 49.
|
|
*/
|
|
CMD_DEF(49)
|
|
CMD_NOT_IMPLEMENTED
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 50.
|
|
*/
|
|
CMD_DEF(50)
|
|
CMD_NOT_IMPLEMENTED
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 51.
|
|
*/
|
|
CMD_DEF(51)
|
|
CMD_NOT_IMPLEMENTED
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 52.
|
|
*/
|
|
CMD_DEF(52)
|
|
CMD_NOT_IMPLEMENTED
|
|
|
|
|
|
/**********************************************************************
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* NOTE
|
|
* Class 53.
|
|
*/
|
|
CMD_DEF(53)
|
|
CMD_NOT_IMPLEMENTED
|
|
|
|
|
|
/**********************************************************************
|
|
* Miscellanea Commands
|
|
**********************************************************************/
|
|
|
|
CMD_DEF(ver)
|
|
{
|
|
INT Total = 0;
|
|
|
|
Total =
|
|
printf (
|
|
"ReactOS Operating System - http://www.reactos.com/\n"
|
|
"QSI - Query System Information (compiled on %s, %s)\n"
|
|
"Copyright (c) 1999-2001 Emanuele Aliberti et alii\n\n"
|
|
"Run the command in verbose mode, for full license information.\n\n",
|
|
__DATE__, __TIME__
|
|
);
|
|
|
|
if (Application.Flag.Verbose)
|
|
{
|
|
Total +=
|
|
printf (
|
|
"This program is free software; you can redistribute it and/or modify\n"
|
|
"it under the terms of the GNU General Public License as published by\n"
|
|
"the Free Software Foundation; either version 2 of the License, or\n"
|
|
"(at your option) any later version.\n\n"
|
|
|
|
"This program is distributed in the hope that it will be useful,\n"
|
|
"but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
|
|
"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
|
|
"GNU General Public License for more details.\n\n"
|
|
|
|
"You should have received a copy of the GNU General Public License\n"
|
|
"along with this program; if not, write to the Free Software\n"
|
|
"Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\n"
|
|
"(See also http://www.fsf.org/).\n"
|
|
);
|
|
}
|
|
return (Total);
|
|
}
|
|
|
|
|
|
CMD_DEF(exit)
|
|
{
|
|
Application.Active = FALSE;
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
extern COMMAND_DESCRIPTOR Commands [];
|
|
|
|
CMD_DEF(help)
|
|
{
|
|
int i;
|
|
|
|
if (Application.Flag.Verbose)
|
|
{
|
|
printf ("Commands:\n");
|
|
}
|
|
for ( i = 0;
|
|
(NULL != Commands[i].Name);
|
|
i ++
|
|
)
|
|
{
|
|
printf (
|
|
(strlen (Commands[i].Name) > 7)
|
|
? "%s\t: %s\n"
|
|
: "%s\t\t: %s\n",
|
|
Commands[i].Name,
|
|
Commands[i].Description
|
|
);
|
|
}
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
CMD_DEF(credits)
|
|
{
|
|
return
|
|
printf (
|
|
"\nReactOS (http://www.reactos.com/):\n"
|
|
"\tEmanuele Aliberti\n"
|
|
"\tEric Kohl\n\n"
|
|
|
|
"HandleEx:\n"
|
|
"\tMark Russinovich (http://www.sysinternals.com/)\n\n"
|
|
|
|
"NtDriverList:\n"
|
|
"\tYariv Kaplan (http://www.internals.com/)\n\n"
|
|
|
|
"Undocumented SYSTEM_POOL_INFORMATION:\n"
|
|
"\tKlaus P. Gerlicher\n\n"
|
|
|
|
"Undocumented Windows NT:\n"
|
|
"\tPrasad Dabak, Sandeep Phadke, and Milind Borate\n\n"
|
|
|
|
"Windows NT/2000 Native API Reference:\n"
|
|
"\tGary Nebbett\n\n"
|
|
|
|
"comp.os.ms-windows.programmer.nt.kernel-mode\n"
|
|
"\t(many postings with sample code)\n"
|
|
);
|
|
}
|
|
|
|
|
|
CMD_DEF(verbose)
|
|
{
|
|
Application.Flag.Verbose = ~Application.Flag.Verbose;
|
|
return printf (
|
|
"Verbose mode is %s.\n",
|
|
ONOFF(Application.Flag.Verbose)
|
|
);
|
|
}
|
|
|
|
|
|
CMD_DEF(dump)
|
|
{
|
|
Application.Flag.Dump = ~Application.Flag.Dump;
|
|
return printf (
|
|
"Dump mode is %s.\n",
|
|
ONOFF(Application.Flag.Dump)
|
|
);
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
* Commands table
|
|
**********************************************************************/
|
|
|
|
COMMAND_DESCRIPTOR
|
|
Commands [] =
|
|
{
|
|
/* System information classes */
|
|
|
|
{ /* 0 Q */
|
|
"basic",
|
|
CMD_REF(0),
|
|
"Basic system information"
|
|
},
|
|
{ /* 1 Q */
|
|
"processor",
|
|
CMD_REF(1),
|
|
"Processor characteristics"
|
|
},
|
|
{ /* 2 Q */
|
|
"perf",
|
|
CMD_REF(2),
|
|
"System performance data"
|
|
},
|
|
{ /* 3 Q */
|
|
"time",
|
|
CMD_REF(3),
|
|
"System times"
|
|
},
|
|
{ /* 4 Q (checked build only) */
|
|
"path",
|
|
CMD_REF(4),
|
|
"Path (checked build only)"
|
|
},
|
|
{ /* 5 Q */
|
|
"process",
|
|
CMD_REF(5),
|
|
"Process & thread tables"
|
|
},
|
|
{ /* 6 Q */
|
|
"callcount",
|
|
CMD_REF(6),
|
|
"Call count information"
|
|
},
|
|
{ /* 7 Q */
|
|
"device",
|
|
CMD_REF(7),
|
|
"I/O devices in the system, by class"
|
|
},
|
|
{ /* 8 Q */
|
|
"performance",
|
|
CMD_REF(8),
|
|
"Processor performance"
|
|
},
|
|
{ /* 9 QS */
|
|
"flags",
|
|
CMD_REF(9),
|
|
"System wide flags"
|
|
},
|
|
{ /* 10 */
|
|
"call",
|
|
CMD_REF(10),
|
|
"Call time"
|
|
},
|
|
{ /* 11 Q */
|
|
"module",
|
|
CMD_REF(11),
|
|
"Table of kernel modules"
|
|
},
|
|
{ /* 12 Q */
|
|
"locks",
|
|
CMD_REF(12),
|
|
"Table of locks on resources"
|
|
},
|
|
{ /* 13 */
|
|
"stack",
|
|
CMD_REF(13),
|
|
"Stack trace"
|
|
},
|
|
{ /* 14 */
|
|
"ppool",
|
|
CMD_REF(14),
|
|
"Paged pool"
|
|
},
|
|
{ /* 15 */
|
|
"nppool",
|
|
CMD_REF(15),
|
|
"Non paged pool"
|
|
},
|
|
{ /* 16 Q */
|
|
"handle",
|
|
CMD_REF(16),
|
|
"Table of handles"
|
|
},
|
|
{ /* 17 Q */
|
|
"object",
|
|
CMD_REF(17),
|
|
"Table of executive objects"
|
|
},
|
|
{ /* 18 Q */
|
|
"pagefile",
|
|
CMD_REF(18),
|
|
"Virtual memory paging files"
|
|
},
|
|
{ /* 19 Q */
|
|
"vdmie",
|
|
CMD_REF(19),
|
|
"Virtual DOS Machine instruction emulation (VDM)"
|
|
},
|
|
{ /* 20 */
|
|
"vdmbop",
|
|
CMD_REF(20),
|
|
"Bop (VDM)"
|
|
},
|
|
{ /* 21 QS */
|
|
"cache",
|
|
CMD_REF(21),
|
|
"File cache"
|
|
},
|
|
{ /* 22 Q */
|
|
"pooltag",
|
|
CMD_REF(22),
|
|
"Tagged pools statistics (checked build only)"
|
|
},
|
|
{ /* 23 Q */
|
|
"int",
|
|
CMD_REF(23),
|
|
"Processor schedule information (interrupt)"
|
|
},
|
|
{ /* 24 QS */
|
|
"dpc",
|
|
CMD_REF(24),
|
|
"Deferred procedure call behaviour (DPC)"
|
|
},
|
|
{ /* 25 */
|
|
"fullmem",
|
|
CMD_REF(25),
|
|
"Full memory"
|
|
},
|
|
{ /* 26 S (callable) */
|
|
"loadpe",
|
|
CMD_REF(26),
|
|
"Load a kernel mode DLL (module in PE format)"
|
|
},
|
|
{ /* 27 S (callable) */
|
|
"unloadpe",
|
|
CMD_REF(27),
|
|
"Unload a kernel mode DLL (module in Pe format)"
|
|
},
|
|
{ /* 28 QS */
|
|
"timeadj",
|
|
CMD_REF(28),
|
|
"Time adjustment"
|
|
},
|
|
{ /* 29 */
|
|
"smem",
|
|
CMD_REF(29),
|
|
"Summary memory"
|
|
},
|
|
{ /* 30 */
|
|
"event",
|
|
CMD_REF(30),
|
|
"Next event ID"
|
|
},
|
|
{ /* 31 */
|
|
"events",
|
|
CMD_REF(31),
|
|
"Event IDs"
|
|
},
|
|
{ /* 32 Q */
|
|
"crash",
|
|
CMD_REF(32),
|
|
"Crash Dump Section"
|
|
},
|
|
{ /* 33 Q */
|
|
"exceptions",
|
|
CMD_REF(33),
|
|
"Exceptions"
|
|
},
|
|
{ /* 34 Q */
|
|
"crashstate",
|
|
CMD_REF(34),
|
|
"Crash Dump State"
|
|
},
|
|
{ /* 35 Q */
|
|
"debugger",
|
|
CMD_REF(35),
|
|
"Kernel debugger"
|
|
},
|
|
{ /* 36 Q */
|
|
"cswitch",
|
|
CMD_REF(36),
|
|
"Thread context switch counters"
|
|
},
|
|
{ /* 37 QS */
|
|
"regquota",
|
|
CMD_REF(37),
|
|
"Registry quota values"
|
|
},
|
|
{ /* 38 S */
|
|
"est",
|
|
CMD_REF(38),
|
|
"Extended service table"
|
|
},
|
|
{ /* 39 S */
|
|
"prisep",
|
|
CMD_REF(39),
|
|
"Priority Separation"
|
|
},
|
|
{ /* 40 */
|
|
"ppbus",
|
|
CMD_REF(40),
|
|
"Plug & play bus"
|
|
},
|
|
{ /* 41 */
|
|
"dock",
|
|
CMD_REF(41),
|
|
"Dock"
|
|
},
|
|
{ /* 42 */
|
|
"power",
|
|
CMD_REF(42),
|
|
"Power"
|
|
},
|
|
{ /* 43 */
|
|
"procspeed",
|
|
CMD_REF(43),
|
|
"Processor speed"
|
|
},
|
|
{ /* 44 QS */
|
|
"tz",
|
|
CMD_REF(44),
|
|
"Current time zone (TZ)"
|
|
},
|
|
{ /* 45 Q */
|
|
"lookaside",
|
|
CMD_REF(45),
|
|
"Lookaside"
|
|
},
|
|
/* NT5 */
|
|
{ /* 46 Q */
|
|
"tslip",
|
|
CMD_REF(46),
|
|
"Set time slip (5.0)"
|
|
},
|
|
{ /* 47 Q */
|
|
"csession",
|
|
CMD_REF(47),
|
|
"Create session (5.0)"
|
|
},
|
|
{ /* 48 Q */
|
|
"dsession",
|
|
CMD_REF(48),
|
|
"Delete session (5.0)"
|
|
},
|
|
{ /* 49 Q */
|
|
"#49",
|
|
CMD_REF(49),
|
|
"UNKNOWN (5.0)"
|
|
},
|
|
{ /* 50 Q */
|
|
"range",
|
|
CMD_REF(50),
|
|
"Range start (5.0)"
|
|
},
|
|
{ /* 51 Q */
|
|
"verifier",
|
|
CMD_REF(51),
|
|
"Verifier (5.0)"
|
|
},
|
|
{ /* 52 Q */
|
|
"addverif",
|
|
CMD_REF(52),
|
|
"Add verifier (5.0)"
|
|
},
|
|
{ /* 53 Q */
|
|
"sesproc",
|
|
CMD_REF(53),
|
|
"Session processes (5.0)"
|
|
},
|
|
/* User commands */
|
|
{
|
|
"?",
|
|
CMD_REF(help),
|
|
"Same as 'help'"
|
|
},
|
|
{
|
|
"help",
|
|
CMD_REF(help),
|
|
"Print this command directory"
|
|
},
|
|
{
|
|
"credits",
|
|
CMD_REF(credits),
|
|
"Print the list of people and sources that made QSI possible"
|
|
},
|
|
{
|
|
"ver",
|
|
CMD_REF(ver),
|
|
"Print version number and license information"
|
|
},
|
|
{
|
|
"exit",
|
|
CMD_REF(exit),
|
|
"Exit to operating system"
|
|
},
|
|
{
|
|
"dump",
|
|
CMD_REF(dump),
|
|
"Enable/disable dumping raw data returned by system"
|
|
},
|
|
{
|
|
"verbose",
|
|
CMD_REF(verbose),
|
|
"Enable/disable printing unused, unknown, and service fields"
|
|
},
|
|
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
|
|
|
|
/* user input --> command decoder */
|
|
|
|
|
|
COMMAND_CALL
|
|
DecodeCommand (LPCSTR Command)
|
|
{
|
|
int i;
|
|
|
|
for ( i = 0;
|
|
( Commands[i].Name
|
|
&& stricmp (Commands[i].Name,Command)
|
|
);
|
|
++i
|
|
);
|
|
return Commands[i].EntryPoint;
|
|
}
|
|
|
|
INT
|
|
ParseCommandLine (
|
|
LPCSTR CommandLine,
|
|
LPCSTR CommandArgv []
|
|
)
|
|
{
|
|
INT ArgC = 0;
|
|
LPCSTR Separators = " \t";
|
|
|
|
for ( CommandArgv [ArgC] = strtok ((char*)CommandLine, (char*)Separators);
|
|
(ArgC < ARGV_SIZE);
|
|
CommandArgv [ArgC] = (LPCSTR) strtok (NULL, (char*)Separators)
|
|
)
|
|
{
|
|
if (NULL == CommandArgv [ArgC++])
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
return (ArgC);
|
|
}
|
|
|
|
|
|
int
|
|
main (int argc, char * argv [])
|
|
{
|
|
CHAR CommandLine [_MAX_PATH];
|
|
|
|
INT CommandArgc;
|
|
LPCSTR CommandArgv [ARGV_SIZE];
|
|
|
|
/*
|
|
* Initialize rt data.
|
|
*/
|
|
Application.Heap = GetProcessHeap ();
|
|
Application.Active = TRUE;
|
|
/*
|
|
* r-e-p loop.
|
|
*/
|
|
while (Application.Active)
|
|
{
|
|
/* Print the prompt string. */
|
|
if (! Application.Flag.Batch)
|
|
{
|
|
printf ("\r\nsystem> ");
|
|
}
|
|
/* Read user command. */
|
|
gets (CommandLine);
|
|
/* Parse the user command */
|
|
CommandArgc = ParseCommandLine (
|
|
CommandLine,
|
|
CommandArgv
|
|
);
|
|
if (0 != CommandArgc)
|
|
{
|
|
COMMAND_CALL CommandCall = NULL;
|
|
|
|
/* decode */
|
|
if ((CommandCall = DecodeCommand (CommandArgv[0])))
|
|
{
|
|
/* execute */
|
|
Application.ExitCode =
|
|
CommandCall (
|
|
CommandArgc,
|
|
CommandArgv
|
|
);
|
|
}
|
|
else
|
|
{
|
|
printf ("Unknown command (type help for a list of valid commands).\n");
|
|
}
|
|
}
|
|
|
|
}
|
|
if (! Application.Flag.Batch)
|
|
{
|
|
printf ("Bye\n");
|
|
}
|
|
return (EXIT_SUCCESS);
|
|
}
|
|
|
|
/* EOF */
|