📄 ntinfo.c
字号:
}
break;
}
}
return fMore;
}
// -----------------------------------------------------------------
DWORD WINAPI CommandParser (PNTL_CMD_OPTION pncoTable,
PNTL_CMD_FLAG pncfTable,
PTBYTE ptPrefixes,
PPTBYTE pptData,
DWORD dCount)
{
NTINFO_CLIENT nc = {0, 0, 0};
return NtlCommandEvaluate (pncoTable, pncfTable, ptPrefixes,
pptData, dCount,
CommandCallback, &nc);
}
// -----------------------------------------------------------------
BOOL WINAPI CommandInfo (PNTL_CMD_OPTION pncoTable,
TBYTE tPrefix,
PTBYTE ptPrefixes,
PTBYTE ptInfo,
BOOL fAlign)
{
DWORD dAlign, dOffset, dSpace, i, j, n;
BOOL fOk = FALSE;
if (pncoTable != NULL)
{
for (dAlign = n = 0; pncoTable [n].ptName != NULL; n++)
{
if ((pncoTable [n].Handler != NULL) &&
((i = lstrlen (pncoTable [n].ptName)) > dAlign))
{
dAlign = i;
}
}
if (dAlign)
{
for (dOffset = dSpace = i = 0; i < n; i++)
{
if (pncoTable [i].Handler != NULL)
{
if (!dOffset)
{
DisplayText (ptInfo, &dOffset);
dSpace = DisplayText (ptInfo, &dOffset);
}
else
{
for (j = 0; j < dSpace; j++)
{
printf (atSpace);
}
}
printf (T("%c"), tPrefix);
j = printf (pncoTable [i].ptName);
if (pncoTable [i].ptTail != NULL)
{
if (fAlign)
{
for (; j < dAlign; j++)
{
printf (atSpace);
}
}
printf (pncoTable [i].ptTail);
}
printf (atNewLine);
}
}
DisplayText (ptInfo, &dOffset);
for (i = 0; ptPrefixes [i]; i++)
{
printf (T(" '%c'"), ptPrefixes [i]);
}
DisplayText (ptInfo, &dOffset);
fOk = TRUE;
}
}
return fOk;
}
// =================================================================
// SYSTEM INFO HANDLERS
// =================================================================
BOOL WINAPI TestIds (PNTL_CMD_DATA pncd,
DWORD dIdThis,
DWORD dCount,
...)
{
DWORD i, j;
BOOL fAll;
PDWORD pdIds = &dCount + 1;
BOOL fOk = FALSE;
fAll = (pncd->dCount == 0 ) ||
(pncd->dFlags & NTL_CMD_FLAG_ALL );
fOk = (pncd->dCount == 1 ) &&
(pncd->dFlags & NTL_CMD_FLAG_THIS) &&
(dIdThis == MAXDWORD );
if ((pncd->dFlags & NTL_CMD_FLAG_THIS) && (dIdThis != MAXDWORD))
{
for (j = 0; (!fOk) && (j < dCount); j++)
{
fOk = (pdIds [j] == dIdThis);
}
}
for (i = 0; (!fOk) && (i < pncd->dCount); i++)
{
if (pncd->ancp [i].fNumeric)
{
for (j = 0; (!fOk) && (j < dCount); j++)
{
fOk = (pdIds [j] == pncd->ancp [i].dValue);
}
}
}
return (fAll ? !fOk : fOk);
}
// -----------------------------------------------------------------
BOOL WINAPI TestTag (PNTL_CMD_DATA pncd,
DWORD dTag)
{
DWORD i, j;
BOOL fAll;
BOOL fOk = FALSE;
fAll = (pncd->dCount == 0 ) ||
(pncd->dFlags & NTL_CMD_FLAG_ALL );
for (i = 0; (!fOk) && (i < pncd->dCount); i++)
{
for (j = 0; (!fOk) && (j < 4); j++)
{
if ((!pncd->ancp [i].ptValue [j])
||
((pncd->ancp [i].ptValue [j] != '?') &&
(pncd->ancp [i].ptValue [j] !=
((PBYTE) &dTag) [j])))
{
break;
}
}
fOk = (!pncd->ancp [i].ptValue [j]);
}
return (fAll ? !fOk : fOk);
}
// -----------------------------------------------------------------
DWORD WINAPI Basic (PNTL_CMD_DATA pncd)
{
SYSTEM_CONFIGURATION_INFORMATION sci;
SYSTEM_BASIC_INFORMATION sbi;
SYSTEM_DPC_INFORMATION sdpc;
SYSTEM_GLOBAL_FLAG sgf;
SYSTEM_CRASH_DUMP_INFORMATION scdi;
SYSTEM_CRASH_DUMP_STATE_INFORMATION scdsi;
SYSTEM_DEBUGGER_INFORMATION sdi;
DWORD dSize;
DisplayCommand (pncd);
dSize = SYSTEM_CONFIGURATION_INFORMATION_;
if (NtlInfoRead (&sci, &dSize, NTL_INFO_SYSTEM,
SystemConfigurationInformation, NULL)
== STATUS_SUCCESS)
{
printf (T("\r\nGlobal I/O configuration: ")
T("%lu HD, %lu FD, %lu CD, ")
T("%lu Tape, %lu COM, %lu LPT"),
sci.dDiskCount,
sci.dFloppyCount,
sci.dCDRomCount,
sci.dTapeCount,
sci.dSerialCount,
sci.dParallelCount);
}
dSize = SYSTEM_BASIC_INFORMATION_;
if (NtlInfoRead (&sbi, &dSize, NTL_INFO_SYSTEM,
SystemBasicInformation, NULL)
== STATUS_SUCCESS)
{
printf (T("\r\nPhysical address range: ")
T("0x%08lX..0x%08lX")
T("\r\nApplication address range: ")
T("0x%08lX..0x%08lX")
T("\r\nMaximum time increment: %lu (%lu Hz)"),
NtlPagesToBytes (sbi.dMmLowestPhysicalPage),
NtlPagesToBytes (sbi.dMmHighestPhysicalPage),
sbi.pLowestUserAddress,
sbi.pMmHighestUserAddress,
sbi.dKeMaximumIncrement,
(TICKS_PER_SECOND / sbi.dKeMaximumIncrement) +
(TICKS_PER_SECOND % sbi.dKeMaximumIncrement
>= sbi.dKeMaximumIncrement >> 1 ? 1 : 0));
}
dSize = SYSTEM_DPC_INFORMATION_;
if (NtlInfoRead (&sdpc, &dSize, NTL_INFO_SYSTEM,
SystemDpcInformation, NULL)
== STATUS_SUCCESS)
{
printf (T("\r\nMaximum DPC queue depth: %lu")
T("\r\nMinimum DPC rate: %lu")
T("\r\nIdeal DPC rate: %lu")
T("\r\nAdjust DPC threshold: %lu"),
sdpc.dKiMaximumDpcQueueDepth,
sdpc.dKiMinimumDpcRate,
sdpc.dKiIdealDpcRate,
sdpc.dKiAdjustDpcThreshold);
}
dSize = SYSTEM_GLOBAL_FLAG_;
if (NtlInfoRead (&sgf, &dSize, NTL_INFO_SYSTEM,
SystemGlobalFlag, NULL)
== STATUS_SUCCESS)
{
printf (T("\r\nGlobal flag: 0x%08lX"),
sgf.dNtGlobalFlag);
}
dSize = SYSTEM_CRASH_DUMP_INFORMATION_;
if (NtlInfoRead (&scdi, &dSize, NTL_INFO_SYSTEM,
SystemCrashDumpInformation, NULL)
== STATUS_SUCCESS)
{
printf (T("\r\nCrash dump section handle: 0x%08lX"),
scdi.hMmCrashDumpSection);
}
dSize = SYSTEM_CRASH_DUMP_STATE_INFORMATION_;
if (NtlInfoRead (&scdsi, &dSize, NTL_INFO_SYSTEM,
SystemCrashDumpStateInformation, NULL)
== STATUS_SUCCESS)
{
printf (T("\r\nCrash dump enabled: %s"),
(scdsi.fCrashDumpEnabled ? atYes : atNo));
}
dSize = SYSTEM_DEBUGGER_INFORMATION_;
if (NtlInfoRead (&sdi, &dSize, NTL_INFO_SYSTEM,
SystemDebuggerInformation, NULL)
== STATUS_SUCCESS)
{
printf (T("\r\nKernel debugger enabled: %s")
T("\r\nKernel debugger not present: %s"),
(sdi.bKdDebuggerEnabled ? atYes : atNo),
(sdi.bKdDebuggerNotPresent ? atYes : atNo));
}
printf (atNewLine);
return 0;
}
// -----------------------------------------------------------------
DWORD WINAPI Cpu (PNTL_CMD_DATA pncd)
{
SYSTEM_PROCESSOR_INFORMATION spi;
SYSTEM_BASIC_INFORMATION sbi;
SYSTEM_THREAD_SWITCH_INFORMATION stsi;
SYSTEM_TIME_INFORMATION sti;
PSYSTEM_PROCESSOR_COUNTERS pspc;
NTL_TABLE nt;
TIME_FIELDS tf, tfT, tfP, tfU, tfI, tfD;
PTBYTE ptProcessorArchitecture;
QWORD qTime;
DWORD dSize, i;
DisplayCommand (pncd);
dSize = SYSTEM_PROCESSOR_INFORMATION_;
if (NtlInfoRead (&spi, &dSize, NTL_INFO_SYSTEM,
SystemProcessorInformation, NULL)
== STATUS_SUCCESS)
{
switch (spi.wKeProcessorArchitecture)
{
case PROCESSOR_ARCHITECTURE_INTEL:
ptProcessorArchitecture = T("x86");
break;
case PROCESSOR_ARCHITECTURE_MIPS:
ptProcessorArchitecture = T("MIPS");
break;
case PROCESSOR_ARCHITECTURE_ALPHA:
ptProcessorArchitecture = T("ALPHA");
break;
case PROCESSOR_ARCHITECTURE_PPC:
ptProcessorArchitecture = T("PPC");
break;
default:
ptProcessorArchitecture = T("Unknown");
break;
}
printf (T("\r\nProcessor architecture: %u (%s)")
T("\r\nProcessor level: %u")
T("\r\nProcessor revision: %u.%u")
T("\r\nProcessor feature bits: 0x%08lX"),
spi.wKeProcessorArchitecture,
ptProcessorArchitecture,
spi.wKeProcessorLevel,
HIBYTE (spi.wKeProcessorRevision),
LOBYTE (spi.wKeProcessorRevision),
spi.dKeFeatureBits);
}
dSize = SYSTEM_BASIC_INFORMATION_;
if (NtlInfoRead (&sbi, &dSize, NTL_INFO_SYSTEM,
SystemBasicInformation, NULL)
== STATUS_SUCCESS)
{
printf (T("\r\nNumber of processors: %lu")
T("\r\nActive processor mask: 0x%08lX"),
sbi.bKeNumberProcessors,
sbi.dKeActiveProcessors);
}
dSize = SYSTEM_THREAD_SWITCH_INFORMATION_;
if (NtlInfoRead (&stsi, &dSize, NTL_INFO_SYSTEM,
SystemThreadSwitchInformation, NULL)
== STATUS_SUCCESS)
{
printf (T("\r\nTotal context switches: %lu"),
stsi.dTotalContextSwitches);
}
dSize = SYSTEM_TIME_INFORMATION_;
if (NtlInfoRead (&sti, &dSize, NTL_INFO_SYSTEM,
SystemTimeInformation, NULL)
== STATUS_SUCCESS)
{
NtlTimeInterval
(&sti.qKeBootTime, &sti.qKeSystemTime, &qTime, 1);
NtlTimeUnpack (&qTime, &tf);
printf (T("\r\nSystem up time: ")
T("%02u:%02u:%02u"),
tf.Hour, tf.Minute, tf.Second);
}
if (NtlTableCpu (&nt) == STATUS_SUCCESS)
{
pspc = NtlTableFirst (&nt);
for (i = 0; i < nt.dCount; i++)
{
NtlTimeUnpack (&pspc->qTotalTime, &tfT);
NtlTimeUnpack (&pspc->qProcessorTime, &tfP);
NtlTimeUnpack (&pspc->qUserTime, &tfU);
NtlTimeUnpack (&pspc->qInterruptTime, &tfI);
NtlTimeUnpack (&pspc->qDpcTime, &tfD);
printf (T("\r\n")
T("\r\nCPU #%02lu total time: ")
T("%02u:%02u:%02u")
T("\r\nCPU #%02lu processor time: ")
T("%02u:%02u:%02u")
T("\r\nCPU #%02lu user mode time: ")
T("%02u:%02u:%02u")
T("\r\nCPU #%02lu interrupt time: ")
T("%02u:%02u:%02u")
T("\r\nCPU #%02lu DPC time: ")
T("%02u:%02u:%02u")
T("\r\nCPU #%02lu interrupt count: %lu"),
i+1, tfT.Hour, tfT.Minute, tfT.Second,
i+1, tfP.Hour, tfP.Minute, tfP.Second,
i+1, tfU.Hour, tfU.Minute, tfU.Second,
i+1, tfI.Hour, tfI.Minute, tfI.Second,
i+1, tfD.Hour, tfD.Minute, tfD.Second,
i+1, pspc->dInterruptCount);
pspc = NtlTableNext (&nt, pspc);
}
NtlTableUnload (&nt);
}
printf (atNewLine);
return 0;
}
// -----------------------------------------------------------------
DWORD WINAPI Time (PNTL_CMD_DATA pncd)
{
SYSTEM_BASIC_INFORMATION sbi;
SYSTEM_TIME_INFORMATION sti;
SYSTEM_TIME_ADJUSTMENT_INFORMATION stai;
SYSTEM_TIME_ZONE_INFORMATION stzi;
SYSTEM_PERFORMANCE_INFORMATION spi;
TIME_FIELDS tf;
QWORD qBias, qTime;
DWORD dSize;
DisplayCommand (pncd);
dSize = SYSTEM_TIME_ADJUSTMENT_INFORMATION_;
if (NtlInfoRead (&stai, &dSize, NTL_INFO_SYSTEM,
SystemTimeAdjustmentInformation, NULL)
== STATUS_SUCCESS)
{
printf (T("\r\nSystem time adjustment: "));
if (stai.bKeTimeSynchronization)
{
printf (T("Disabled"));
}
else
{
printf (T("Adjustment=%lu, Increment=%lu"),
stai.TimeAdjustmentParams.dKeTimeAdjustment,
stai.TimeAdjustmentParams.dKeMaximumIncrement);
}
}
dSize = SYSTEM_BASIC_INFORMATION_;
if (NtlInfoRead (&sbi, &dSize, NTL_INFO_SYSTEM,
SystemBasicInformation, NULL)
== STATUS_SUCCESS)
{
printf (T("\r\nMaximum time increment: %lu"),
sbi.dKeMaximumIncrement);
}
dSize = SYSTEM_TIME_ZONE_INFORMATION_;
if (NtlInfoRead (&stzi, &dSize, NTL_INFO_SYSTEM,
SystemTimeZoneInformation, NULL)
== STATUS_SUCCESS)
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -