Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-12-27 01:24:38 +00:00
Code Issues Projects Releases Packages Wiki Activity

- don't redefine public structures in taskmgr

Browse source 
- minor taskmgr changes and make better use of PCH
- fixed definition of SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION and depending code

svn path=/trunk/; revision=14536
This commit is contained in:
Thomas Bluemel 2005-04-07 13:25:34 +00:00
parent b995b11c1d
commit 2acf2098b8
31 changed files with 141 additions and 623 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
reactos/include/ntos/zwtypes.h
View file

@ -1401,17 +1401,17 @@ struct _SYSTEM_DEVICE_INFORMATION
// SystemProcessorPerformanceInformation (8)
// (one per processor in the system)
typedef
struct _SYSTEM_PROCESSORTIME_INFO
struct _SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION
{
TIME TotalProcessorRunTime;
TIME TotalProcessorTime;
TIME TotalProcessorUserTime;
TIME TotalDPCTime;
TIME TotalInterruptTime;
ULONG TotalInterrupts;
ULONG Unused;
LARGE_INTEGER IdleTime;
LARGE_INTEGER KernelTime;
LARGE_INTEGER UserTime;
LARGE_INTEGER DpcTime;
LARGE_INTEGER InterruptTime;
ULONG InterruptCount;
ULONG Reserved;
} SYSTEM_PROCESSORTIME_INFO, *PSYSTEM_PROCESSORTIME_INFO;
} SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION, *PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION;
// SystemFlagsInformation (9)
typedef

18
reactos/lib/kernel32/misc/time.c
View file

@ -500,12 +500,12 @@ GetSystemTimes(
LPFILETIME lpUserTime
)
{
SYSTEM_PROCESSORTIME_INFO SysProcTime;
SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION SysProcPerfInfo;
NTSTATUS Status;
Status = ZwQuerySystemInformation(SystemProcessorPerformanceInformation,
&SysProcTime,
sizeof(SysProcTime),
&SysProcPerfInfo,
sizeof(SysProcPerfInfo),
NULL);
if (!NT_SUCCESS(Status))
@ -517,14 +517,14 @@ GetSystemTimes(
Good only for one processor system.
*/
lpIdleTime->dwLowDateTime = SysProcTime.TotalProcessorRunTime.LowPart;
lpIdleTime->dwHighDateTime = SysProcTime.TotalProcessorRunTime.HighPart;
lpIdleTime->dwLowDateTime = SysProcPerfInfo.IdleTime.LowPart;
lpIdleTime->dwHighDateTime = SysProcPerfInfo.IdleTime.HighPart;
lpKernelTime->dwLowDateTime = SysProcTime.TotalProcessorTime.LowPart;
lpKernelTime->dwHighDateTime = SysProcTime.TotalProcessorTime.HighPart;
lpKernelTime->dwLowDateTime = SysProcPerfInfo.KernelTime.LowPart;
lpKernelTime->dwHighDateTime = SysProcPerfInfo.KernelTime.HighPart;
lpUserTime->dwLowDateTime = SysProcTime.TotalProcessorUserTime.LowPart;
lpUserTime->dwHighDateTime = SysProcTime.TotalProcessorUserTime.HighPart;
lpUserTime->dwLowDateTime = SysProcPerfInfo.UserTime.LowPart;
lpUserTime->dwHighDateTime = SysProcPerfInfo.UserTime.HighPart;
return TRUE;
}

24
reactos/ntoskrnl/ex/sysinfo.c
View file

@ -725,18 +725,18 @@ QSI_DEF(SystemDeviceInformation)
/* Class 8 - Processor Performance Information */
QSI_DEF(SystemProcessorPerformanceInformation)
{
PSYSTEM_PROCESSORTIME_INFO Spi
= (PSYSTEM_PROCESSORTIME_INFO) Buffer;
PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION Spi
= (PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION) Buffer;
ULONG i;
LARGE_INTEGER CurrentTime;
PKPRCB Prcb;
*ReqSize = KeNumberProcessors * sizeof (SYSTEM_PROCESSORTIME_INFO);
*ReqSize = KeNumberProcessors * sizeof (SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION);
/*
* Check user buffer's size
* Check user buffer's size
*/
if (Size < KeNumberProcessors * sizeof(SYSTEM_PROCESSORTIME_INFO))
if (Size < KeNumberProcessors * sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION))
{
return (STATUS_INFO_LENGTH_MISMATCH);
}
@ -745,16 +745,16 @@ QSI_DEF(SystemProcessorPerformanceInformation)
Prcb = ((PKPCR)KPCR_BASE)->Prcb;
for (i = 0; i < KeNumberProcessors; i++)
{
Spi->TotalProcessorRunTime.QuadPart = (Prcb->IdleThread->KernelTime + Prcb->IdleThread->UserTime) * 100000LL; // IdleTime
Spi->TotalProcessorTime.QuadPart = Prcb->KernelTime * 100000LL; // KernelTime
Spi->TotalProcessorUserTime.QuadPart = Prcb->UserTime * 100000LL;
Spi->TotalDPCTime.QuadPart = Prcb->DpcTime * 100000LL;
Spi->TotalInterruptTime.QuadPart = Prcb->InterruptTime * 100000LL;
Spi->TotalInterrupts = Prcb->InterruptCount; // Interrupt Count
Spi->IdleTime.QuadPart = (Prcb->IdleThread->KernelTime + Prcb->IdleThread->UserTime) * 100000LL; // IdleTime
Spi->KernelTime.QuadPart = Prcb->KernelTime * 100000LL; // KernelTime
Spi->UserTime.QuadPart = Prcb->UserTime * 100000LL;
Spi->DpcTime.QuadPart = Prcb->DpcTime * 100000LL;
Spi->InterruptTime.QuadPart = Prcb->InterruptTime * 100000LL;
Spi->InterruptCount = Prcb->InterruptCount; // Interrupt Count
Spi++;
Prcb = (PKPRCB)((ULONG_PTR)Prcb + PAGE_SIZE);
}
return (STATUS_SUCCESS);
}

1
reactos/subsys/system/taskmgr/De.rc
View file

@ -583,6 +583,7 @@ STRINGTABLE DISCARDABLE
BEGIN
IDS_APP_TITLE "Task-Manager"
IDC_TASKMGR "Task-Manager"
IDS_IDLE_PROCESS "Leerlaufprozess"
END
STRINGTABLE DISCARDABLE

1
reactos/subsys/system/taskmgr/Dk.rc
View file

@ -538,6 +538,7 @@ STRINGTABLE DISCARDABLE
BEGIN
IDS_APP_TITLE "Opgavestyring"
IDC_TASKMGR "Opgavestyring"
IDS_IDLE_PROCESS "System Idle Process"
END
STRINGTABLE DISCARDABLE

1
reactos/subsys/system/taskmgr/En.rc
View file

@ -538,6 +538,7 @@ STRINGTABLE DISCARDABLE
BEGIN
IDS_APP_TITLE "Task Manager"
IDC_TASKMGR "Task Manager"
IDS_IDLE_PROCESS "System Idle Process"
END
STRINGTABLE DISCARDABLE

1
reactos/subsys/system/taskmgr/Es.rc
View file

@ -611,6 +611,7 @@ STRINGTABLE DISCARDABLE
BEGIN
IDS_APP_TITLE "Administrador de Tareas"
IDC_TASKMGR "Administrador de Tareas"
IDS_IDLE_PROCESS "System Idle Process"
END
STRINGTABLE DISCARDABLE

1
reactos/subsys/system/taskmgr/Sv.rc
View file

@ -555,6 +555,7 @@ STRINGTABLE DISCARDABLE
BEGIN
IDS_APP_TITLE "Aktivitetshanteraren"
IDC_TASKMGR "Aktivitetshanteraren"
IDS_IDLE_PROCESS "System Idle Process"
END
STRINGTABLE DISCARDABLE

8
reactos/subsys/system/taskmgr/about.c
View file

@ -21,14 +21,6 @@
*/
#include "precomp.h"
#include <commctrl.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>
#include <stdio.h>
#include "about.h"
INT_PTR CALLBACK AboutDialogWndProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);

11
reactos/subsys/system/taskmgr/affinity.c
View file

@ -22,17 +22,6 @@
*/
#include "precomp.h"
#include <commctrl.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>
#include <winnt.h>
#include <stdio.h>
#include "procpage.h"
#include "affinity.h"
#include "perfdata.h"
HANDLE hProcessAffinityHandle;
TCHAR szTemp[256];

25
reactos/subsys/system/taskmgr/applpage.c
View file

@ -22,15 +22,6 @@
*/
#include "precomp.h"
#include <commctrl.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>
#include <stdio.h>
#include "applpage.h"
#include "procpage.h"
typedef struct
{
@ -370,7 +361,7 @@ void AddOrUpdateHwnd(HWND hWnd, TCHAR *szTitle, HICON hIcon, BOOL bHung)
/* It is not already in the list so add it */
else
{
pAPLI = (LPAPPLICATION_PAGE_LIST_ITEM)malloc(sizeof(APPLICATION_PAGE_LIST_ITEM));
pAPLI = (LPAPPLICATION_PAGE_LIST_ITEM)HeapAlloc(GetProcessHeap(), 0, sizeof(APPLICATION_PAGE_LIST_ITEM));
pAPLI->hWnd = hWnd;
pAPLI->hIcon = hIcon;
@ -409,7 +400,7 @@ void AddOrUpdateHwnd(HWND hWnd, TCHAR *szTitle, HICON hIcon, BOOL bHung)
ImageList_Remove(hImageListSmall, item.iItem);
ListView_DeleteItem(hApplicationPageListCtrl, item.iItem);
free(pAPLI);
HeapFree(GetProcessHeap(), 0, pAPLI);
bItemRemoved = TRUE;
}
}
@ -704,7 +695,7 @@ void ApplicationPage_OnWindowsTileHorizontally(void)
HWND* hWndArray;
int nWndCount;
hWndArray = (HWND*)malloc(sizeof(HWND) * ListView_GetItemCount(hApplicationPageListCtrl));
hWndArray = (HWND*)HeapAlloc(GetProcessHeap(), 0, sizeof(HWND) * ListView_GetItemCount(hApplicationPageListCtrl));
nWndCount = 0;
for (i=0; i<ListView_GetItemCount(hApplicationPageListCtrl); i++) {
@ -724,7 +715,7 @@ void ApplicationPage_OnWindowsTileHorizontally(void)
}
}
TileWindows(NULL, MDITILE_HORIZONTAL, NULL, nWndCount, hWndArray);
free(hWndArray);
HeapFree(GetProcessHeap(), 0, hWndArray);
}
void ApplicationPage_OnWindowsTileVertically(void)
@ -735,7 +726,7 @@ void ApplicationPage_OnWindowsTileVertically(void)
HWND* hWndArray;
int nWndCount;
hWndArray = (HWND*)malloc(sizeof(HWND) * ListView_GetItemCount(hApplicationPageListCtrl));
hWndArray = (HWND*)HeapAlloc(GetProcessHeap(), 0, sizeof(HWND) * ListView_GetItemCount(hApplicationPageListCtrl));
nWndCount = 0;
for (i=0; i<ListView_GetItemCount(hApplicationPageListCtrl); i++) {
@ -755,7 +746,7 @@ void ApplicationPage_OnWindowsTileVertically(void)
}
TileWindows(NULL, MDITILE_VERTICAL, NULL, nWndCount, hWndArray);
free(hWndArray);
HeapFree(GetProcessHeap(), 0, hWndArray);
}
void ApplicationPage_OnWindowsMinimize(void)
@ -808,7 +799,7 @@ void ApplicationPage_OnWindowsCascade(void)
HWND* hWndArray;
int nWndCount;
hWndArray = (HWND*)malloc(sizeof(HWND) * ListView_GetItemCount(hApplicationPageListCtrl));
hWndArray = (HWND*)HeapAlloc(GetProcessHeap(), 0, sizeof(HWND) * ListView_GetItemCount(hApplicationPageListCtrl));
nWndCount = 0;
for (i=0; i<ListView_GetItemCount(hApplicationPageListCtrl); i++) {
@ -826,7 +817,7 @@ void ApplicationPage_OnWindowsCascade(void)
}
}
CascadeWindows(NULL, 0, NULL, nWndCount, hWndArray);
free(hWndArray);
HeapFree(GetProcessHeap(), 0, hWndArray);
}
void ApplicationPage_OnWindowsBringToFront(void)

9
reactos/subsys/system/taskmgr/column.c
View file

@ -22,15 +22,6 @@
*/
#include "precomp.h"
#include <commctrl.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>
#include <stdio.h>
#include "column.h"
#include "procpage.h"
UINT ColumnDataHints[25];
TCHAR szTemp[256];

14
reactos/subsys/system/taskmgr/dbgchnl.c
View file

@ -21,20 +21,6 @@
*/
#include "precomp.h"
#include <commctrl.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>
#include <stdio.h>
#include <winnt.h>
#include "procpage.h"
#include "perfdata.h"
#include "column.h"
#include "proclist.h"
#include "dbgchnl.h"
#include <ctype.h>
/* TODO:
* - the dialog box could be non modal

11
reactos/subsys/system/taskmgr/debug.c
View file

@ -22,17 +22,6 @@
*/
#include "precomp.h"
#include <commctrl.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>
#include <stdio.h>
#include <winnt.h>
#include "debug.h"
#include "procpage.h"
#include "perfdata.h"
void ProcessPage_OnDebug(void)
{

11
reactos/subsys/system/taskmgr/endproc.c
View file

@ -22,17 +22,6 @@
*/
#include "precomp.h"
#include <commctrl.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>
#include <stdio.h>
#include <winnt.h>
#include "endproc.h"
#include "procpage.h"
#include "perfdata.h"
TCHAR szTemp[256];
TCHAR szTempA[256];

8
reactos/subsys/system/taskmgr/font.c
View file

@ -21,14 +21,6 @@
*/
#include "precomp.h"
#include <commctrl.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>
#include <stdio.h>
#include "font.h"
void Font_DrawText(HDC hDC, LPCTSTR lpszText, int x, int y)
{

12
reactos/subsys/system/taskmgr/graph.c
View file

@ -21,18 +21,6 @@
*/
#include "precomp.h"
#include <commctrl.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>
#include <stdio.h>
#include <winnt.h>
#include "graph.h"
#include "font.h"
#include "perfdata.h"
LONG OldGraphWndProc;

9
reactos/subsys/system/taskmgr/graphctl.c
View file

@ -21,15 +21,6 @@
*/
#include "precomp.h"
#include <commctrl.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>
#include <stdio.h>
#include <math.h>
#include "graphctl.h"
LONG OldGraphCtrlWndProc;

2
reactos/subsys/system/taskmgr/makefile
View file

@ -16,7 +16,7 @@ TARGET_INSTALLDIR = system32
TARGET_PCH = precomp.h
TARGET_CFLAGS = -Werror -Wall -DDBG -D_WIN32_IE=0x0501 -D_WIN32_WINNT=0x0501 -D__USE_W32API
TARGET_CFLAGS = -Werror -Wall -DDBG -D_WIN32_IE=0x0501 -D_WIN32_WINNT=0x0501 -D__USE_W32API
TARGET_SDKLIBS = ntdll.a kernel32.a user32.a gdi32.a comctl32.a

9
reactos/subsys/system/taskmgr/optnmenu.c
View file

@ -27,15 +27,6 @@
*/
#include "precomp.h"
#include <commctrl.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>
#include <stdio.h>
#include "optnmenu.h"
#include "procpage.h"
void TaskManager_OnOptionsAlwaysOnTop(void)
{

158
reactos/subsys/system/taskmgr/perfdata.c
View file

@ -21,19 +21,8 @@
*/
#include "precomp.h"
#include <commctrl.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>
#include <stdio.h>
#include <winnt.h>
#include "perfdata.h"
PROCNTQSI NtQuerySystemInformation = NULL;
PROCGGR pGetGuiResources = NULL;
PROCGPIC pGetProcessIoCounters = NULL;
CRITICAL_SECTION PerfDataCriticalSection;
CRITICAL_SECTION PerfDataCriticalSection;
PPERFDATA pPerfDataOld = NULL; /* Older perf data (saved to establish delta values) */
PPERFDATA pPerfData = NULL; /* Most recent copy of perf data */
ULONG ProcessCountOld = 0;
@ -48,21 +37,14 @@ SYSTEM_PERFORMANCE_INFORMATION SystemPerfInfo;
SYSTEM_BASIC_INFORMATION SystemBasicInfo;
SYSTEM_CACHE_INFORMATION SystemCacheInfo;
SYSTEM_HANDLE_INFORMATION SystemHandleInfo;
PSYSTEM_PROCESSORTIME_INFO SystemProcessorTimeInfo = NULL;
PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION SystemProcessorTimeInfo = NULL;
BOOL PerfDataInitialize(void)
{
LONG status;
NtQuerySystemInformation = (PROCNTQSI)GetProcAddress(GetModuleHandle(_T("ntdll.dll")), "NtQuerySystemInformation");
pGetGuiResources = (PROCGGR)GetProcAddress(GetModuleHandle(_T("user32.dll")), "GetGuiResources");
pGetProcessIoCounters = (PROCGPIC)GetProcAddress(GetModuleHandle(_T("kernel32.dll")), "GetProcessIoCounters");
NTSTATUS status;
InitializeCriticalSection(&PerfDataCriticalSection);
if (!NtQuerySystemInformation)
return FALSE;
/*
* Get number of processors in the system
*/
@ -75,15 +57,13 @@ BOOL PerfDataInitialize(void)
void PerfDataUninitialize(void)
{
NtQuerySystemInformation = NULL;
DeleteCriticalSection(&PerfDataCriticalSection);
}
void PerfDataRefresh(void)
{
ULONG ulSize;
LONG status;
NTSTATUS status;
LPBYTE pBuffer;
ULONG BufferSize;
PSYSTEM_PROCESS_INFORMATION pSPI;
@ -94,18 +74,14 @@ void PerfDataRefresh(void)
TCHAR szTemp[MAX_PATH];
DWORD dwSize;
SYSTEM_PERFORMANCE_INFORMATION SysPerfInfo;
SYSTEM_TIME_INFORMATION SysTimeInfo;
SYSTEM_TIMEOFDAY_INFORMATION SysTimeInfo;
SYSTEM_CACHE_INFORMATION SysCacheInfo;
LPBYTE SysHandleInfoData;
PSYSTEM_PROCESSORTIME_INFO SysProcessorTimeInfo;
PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION SysProcessorTimeInfo;
double CurrentKernelTime;
if (!NtQuerySystemInformation)
return;
/* Get new system time */
status = NtQuerySystemInformation(SystemTimeInformation, &SysTimeInfo, sizeof(SysTimeInfo), 0);
status = NtQuerySystemInformation(SystemTimeOfDayInformation, &SysTimeInfo, sizeof(SysTimeInfo), 0);
if (status != NO_ERROR)
return;
@ -120,8 +96,8 @@ void PerfDataRefresh(void)
return;
/* Get processor time information */
SysProcessorTimeInfo = (PSYSTEM_PROCESSORTIME_INFO)malloc(sizeof(SYSTEM_PROCESSORTIME_INFO) * SystemBasicInfo.bKeNumberProcessors);
status = NtQuerySystemInformation(SystemProcessorTimeInformation, SysProcessorTimeInfo, sizeof(SYSTEM_PROCESSORTIME_INFO) * SystemBasicInfo.bKeNumberProcessors, &ulSize);
SysProcessorTimeInfo = (PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION)HeapAlloc(GetProcessHeap(), 0, sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION) * SystemBasicInfo.NumberProcessors);
status = NtQuerySystemInformation(SystemProcessorPerformanceInformation, SysProcessorTimeInfo, sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION) * SystemBasicInfo.NumberProcessors, &ulSize);
if (status != NO_ERROR)
return;
@ -133,12 +109,12 @@ void PerfDataRefresh(void)
do
{
BufferSize += 0x10000;
SysHandleInfoData = (LPBYTE)malloc(BufferSize);
SysHandleInfoData = (LPBYTE)HeapAlloc(GetProcessHeap(), 0, BufferSize);
status = NtQuerySystemInformation(SystemHandleInformation, SysHandleInfoData, BufferSize, &ulSize);
if (status == 0xC0000004 /*STATUS_INFO_LENGTH_MISMATCH*/) {
free(SysHandleInfoData);
HeapFree(GetProcessHeap(), 0, SysHandleInfoData);
}
} while (status == 0xC0000004 /*STATUS_INFO_LENGTH_MISMATCH*/);
@ -151,12 +127,12 @@ void PerfDataRefresh(void)
do
{
BufferSize += 0x10000;
pBuffer = (LPBYTE)malloc(BufferSize);
pBuffer = (LPBYTE)HeapAlloc(GetProcessHeap(), 0, BufferSize);
status = NtQuerySystemInformation(SystemProcessInformation, pBuffer, BufferSize, &ulSize);
if (status == 0xC0000004 /*STATUS_INFO_LENGTH_MISMATCH*/) {
free(pBuffer);
HeapFree(GetProcessHeap(), 0, pBuffer);
}
} while (status == 0xC0000004 /*STATUS_INFO_LENGTH_MISMATCH*/);
@ -177,7 +153,7 @@ void PerfDataRefresh(void)
* Save system processor time info
*/
if (SystemProcessorTimeInfo) {
free(SystemProcessorTimeInfo);
HeapFree(GetProcessHeap(), 0, SystemProcessorTimeInfo);
}
SystemProcessorTimeInfo = SysProcessorTimeInfo;
@ -185,9 +161,9 @@ void PerfDataRefresh(void)
* Save system handle info
*/
memcpy(&SystemHandleInfo, SysHandleInfoData, sizeof(SYSTEM_HANDLE_INFORMATION));
free(SysHandleInfoData);
HeapFree(GetProcessHeap(), 0, SysHandleInfoData);
for (CurrentKernelTime=0, Idx=0; Idx<SystemBasicInfo.bKeNumberProcessors; Idx++) {
for (CurrentKernelTime=0, Idx=0; Idx<SystemBasicInfo.NumberProcessors; Idx++) {
CurrentKernelTime += Li2Double(SystemProcessorTimeInfo[Idx].KernelTime);
CurrentKernelTime += Li2Double(SystemProcessorTimeInfo[Idx].DpcTime);
CurrentKernelTime += Li2Double(SystemProcessorTimeInfo[Idx].InterruptTime);
@ -196,22 +172,22 @@ void PerfDataRefresh(void)
/* If it's a first call - skip idle time calcs */
if (liOldIdleTime.QuadPart != 0) {
/* CurrentValue = NewValue - OldValue */
dbIdleTime = Li2Double(SysPerfInfo.liIdleTime) - Li2Double(liOldIdleTime);
dbIdleTime = Li2Double(SysPerfInfo.IdleTime) - Li2Double(liOldIdleTime);
dbKernelTime = CurrentKernelTime - OldKernelTime;
dbSystemTime = Li2Double(SysTimeInfo.liKeSystemTime) - Li2Double(liOldSystemTime);
dbSystemTime = Li2Double(SysTimeInfo.CurrentTime) - Li2Double(liOldSystemTime);
/* CurrentCpuIdle = IdleTime / SystemTime */
dbIdleTime = dbIdleTime / dbSystemTime;
dbKernelTime = dbKernelTime / dbSystemTime;
/* CurrentCpuUsage% = 100 - (CurrentCpuIdle * 100) / NumberOfProcessors */
dbIdleTime = 100.0 - dbIdleTime * 100.0 / (double)SystemBasicInfo.bKeNumberProcessors; /* + 0.5; */
dbKernelTime = 100.0 - dbKernelTime * 100.0 / (double)SystemBasicInfo.bKeNumberProcessors; /* + 0.5; */
dbIdleTime = 100.0 - dbIdleTime * 100.0 / (double)SystemBasicInfo.NumberProcessors; /* + 0.5; */
dbKernelTime = 100.0 - dbKernelTime * 100.0 / (double)SystemBasicInfo.NumberProcessors; /* + 0.5; */
}
/* Store new CPU's idle and system time */
liOldIdleTime = SysPerfInfo.liIdleTime;
liOldSystemTime = SysTimeInfo.liKeSystemTime;
liOldIdleTime = SysPerfInfo.IdleTime;
liOldSystemTime = SysTimeInfo.CurrentTime;
OldKernelTime = CurrentKernelTime;
/* Determine the process count
@ -223,24 +199,24 @@ void PerfDataRefresh(void)
pSPI = (PSYSTEM_PROCESS_INFORMATION)pBuffer;
while (pSPI) {
ProcessCount++;
if (pSPI->RelativeOffset == 0)
if (pSPI->NextEntryOffset == 0)
break;
pSPI = (PSYSTEM_PROCESS_INFORMATION)((LPBYTE)pSPI + pSPI->RelativeOffset);
pSPI = (PSYSTEM_PROCESS_INFORMATION)((LPBYTE)pSPI + pSPI->NextEntryOffset);
}
/* Now alloc a new PERFDATA array and fill in the data */
if (pPerfDataOld) {
free(pPerfDataOld);
HeapFree(GetProcessHeap(), 0, pPerfDataOld);
}
pPerfDataOld = pPerfData;
pPerfData = (PPERFDATA)malloc(sizeof(PERFDATA) * ProcessCount);
pPerfData = (PPERFDATA)HeapAlloc(GetProcessHeap(), 0, sizeof(PERFDATA) * ProcessCount);
pSPI = (PSYSTEM_PROCESS_INFORMATION)pBuffer;
for (Idx=0; Idx<ProcessCount; Idx++) {
/* Get the old perf data for this process (if any) */
/* so that we can establish delta values */
pPDOld = NULL;
for (Idx2=0; Idx2<ProcessCountOld; Idx2++) {
if (pPerfDataOld[Idx2].ProcessId == pSPI->ProcessId) {
if (pPerfDataOld[Idx2].ProcessId == pSPI->UniqueProcessId) {
pPDOld = &pPerfDataOld[Idx2];
break;
}
@ -249,25 +225,26 @@ void PerfDataRefresh(void)
/* Clear out process perf data structure */
memset(&pPerfData[Idx], 0, sizeof(PERFDATA));
if (pSPI->Name.Buffer)
wcscpy(pPerfData[Idx].ImageName, pSPI->Name.Buffer);
if (pSPI->ImageName.Buffer)
wcscpy(pPerfData[Idx].ImageName, pSPI->ImageName.Buffer);
else
wcscpy(pPerfData[Idx].ImageName, L"System Idle Process");
LoadStringW(hInst, IDS_IDLE_PROCESS, pPerfData[Idx].ImageName,
sizeof(pPerfData[Idx].ImageName) / sizeof(pPerfData[Idx].ImageName[0]));
pPerfData[Idx].ProcessId = pSPI->ProcessId;
pPerfData[Idx].ProcessId = pSPI->UniqueProcessId;
if (pPDOld) {
double CurTime = Li2Double(pSPI->KernelTime) + Li2Double(pSPI->UserTime);
double OldTime = Li2Double(pPDOld->KernelTime) + Li2Double(pPDOld->UserTime);
double CpuTime = (CurTime - OldTime) / dbSystemTime;
CpuTime = CpuTime * 100.0 / (double)SystemBasicInfo.bKeNumberProcessors; /* + 0.5; */
CpuTime = CpuTime * 100.0 / (double)SystemBasicInfo.NumberProcessors; /* + 0.5; */
pPerfData[Idx].CPUUsage = (ULONG)CpuTime;
}
pPerfData[Idx].CPUTime.QuadPart = pSPI->UserTime.QuadPart + pSPI->KernelTime.QuadPart;
pPerfData[Idx].WorkingSetSizeBytes = pSPI->TotalWorkingSetSizeBytes;
pPerfData[Idx].PeakWorkingSetSizeBytes = pSPI->PeakWorkingSetSizeBytes;
pPerfData[Idx].WorkingSetSizeBytes = pSPI->WorkingSetSize;
pPerfData[Idx].PeakWorkingSetSizeBytes = pSPI->PeakWorkingSetSize;
if (pPDOld)
pPerfData[Idx].WorkingSetSizeDelta = labs((LONG)pSPI->TotalWorkingSetSizeBytes - (LONG)pPDOld->WorkingSetSizeBytes);
pPerfData[Idx].WorkingSetSizeDelta = labs((LONG)pSPI->WorkingSetSize - (LONG)pPDOld->WorkingSetSizeBytes);
else
pPerfData[Idx].WorkingSetSizeDelta = 0;
pPerfData[Idx].PageFaultCount = pSPI->PageFaultCount;
@ -275,15 +252,15 @@ void PerfDataRefresh(void)
pPerfData[Idx].PageFaultCountDelta = labs((LONG)pSPI->PageFaultCount - (LONG)pPDOld->PageFaultCount);
else
pPerfData[Idx].PageFaultCountDelta = 0;
pPerfData[Idx].VirtualMemorySizeBytes = pSPI->TotalVirtualSizeBytes;
pPerfData[Idx].PagedPoolUsagePages = pSPI->TotalPagedPoolUsagePages;
pPerfData[Idx].NonPagedPoolUsagePages = pSPI->TotalNonPagedPoolUsagePages;
pPerfData[Idx].VirtualMemorySizeBytes = pSPI->VirtualSize;
pPerfData[Idx].PagedPoolUsagePages = pSPI->QuotaPagedPoolUsage;
pPerfData[Idx].NonPagedPoolUsagePages = pSPI->QuotaPeakNonPagedPoolUsage;
pPerfData[Idx].BasePriority = pSPI->BasePriority;
pPerfData[Idx].HandleCount = pSPI->HandleCount;
pPerfData[Idx].ThreadCount = pSPI->ThreadCount;
pPerfData[Idx].ThreadCount = pSPI->NumberOfThreads;
pPerfData[Idx].SessionId = pSPI->SessionId;
hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, pSPI->ProcessId);
hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, (DWORD)pSPI->UniqueProcessId);
if (hProcess) {
if (OpenProcessToken(hProcess, TOKEN_QUERY|TOKEN_DUPLICATE|TOKEN_IMPERSONATE, &hProcessToken)) {
ImpersonateLoggedOnUser(hProcessToken);
@ -306,19 +283,16 @@ int MultiByteToWideChar(
RevertToSelf();
CloseHandle(hProcessToken);
}
if (pGetGuiResources) {
pPerfData[Idx].USERObjectCount = pGetGuiResources(hProcess, GR_USEROBJECTS);
pPerfData[Idx].GDIObjectCount = pGetGuiResources(hProcess, GR_GDIOBJECTS);
}
if (pGetProcessIoCounters)
pGetProcessIoCounters(hProcess, &pPerfData[Idx].IOCounters);
pPerfData[Idx].USERObjectCount = GetGuiResources(hProcess, GR_USEROBJECTS);
pPerfData[Idx].GDIObjectCount = GetGuiResources(hProcess, GR_GDIOBJECTS);
GetProcessIoCounters(hProcess, &pPerfData[Idx].IOCounters);
CloseHandle(hProcess);
}
pPerfData[Idx].UserTime.QuadPart = pSPI->UserTime.QuadPart;
pPerfData[Idx].KernelTime.QuadPart = pSPI->KernelTime.QuadPart;
pSPI = (PSYSTEM_PROCESS_INFORMATION)((LPBYTE)pSPI + pSPI->RelativeOffset);
pSPI = (PSYSTEM_PROCESS_INFORMATION)((LPBYTE)pSPI + pSPI->NextEntryOffset);
}
free(pBuffer);
HeapFree(GetProcessHeap(), 0, pBuffer);
LeaveCriticalSection(&PerfDataCriticalSection);
}
@ -365,7 +339,7 @@ ULONG PerfDataGetProcessId(ULONG Index)
EnterCriticalSection(&PerfDataCriticalSection);
if (Index < ProcessCount)
ProcessId = pPerfData[Index].ProcessId;
ProcessId = (ULONG)pPerfData[Index].ProcessId;
else
ProcessId = 0;
@ -677,8 +651,8 @@ ULONG PerfDataGetCommitChargeTotalK(void)
EnterCriticalSection(&PerfDataCriticalSection);
Total = SystemPerfInfo.MmTotalCommitedPages;
PageSize = SystemBasicInfo.uPageSize;
Total = SystemPerfInfo.TotalCommittedPages;
PageSize = SystemBasicInfo.PhysicalPageSize;
LeaveCriticalSection(&PerfDataCriticalSection);
@ -694,8 +668,8 @@ ULONG PerfDataGetCommitChargeLimitK(void)
EnterCriticalSection(&PerfDataCriticalSection);
Limit = SystemPerfInfo.MmTotalCommitLimit;
PageSize = SystemBasicInfo.uPageSize;
Limit = SystemPerfInfo.TotalCommitLimit;
PageSize = SystemBasicInfo.PhysicalPageSize;
LeaveCriticalSection(&PerfDataCriticalSection);
@ -711,8 +685,8 @@ ULONG PerfDataGetCommitChargePeakK(void)
EnterCriticalSection(&PerfDataCriticalSection);
Peak = SystemPerfInfo.MmPeakLimit;
PageSize = SystemBasicInfo.uPageSize;
Peak = SystemPerfInfo.PeakCommitment;
PageSize = SystemBasicInfo.PhysicalPageSize;
LeaveCriticalSection(&PerfDataCriticalSection);
@ -730,9 +704,9 @@ ULONG PerfDataGetKernelMemoryTotalK(void)
EnterCriticalSection(&PerfDataCriticalSection);
Paged = SystemPerfInfo.PoolPagedBytes;
NonPaged = SystemPerfInfo.PoolNonPagedBytes;
PageSize = SystemBasicInfo.uPageSize;
Paged = SystemPerfInfo.PagedPoolUsage;
NonPaged = SystemPerfInfo.NonPagedPoolUsage;
PageSize = SystemBasicInfo.PhysicalPageSize;
LeaveCriticalSection(&PerfDataCriticalSection);
@ -751,8 +725,8 @@ ULONG PerfDataGetKernelMemoryPagedK(void)
EnterCriticalSection(&PerfDataCriticalSection);
Paged = SystemPerfInfo.PoolPagedBytes;
PageSize = SystemBasicInfo.uPageSize;
Paged = SystemPerfInfo.PagedPoolUsage;
PageSize = SystemBasicInfo.PhysicalPageSize;
LeaveCriticalSection(&PerfDataCriticalSection);
@ -768,8 +742,8 @@ ULONG PerfDataGetKernelMemoryNonPagedK(void)
EnterCriticalSection(&PerfDataCriticalSection);
NonPaged = SystemPerfInfo.PoolNonPagedBytes;
PageSize = SystemBasicInfo.uPageSize;
NonPaged = SystemPerfInfo.NonPagedPoolUsage;
PageSize = SystemBasicInfo.PhysicalPageSize;
LeaveCriticalSection(&PerfDataCriticalSection);
@ -785,8 +759,8 @@ ULONG PerfDataGetPhysicalMemoryTotalK(void)
EnterCriticalSection(&PerfDataCriticalSection);
Total = SystemBasicInfo.uMmNumberOfPhysicalPages;
PageSize = SystemBasicInfo.uPageSize;
Total = SystemBasicInfo.NumberOfPhysicalPages;
PageSize = SystemBasicInfo.PhysicalPageSize;
LeaveCriticalSection(&PerfDataCriticalSection);
@ -802,8 +776,8 @@ ULONG PerfDataGetPhysicalMemoryAvailableK(void)
EnterCriticalSection(&PerfDataCriticalSection);
Available = SystemPerfInfo.MmAvailablePages;
PageSize = SystemBasicInfo.uPageSize;
Available = SystemPerfInfo.AvailablePages;
PageSize = SystemBasicInfo.PhysicalPageSize;
LeaveCriticalSection(&PerfDataCriticalSection);
@ -820,7 +794,7 @@ ULONG PerfDataGetPhysicalMemorySystemCacheK(void)
EnterCriticalSection(&PerfDataCriticalSection);
SystemCache = SystemCacheInfo.CurrentSize;
PageSize = SystemBasicInfo.uPageSize;
PageSize = SystemBasicInfo.PhysicalPageSize;
LeaveCriticalSection(&PerfDataCriticalSection);
@ -836,7 +810,7 @@ ULONG PerfDataGetSystemHandleCount(void)
EnterCriticalSection(&PerfDataCriticalSection);
HandleCount = SystemHandleInfo.Count;
HandleCount = SystemHandleInfo.NumberOfHandles;
LeaveCriticalSection(&PerfDataCriticalSection);

290
reactos/subsys/system/taskmgr/perfdata.h
View file

@ -27,27 +27,12 @@
extern "C" {
#endif
#if 0
typedef struct _TIME {
DWORD LowPart;
LONG HighPart;
} TIME, *PTIME;
#endif
typedef ULARGE_INTEGER TIME, *PTIME;
/* typedef WCHAR UNICODE_STRING; */
typedef struct _UNICODE_STRING {
USHORT Length;
USHORT MaximumLength;
PWSTR Buffer;
} UNICODE_STRING, *PUNICODE_STRING;
#define Li2Double(x) ((double)((x).HighPart) * 4.294967296E9 + (double)((x).LowPart))
typedef struct _PERFDATA
{
WCHAR ImageName[MAX_PATH];
ULONG ProcessId;
HANDLE ProcessId;
WCHAR UserName[MAX_PATH];
ULONG SessionId;
ULONG CPUUsage;
@ -71,277 +56,6 @@ typedef struct _PERFDATA
TIME KernelTime;
} PERFDATA, *PPERFDATA;
typedef struct _CLIENT_ID
{
HANDLE UniqueProcess;
HANDLE UniqueThread;
} CLIENT_ID, *PCLIENT_ID;
typedef enum _KWAIT_REASON
{
Executive,
FreePage,
PageIn,
PoolAllocation,
DelayExecution,
Suspended,
UserRequest,
WrExecutive,
WrFreePage,
WrPageIn,
WrDelayExecution,
WrSuspended,
WrUserRequest,
WrQueue,
WrLpcReceive,
WrLpcReply,
WrVirtualMemory,
WrPageOut,
WrRendezvous,
Spare2,
Spare3,
Spare4,
Spare5,
Spare6,
WrKernel,
MaximumWaitReason,
} KWAIT_REASON;
/* SystemProcessThreadInfo (5) */
typedef struct _SYSTEM_THREAD_INFORMATION
{
TIME KernelTime;
TIME UserTime;
TIME CreateTime;
ULONG TickCount;
ULONG StartEIP;
CLIENT_ID ClientId;
ULONG DynamicPriority;
ULONG BasePriority;
ULONG nSwitches;
DWORD State;
KWAIT_REASON WaitReason;
} SYSTEM_THREAD_INFORMATION, *PSYSTEM_THREAD_INFORMATION;
typedef struct SYSTEM_PROCESS_INFORMATION
{
ULONG RelativeOffset;
ULONG ThreadCount;
ULONG Unused1 [6];
TIME CreateTime;
TIME UserTime;
TIME KernelTime;
UNICODE_STRING Name;
ULONG BasePriority;
ULONG ProcessId;
ULONG ParentProcessId;
ULONG HandleCount;
ULONG SessionId;
ULONG Unused2;
ULONG PeakVirtualSizeBytes;
ULONG TotalVirtualSizeBytes;
ULONG PageFaultCount;
ULONG PeakWorkingSetSizeBytes;
ULONG TotalWorkingSetSizeBytes;
ULONG PeakPagedPoolUsagePages;
ULONG TotalPagedPoolUsagePages;
ULONG PeakNonPagedPoolUsagePages;
ULONG TotalNonPagedPoolUsagePages;
ULONG TotalPageFileUsageBytes;
ULONG PeakPageFileUsageBytes;
ULONG TotalPrivateBytes;
SYSTEM_THREAD_INFORMATION ThreadSysInfo [1];
} SYSTEM_PROCESS_INFORMATION, *PSYSTEM_PROCESS_INFORMATION;
typedef struct
{
DWORD dwUnknown1;
ULONG uKeMaximumIncrement;
ULONG uPageSize;
ULONG uMmNumberOfPhysicalPages;
ULONG uMmLowestPhysicalPage;
ULONG uMmHighestPhysicalPage;
ULONG uAllocationGranularity;
PVOID pLowestUserAddress;
PVOID pMmHighestUserAddress;
ULONG uKeActiveProcessors;
BYTE bKeNumberProcessors;
BYTE bUnknown2;
WORD wUnknown3;
} SYSTEM_BASIC_INFORMATION;
/* SystemPerformanceInfo (2) */
typedef struct _SYSTEM_PERFORMANCE_INFORMATION
{
LARGE_INTEGER /*TotalProcessorTime*/liIdleTime;
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;
} SYSTEM_PERFORMANCE_INFORMATION, *PSYSTEM_PERFORMANCE_INFORMATION;
typedef struct
{
LARGE_INTEGER liKeBootTime;
LARGE_INTEGER liKeSystemTime;
LARGE_INTEGER liExpTimeZoneBias;
ULONG uCurrentTimeZoneId;
DWORD dwReserved;
} SYSTEM_TIME_INFORMATION;
/* SystemCacheInformation (21) */
typedef struct _SYSTEM_CACHE_INFORMATION
{
ULONG CurrentSize;
ULONG PeakSize;
ULONG PageFaultCount;
ULONG MinimumWorkingSet;
ULONG MaximumWorkingSet;
ULONG Unused[4];
} SYSTEM_CACHE_INFORMATION;
/* SystemPageFileInformation (18) */
typedef
struct _SYSTEM_PAGEFILE_INFORMATION
{
ULONG RelativeOffset;
ULONG CurrentSizePages;
ULONG TotalUsedPages;
ULONG PeakUsedPages;
UNICODE_STRING PagefileFileName;
} SYSTEM_PAGEFILE_INFORMATION, *PSYSTEM_PAGEFILE_INFORMATION;
/* SystemHandleInformation (16) */
/* (see ontypes.h) */
typedef
struct _SYSTEM_HANDLE_ENTRY
{
ULONG OwnerPid;
BYTE ObjectType;
BYTE HandleFlags;
USHORT HandleValue;
PVOID ObjectPointer;
ULONG AccessMask;
} SYSTEM_HANDLE_ENTRY, *PSYSTEM_HANDLE_ENTRY;
typedef
struct _SYSTEM_HANDLE_INFORMATION
{
ULONG Count;
SYSTEM_HANDLE_ENTRY Handle [1];
} SYSTEM_HANDLE_INFORMATION, *PSYSTEM_HANDLE_INFORMATION;
/* SystemProcessorPerformanceInformation (8) */
typedef
struct _SYSTEM_PROCESSORTIME_INFO
{
LARGE_INTEGER IdleTime;
LARGE_INTEGER KernelTime;
LARGE_INTEGER UserTime;
LARGE_INTEGER DpcTime;
LARGE_INTEGER InterruptTime;
ULONG InterruptCount;
ULONG Unused;
} SYSTEM_PROCESSORTIME_INFO, *PSYSTEM_PROCESSORTIME_INFO;
#define SystemBasicInformation 0
#define SystemPerformanceInformation 2
#define SystemTimeInformation 3
#define SystemProcessInformation 5
#define SystemProcessorTimeInformation 8
#define SystemHandleInformation 16
#define SystemPageFileInformation 18
#define SystemCacheInformation 21
#define Li2Double(x) ((double)((x).HighPart) * 4.294967296E9 + (double)((x).LowPart))
#define BELOW_NORMAL_PRIORITY_CLASS 0x00004000
#define ABOVE_NORMAL_PRIORITY_CLASS 0x00008000
#define GR_GDIOBJECTS 0 /* Count of GDI objects */
#define GR_USEROBJECTS 1 /* Count of USER objects */
typedef LONG (WINAPI *PROCNTQSI)(UINT,PVOID,ULONG,PULONG);
typedef DWORD (WINAPI *PROCGGR)(HANDLE,DWORD);
typedef BOOL (WINAPI *PROCGPIC)(HANDLE,PIO_COUNTERS);
BOOL PerfDataInitialize(void);
void PerfDataUninitialize(void);
void PerfDataRefresh(void);

13
reactos/subsys/system/taskmgr/perfpage.c
View file

@ -21,19 +21,6 @@
*/
#include "precomp.h"
#include <commctrl.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>
#include <stdio.h>
#include <winnt.h>
#include "perfpage.h"
#include "perfdata.h"
#include "graph.h"
#include "graphctl.h"
TGraphCtrl PerformancePageCpuUsageHistoryGraph;
TGraphCtrl PerformancePageMemUsageHistoryGraph;

29
reactos/subsys/system/taskmgr/precomp.h
View file

@ -1,3 +1,30 @@
#define WIN32_LEAN_AND_MEAN /* Exclude rarely-used stuff from Windows headers */
#define NTOS_MODE_USER
#include <ntos.h>
#include <windows.h>
#include <commctrl.h>
#include <shellapi.h>
#include <stdlib.h>
#include <math.h>
#include <tchar.h>
#include <stdio.h>
#include <ctype.h>
#include "taskmgr.h"
#include "perfdata.h"
#include "perfpage.h"
#include "about.h"
#include "procpage.h"
#include "proclist.h"
#include "affinity.h"
#include "applpage.h"
#include "column.h"
#include "dbgchnl.h"
#include "debug.h"
#include "endproc.h"
#include "font.h"
#include "graph.h"
#include "graphctl.h"
#include "optnmenu.h"
#include "priority.h"
#include "run.h"
#include "trayicon.h"

11
reactos/subsys/system/taskmgr/priority.c
View file

@ -22,17 +22,6 @@
*/
#include "precomp.h"
#include <commctrl.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>
#include <stdio.h>
#include <winnt.h>
#include "priority.h"
#include "procpage.h"
#include "perfdata.h"
TCHAR szTemp[256];
TCHAR szTempA[256];

11
reactos/subsys/system/taskmgr/proclist.c
View file

@ -21,17 +21,6 @@
*/
#include "precomp.h"
#include <commctrl.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>
#include <stdio.h>
#include <winnt.h>
#include "procpage.h"
#include "proclist.h"
#include "perfdata.h"
INT_PTR CALLBACK ProcessListWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);

15
reactos/subsys/system/taskmgr/procpage.c
View file

@ -21,21 +21,6 @@
*/
#include "precomp.h"
#include <commctrl.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>
#include <stdio.h>
#include <winnt.h>
#include "procpage.h"
#include "perfdata.h"
#include "column.h"
#include "proclist.h"
#include "dbgchnl.h"
#include "endproc.h"
#include <ctype.h>
HWND hProcessPage; /* Process List Property Page */

1
reactos/subsys/system/taskmgr/resource.h
View file

@ -2,6 +2,7 @@
// Microsoft Developer Studio generated include file.
// Used by TaskMgr.rc
//
#define IDS_IDLE_PROCESS 102
#define IDD_TASKMGR_DIALOG 102
#define IDD_ABOUTBOX 103
#define IDS_APP_TITLE 103

8
reactos/subsys/system/taskmgr/run.c
View file

@ -22,14 +22,6 @@
*/
#include "precomp.h"
#include <commctrl.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>
#include <stdio.h>
#include "run.h"
void TaskManager_OnFileNew(void)
{

23
reactos/subsys/system/taskmgr/taskmgr.c
View file

@ -22,29 +22,6 @@
*/
#include "precomp.h"
#include <commctrl.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>
#include <stdio.h>
#include <winnt.h>
#include "resource.h"
#include "applpage.h"
#include "procpage.h"
#include "perfpage.h"
#include "run.h"
#include "perfdata.h"
#include "optnmenu.h"
#include "affinity.h"
#include "priority.h"
#include "debug.h"
#include "endproc.h"
#include "column.h"
#include "about.h"
#include "trayicon.h"
#include "dbgchnl.h"
#define STATUS_WINDOW 2001

11
reactos/subsys/system/taskmgr/trayicon.c
View file

@ -22,17 +22,6 @@
*/
#include "precomp.h"
#include <commctrl.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>
#include <stdio.h>
#include <winnt.h>
#include "trayicon.h"
#include "perfdata.h"
#include "shellapi.h"
HICON TrayIcon_GetProcessorUsageIcon(void)
{