/* $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 #include #include #include #include #define NTOS_MODE_USER #include 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 */