programs/taskmgr/perfdata.c

   1 /*
   2  *  ReactOS Task Manager
   3  *
   4  *  perfdata.c
   5  *
   6  *  Copyright (C) 1999 - 2001  Brian Palmer  <brianp@reactos.org>
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25
  26 #include <windows.h>
  27 #include <commctrl.h>
  28 #include <winnt.h>
  29
  30 #include "taskmgr.h"
  31 #include "perfdata.h"
  32
  33 static PROCNTQSI                       pNtQuerySystemInformation = NULL;
  34 static PROCGGR                         pGetGuiResources = NULL;
  35 static PROCGPIC                        pGetProcessIoCounters = NULL;
  36 static PROCISW64                       pIsWow64Process = NULL;
  37 static CRITICAL_SECTION                PerfDataCriticalSection;
  38 static PPERFDATA                       pPerfDataOld = NULL;    /* Older perf data (saved to establish delta values) */
  39 static PPERFDATA                       pPerfData = NULL;    /* Most recent copy of perf data */
  40 static ULONG                           ProcessCountOld = 0;
  41 static ULONG                           ProcessCount = 0;
  42 static double                          dbIdleTime;
  43 static double                          dbKernelTime;
  44 static double                          dbSystemTime;
  45 static LARGE_INTEGER                   liOldIdleTime = {{0,0}};
  46 static double                          OldKernelTime = 0;
  47 static LARGE_INTEGER                   liOldSystemTime = {{0,0}};
  48 static SYSTEM_PERFORMANCE_INFORMATION  SystemPerfInfo;
  49 static SYSTEM_BASIC_INFORMATION        SystemBasicInfo;
  50 static SYSTEM_CACHE_INFORMATION        SystemCacheInfo;
  51 static SYSTEM_HANDLE_INFORMATION       SystemHandleInfo;
  52 static PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION SystemProcessorTimeInfo = NULL;
  53
  54 BOOL PerfDataInitialize(void)
  55 {
  56     LONG    status;
  57     static const WCHAR wszNtdll[] = {'n','t','d','l','l','.','d','l','l',0};
  58     static const WCHAR wszUser32[] = {'u','s','e','r','3','2','.','d','l','l',0};
  59     static const WCHAR wszKernel32[] = {'k','e','r','n','e','l','3','2','.','d','l','l',0};
  60
  61     pNtQuerySystemInformation = (PROCNTQSI)GetProcAddress(GetModuleHandleW(wszNtdll), "NtQuerySystemInformation");
  62     pGetGuiResources = (PROCGGR)GetProcAddress(GetModuleHandleW(wszUser32), "GetGuiResources");
  63     pGetProcessIoCounters = (PROCGPIC)GetProcAddress(GetModuleHandleW(wszKernel32), "GetProcessIoCounters");
  64     pIsWow64Process = (PROCISW64)GetProcAddress(GetModuleHandleW(wszKernel32), "IsWow64Process");
  65
  66     InitializeCriticalSection(&PerfDataCriticalSection);
  67
  68     if (!pNtQuerySystemInformation)
  69         return FALSE;
  70
  71     /*
  72      * Get number of processors in the system
  73      */
  74     status = pNtQuerySystemInformation(SystemBasicInformation, &SystemBasicInfo, sizeof(SystemBasicInfo), NULL);
  75     if (status != NO_ERROR)
  76         return FALSE;
  77
  78     return TRUE;
  79 }
  80
  81 void PerfDataRefresh(void)
  82 {
  83     ULONG                            ulSize;
  84     LONG                            status;
  85     LPBYTE                            pBuffer;
  86     ULONG                            BufferSize;
  87     PSYSTEM_PROCESS_INFORMATION        pSPI;
  88     PPERFDATA                        pPDOld;
  89     ULONG                            Idx, Idx2;
  90     HANDLE                            hProcess;
  91     HANDLE                            hProcessToken;
  92     WCHAR                            wszTemp[MAX_PATH];
  93     DWORD                            dwSize;
  94     SYSTEM_PERFORMANCE_INFORMATION    SysPerfInfo;
  95     SYSTEM_TIMEOFDAY_INFORMATION      SysTimeInfo;
  96     SYSTEM_CACHE_INFORMATION        SysCacheInfo;
  97     LPBYTE                            SysHandleInfoData;
  98     SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION *SysProcessorTimeInfo;
  99     double                            CurrentKernelTime;
 100
 101
 102     /* Get new system time */
 103     status = pNtQuerySystemInformation(SystemTimeOfDayInformation, &SysTimeInfo, sizeof(SysTimeInfo), 0);
 104     if (status != NO_ERROR)
 105         return;
 106
 107     /* Get new CPU's idle time */
 108     status = pNtQuerySystemInformation(SystemPerformanceInformation, &SysPerfInfo, sizeof(SysPerfInfo), NULL);
 109     if (status != NO_ERROR)
 110         return;
 111
 112     /* Get system cache information */
 113     status = pNtQuerySystemInformation(SystemCacheInformation, &SysCacheInfo, sizeof(SysCacheInfo), NULL);
 114     if (status != NO_ERROR)
 115         return;
 116
 117     /* Get processor time information */
 118     SysProcessorTimeInfo = HeapAlloc(GetProcessHeap(), 0,
 119                                 sizeof(*SysProcessorTimeInfo) * SystemBasicInfo.NumberOfProcessors);
 120     status = pNtQuerySystemInformation(SystemProcessorPerformanceInformation, SysProcessorTimeInfo, sizeof(*SysProcessorTimeInfo) * SystemBasicInfo.NumberOfProcessors, &ulSize);
 121     if (status != NO_ERROR) {
 122         HeapFree(GetProcessHeap(), 0, SysProcessorTimeInfo);
 123         return;
 124     }
 125
 126     /* Get handle information
 127      * We don't know how much data there is so just keep
 128      * increasing the buffer size until the call succeeds
 129      */
 130     BufferSize = 0;
 131     do
 132     {
 133         BufferSize += 0x10000;
 134         SysHandleInfoData = HeapAlloc(GetProcessHeap(), 0, BufferSize);
 135
 136         status = pNtQuerySystemInformation(SystemHandleInformation, SysHandleInfoData, BufferSize, &ulSize);
 137
 138         if (status == 0xC0000004 /*STATUS_INFO_LENGTH_MISMATCH*/) {
 139             HeapFree(GetProcessHeap(), 0, SysHandleInfoData);
 140         }
 141
 142     } while (status == 0xC0000004 /*STATUS_INFO_LENGTH_MISMATCH*/);
 143
 144     /* Get process information
 145      * We don't know how much data there is so just keep
 146      * increasing the buffer size until the call succeeds
 147      */
 148     BufferSize = 0;
 149     do
 150     {
 151         BufferSize += 0x10000;
 152         pBuffer = HeapAlloc(GetProcessHeap(), 0, BufferSize);
 153
 154         status = pNtQuerySystemInformation(SystemProcessInformation, pBuffer, BufferSize, &ulSize);
 155
 156         if (status == 0xC0000004 /*STATUS_INFO_LENGTH_MISMATCH*/) {
 157             HeapFree(GetProcessHeap(), 0, pBuffer);
 158         }
 159
 160     } while (status == 0xC0000004 /*STATUS_INFO_LENGTH_MISMATCH*/);
 161
 162     EnterCriticalSection(&PerfDataCriticalSection);
 163
 164     /*
 165      * Save system performance info
 166      */
 167     memcpy(&SystemPerfInfo, &SysPerfInfo, sizeof(SYSTEM_PERFORMANCE_INFORMATION));
 168
 169     /*
 170      * Save system cache info
 171      */
 172     memcpy(&SystemCacheInfo, &SysCacheInfo, sizeof(SYSTEM_CACHE_INFORMATION));
 173
 174     /*
 175      * Save system processor time info
 176      */
 177     HeapFree(GetProcessHeap(), 0, SystemProcessorTimeInfo);
 178     SystemProcessorTimeInfo = SysProcessorTimeInfo;
 179
 180     /*
 181      * Save system handle info
 182      */
 183     memcpy(&SystemHandleInfo, SysHandleInfoData, sizeof(SYSTEM_HANDLE_INFORMATION));
 184     HeapFree(GetProcessHeap(), 0, SysHandleInfoData);
 185
 186     for (CurrentKernelTime=0, Idx=0; Idx<SystemBasicInfo.NumberOfProcessors; Idx++) {
 187         CurrentKernelTime += Li2Double(SystemProcessorTimeInfo[Idx].KernelTime);
 188         CurrentKernelTime += Li2Double(SystemProcessorTimeInfo[Idx].Reserved1[0]);
 189         CurrentKernelTime += Li2Double(SystemProcessorTimeInfo[Idx].Reserved1[1]);
 190     }
 191
 192     /* If it's a first call - skip idle time calcs */
 193     if (liOldIdleTime.QuadPart != 0) {
 194         /*  CurrentValue = NewValue - OldValue */
 195         dbIdleTime = Li2Double(SysPerfInfo.IdleTime) - Li2Double(liOldIdleTime);
 196         dbKernelTime = CurrentKernelTime - OldKernelTime;
 197         dbSystemTime = Li2Double(SysTimeInfo.liKeSystemTime) - Li2Double(liOldSystemTime);
 198
 199         /*  CurrentCpuIdle = IdleTime / SystemTime */
 200         dbIdleTime = dbIdleTime / dbSystemTime;
 201         dbKernelTime = dbKernelTime / dbSystemTime;
 202
 203         /*  CurrentCpuUsage% = 100 - (CurrentCpuIdle * 100) / NumberOfProcessors */
 204         dbIdleTime = 100.0 - dbIdleTime * 100.0 / (double)SystemBasicInfo.NumberOfProcessors; /* + 0.5; */
 205         dbKernelTime = 100.0 - dbKernelTime * 100.0 / (double)SystemBasicInfo.NumberOfProcessors; /* + 0.5; */
 206     }
 207
 208     /* Store new CPU's idle and system time */
 209     liOldIdleTime = SysPerfInfo.IdleTime;
 210     liOldSystemTime = SysTimeInfo.liKeSystemTime;
 211     OldKernelTime = CurrentKernelTime;
 212
 213     /* Determine the process count
 214      * We loop through the data we got from NtQuerySystemInformation
 215      * and count how many structures there are (until RelativeOffset is 0)
 216      */
 217     ProcessCountOld = ProcessCount;
 218     ProcessCount = 0;
 219     pSPI = (PSYSTEM_PROCESS_INFORMATION)pBuffer;
 220     while (pSPI) {
 221         ProcessCount++;
 222         if (pSPI->NextEntryOffset == 0)
 223             break;
 224         pSPI = (PSYSTEM_PROCESS_INFORMATION)((LPBYTE)pSPI + pSPI->NextEntryOffset);
 225     }
 226
 227     /* Now alloc a new PERFDATA array and fill in the data */
 228     HeapFree(GetProcessHeap(), 0, pPerfDataOld);
 229     pPerfDataOld = pPerfData;
 230     pPerfData = HeapAlloc(GetProcessHeap(), 0, sizeof(PERFDATA) * ProcessCount);
 231     pSPI = (PSYSTEM_PROCESS_INFORMATION)pBuffer;
 232     for (Idx=0; Idx<ProcessCount; Idx++) {
 233         /* Get the old perf data for this process (if any) */
 234         /* so that we can establish delta values */
 235         pPDOld = NULL;
 236         for (Idx2=0; Idx2<ProcessCountOld; Idx2++) {
 237             if (pPerfDataOld[Idx2].ProcessId == (DWORD_PTR)pSPI->UniqueProcessId) {
 238                 pPDOld = &pPerfDataOld[Idx2];
 239                 break;
 240             }
 241         }
 242
 243         /* Clear out process perf data structure */
 244         memset(&pPerfData[Idx], 0, sizeof(PERFDATA));
 245
 246         if (pSPI->ProcessName.Buffer)
 247             lstrcpyW(pPerfData[Idx].ImageName, pSPI->ProcessName.Buffer);
 248         else
 249         {
 250             WCHAR idleW[255];
 251             LoadStringW(hInst, IDS_SYSTEM_IDLE_PROCESS, idleW, sizeof(idleW)/sizeof(WCHAR));
 252             lstrcpyW(pPerfData[Idx].ImageName, idleW );
 253         }
 254
 255         pPerfData[Idx].ProcessId = (DWORD_PTR)pSPI->UniqueProcessId;
 256
 257         if (pPDOld)    {
 258             double    CurTime = Li2Double(pSPI->KernelTime) + Li2Double(pSPI->UserTime);
 259             double    OldTime = Li2Double(pPDOld->KernelTime) + Li2Double(pPDOld->UserTime);
 260             double    CpuTime = (CurTime - OldTime) / dbSystemTime;
 261             CpuTime = CpuTime * 100.0 / (double)SystemBasicInfo.NumberOfProcessors; /* + 0.5; */
 262             pPerfData[Idx].CPUUsage = (ULONG)CpuTime;
 263         }
 264
 265         pPerfData[Idx].CPUTime.QuadPart = pSPI->UserTime.QuadPart + pSPI->KernelTime.QuadPart;
 266         pPerfData[Idx].vmCounters.WorkingSetSize = pSPI->vmCounters.WorkingSetSize;
 267         pPerfData[Idx].vmCounters.PeakWorkingSetSize = pSPI->vmCounters.PeakWorkingSetSize;
 268         if (pPDOld)
 269             pPerfData[Idx].WorkingSetSizeDelta = labs(pSPI->vmCounters.WorkingSetSize - pPDOld->vmCounters.WorkingSetSize);
 270         else
 271             pPerfData[Idx].WorkingSetSizeDelta = 0;
 272         pPerfData[Idx].vmCounters.PageFaultCount = pSPI->vmCounters.PageFaultCount;
 273         if (pPDOld)
 274             pPerfData[Idx].PageFaultCountDelta = labs(pSPI->vmCounters.PageFaultCount - pPDOld->vmCounters.PageFaultCount);
 275         else
 276             pPerfData[Idx].PageFaultCountDelta = 0;
 277         pPerfData[Idx].vmCounters.VirtualSize = pSPI->vmCounters.VirtualSize;
 278         pPerfData[Idx].vmCounters.QuotaPagedPoolUsage = pSPI->vmCounters.QuotaPagedPoolUsage;
 279         pPerfData[Idx].vmCounters.QuotaNonPagedPoolUsage = pSPI->vmCounters.QuotaNonPagedPoolUsage;
 280         pPerfData[Idx].BasePriority = pSPI->dwBasePriority;
 281         pPerfData[Idx].HandleCount = pSPI->HandleCount;
 282         pPerfData[Idx].ThreadCount = pSPI->dwThreadCount;
 283         pPerfData[Idx].SessionId = pSPI->SessionId;
 284
 285         hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, (DWORD_PTR)pSPI->UniqueProcessId);
 286         if (hProcess) {
 287             if (OpenProcessToken(hProcess, TOKEN_QUERY|TOKEN_DUPLICATE|TOKEN_IMPERSONATE, &hProcessToken)) {
 288                 ImpersonateLoggedOnUser(hProcessToken);
 289                 memset(wszTemp, 0, sizeof(wszTemp));
 290                 dwSize = MAX_PATH;
 291                 GetUserNameW(wszTemp, &dwSize);
 292                 RevertToSelf();
 293                 CloseHandle(hProcessToken);
 294             }
 295             if (pGetGuiResources) {
 296                 pPerfData[Idx].USERObjectCount = pGetGuiResources(hProcess, GR_USEROBJECTS);
 297                 pPerfData[Idx].GDIObjectCount = pGetGuiResources(hProcess, GR_GDIOBJECTS);
 298             }
 299             if (pGetProcessIoCounters)
 300                 pGetProcessIoCounters(hProcess, &pPerfData[Idx].IOCounters);
 301             if (pIsWow64Process)
 302                 pIsWow64Process(hProcess, &pPerfData[Idx].Wow64Process);
 303             CloseHandle(hProcess);
 304         }
 305         pPerfData[Idx].UserTime.QuadPart = pSPI->UserTime.QuadPart;
 306         pPerfData[Idx].KernelTime.QuadPart = pSPI->KernelTime.QuadPart;
 307         pSPI = (PSYSTEM_PROCESS_INFORMATION)((LPBYTE)pSPI + pSPI->NextEntryOffset);
 308     }
 309     HeapFree(GetProcessHeap(), 0, pBuffer);
 310     LeaveCriticalSection(&PerfDataCriticalSection);
 311 }
 312
 313 ULONG PerfDataGetProcessCount(void)
 314 {
 315     return ProcessCount;
 316 }
 317
 318 ULONG PerfDataGetProcessorUsage(void)
 319 {
 320     if( dbIdleTime < 0.0 )
 321         return 0;
 322     if( dbIdleTime > 100.0 )
 323         return 100;
 324     return (ULONG)dbIdleTime;
 325 }
 326
 327 ULONG PerfDataGetProcessorSystemUsage(void)
 328 {
 329     if( dbKernelTime < 0.0 )
 330         return 0;
 331     if( dbKernelTime > 100.0 )
 332         return 100;
 333     return (ULONG)dbKernelTime;
 334 }
 335
 336 BOOL PerfDataGetImageName(ULONG Index, LPWSTR lpImageName, int nMaxCount)
 337 {
 338     static const WCHAR proc32W[] = {' ','*','3','2',0};
 339     BOOL    bSuccessful;
 340
 341     EnterCriticalSection(&PerfDataCriticalSection);
 342
 343     if (Index < ProcessCount) {
 344         wcsncpy(lpImageName, pPerfData[Index].ImageName, nMaxCount);
 345         if (pPerfData[Index].Wow64Process &&
 346             nMaxCount - lstrlenW(lpImageName) > 4 /* =lstrlenW(proc32W) */)
 347             lstrcatW(lpImageName, proc32W);
 348         bSuccessful = TRUE;
 349     } else {
 350         bSuccessful = FALSE;
 351     }
 352     LeaveCriticalSection(&PerfDataCriticalSection);
 353     return bSuccessful;
 354 }
 355
 356 ULONG PerfDataGetProcessId(ULONG Index)
 357 {
 358     ULONG    ProcessId;
 359
 360     EnterCriticalSection(&PerfDataCriticalSection);
 361
 362     if (Index < ProcessCount)
 363         ProcessId = pPerfData[Index].ProcessId;
 364     else
 365         ProcessId = 0;
 366
 367     LeaveCriticalSection(&PerfDataCriticalSection);
 368
 369     return ProcessId;
 370 }
 371
 372 BOOL PerfDataGetUserName(ULONG Index, LPWSTR lpUserName, int nMaxCount)
 373 {
 374     BOOL    bSuccessful;
 375
 376     EnterCriticalSection(&PerfDataCriticalSection);
 377
 378     if (Index < ProcessCount) {
 379         wcsncpy(lpUserName, pPerfData[Index].UserName, nMaxCount);
 380         bSuccessful = TRUE;
 381     } else {
 382         bSuccessful = FALSE;
 383     }
 384
 385     LeaveCriticalSection(&PerfDataCriticalSection);
 386
 387     return bSuccessful;
 388 }
 389
 390 ULONG PerfDataGetSessionId(ULONG Index)
 391 {
 392     ULONG    SessionId;
 393
 394     EnterCriticalSection(&PerfDataCriticalSection);
 395
 396     if (Index < ProcessCount)
 397         SessionId = pPerfData[Index].SessionId;
 398     else
 399         SessionId = 0;
 400
 401     LeaveCriticalSection(&PerfDataCriticalSection);
 402
 403     return SessionId;
 404 }
 405
 406 ULONG PerfDataGetCPUUsage(ULONG Index)
 407 {
 408     ULONG    CpuUsage;
 409
 410     EnterCriticalSection(&PerfDataCriticalSection);
 411
 412     if (Index < ProcessCount)
 413         CpuUsage = pPerfData[Index].CPUUsage;
 414     else
 415         CpuUsage = 0;
 416
 417     LeaveCriticalSection(&PerfDataCriticalSection);
 418
 419     return CpuUsage;
 420 }
 421
 422 TIME PerfDataGetCPUTime(ULONG Index)
 423 {
 424     TIME    CpuTime = {{0,0}};
 425
 426     EnterCriticalSection(&PerfDataCriticalSection);
 427
 428     if (Index < ProcessCount)
 429         CpuTime = pPerfData[Index].CPUTime;
 430
 431     LeaveCriticalSection(&PerfDataCriticalSection);
 432
 433     return CpuTime;
 434 }
 435
 436 ULONG PerfDataGetWorkingSetSizeBytes(ULONG Index)
 437 {
 438     ULONG    WorkingSetSizeBytes;
 439
 440     EnterCriticalSection(&PerfDataCriticalSection);
 441
 442     if (Index < ProcessCount)
 443         WorkingSetSizeBytes = pPerfData[Index].vmCounters.WorkingSetSize;
 444     else
 445         WorkingSetSizeBytes = 0;
 446
 447     LeaveCriticalSection(&PerfDataCriticalSection);
 448
 449     return WorkingSetSizeBytes;
 450 }
 451
 452 ULONG PerfDataGetPeakWorkingSetSizeBytes(ULONG Index)
 453 {
 454     ULONG    PeakWorkingSetSizeBytes;
 455
 456     EnterCriticalSection(&PerfDataCriticalSection);
 457
 458     if (Index < ProcessCount)
 459         PeakWorkingSetSizeBytes = pPerfData[Index].vmCounters.PeakWorkingSetSize;
 460     else
 461         PeakWorkingSetSizeBytes = 0;
 462
 463     LeaveCriticalSection(&PerfDataCriticalSection);
 464
 465     return PeakWorkingSetSizeBytes;
 466 }
 467
 468 ULONG PerfDataGetWorkingSetSizeDelta(ULONG Index)
 469 {
 470     ULONG    WorkingSetSizeDelta;
 471
 472     EnterCriticalSection(&PerfDataCriticalSection);
 473
 474     if (Index < ProcessCount)
 475         WorkingSetSizeDelta = pPerfData[Index].WorkingSetSizeDelta;
 476     else
 477         WorkingSetSizeDelta = 0;
 478
 479     LeaveCriticalSection(&PerfDataCriticalSection);
 480
 481     return WorkingSetSizeDelta;
 482 }
 483
 484 ULONG PerfDataGetPageFaultCount(ULONG Index)
 485 {
 486     ULONG    PageFaultCount;
 487
 488     EnterCriticalSection(&PerfDataCriticalSection);
 489
 490     if (Index < ProcessCount)
 491         PageFaultCount = pPerfData[Index].vmCounters.PageFaultCount;
 492     else
 493         PageFaultCount = 0;
 494
 495     LeaveCriticalSection(&PerfDataCriticalSection);
 496
 497     return PageFaultCount;
 498 }
 499
 500 ULONG PerfDataGetPageFaultCountDelta(ULONG Index)
 501 {
 502     ULONG    PageFaultCountDelta;
 503
 504     EnterCriticalSection(&PerfDataCriticalSection);
 505
 506     if (Index < ProcessCount)
 507         PageFaultCountDelta = pPerfData[Index].PageFaultCountDelta;
 508     else
 509         PageFaultCountDelta = 0;
 510
 511     LeaveCriticalSection(&PerfDataCriticalSection);
 512
 513     return PageFaultCountDelta;
 514 }
 515
 516 ULONG PerfDataGetVirtualMemorySizeBytes(ULONG Index)
 517 {
 518     ULONG    VirtualMemorySizeBytes;
 519
 520     EnterCriticalSection(&PerfDataCriticalSection);
 521
 522     if (Index < ProcessCount)
 523         VirtualMemorySizeBytes = pPerfData[Index].vmCounters.VirtualSize;
 524     else
 525         VirtualMemorySizeBytes = 0;
 526
 527     LeaveCriticalSection(&PerfDataCriticalSection);
 528
 529     return VirtualMemorySizeBytes;
 530 }
 531
 532 ULONG PerfDataGetPagedPoolUsagePages(ULONG Index)
 533 {
 534     ULONG    PagedPoolUsagePages;
 535
 536     EnterCriticalSection(&PerfDataCriticalSection);
 537
 538     if (Index < ProcessCount)
 539         PagedPoolUsagePages = pPerfData[Index].vmCounters.QuotaPagedPoolUsage;
 540     else
 541         PagedPoolUsagePages = 0;
 542
 543     LeaveCriticalSection(&PerfDataCriticalSection);
 544
 545     return PagedPoolUsagePages;
 546 }
 547
 548 ULONG PerfDataGetNonPagedPoolUsagePages(ULONG Index)
 549 {
 550     ULONG    NonPagedPoolUsagePages;
 551
 552     EnterCriticalSection(&PerfDataCriticalSection);
 553
 554     if (Index < ProcessCount)
 555         NonPagedPoolUsagePages = pPerfData[Index].vmCounters.QuotaNonPagedPoolUsage;
 556     else
 557         NonPagedPoolUsagePages = 0;
 558
 559     LeaveCriticalSection(&PerfDataCriticalSection);
 560
 561     return NonPagedPoolUsagePages;
 562 }
 563
 564 ULONG PerfDataGetBasePriority(ULONG Index)
 565 {
 566     ULONG    BasePriority;
 567
 568     EnterCriticalSection(&PerfDataCriticalSection);
 569
 570     if (Index < ProcessCount)
 571         BasePriority = pPerfData[Index].BasePriority;
 572     else
 573         BasePriority = 0;
 574
 575     LeaveCriticalSection(&PerfDataCriticalSection);
 576
 577     return BasePriority;
 578 }
 579
 580 ULONG PerfDataGetHandleCount(ULONG Index)
 581 {
 582     ULONG    HandleCount;
 583
 584     EnterCriticalSection(&PerfDataCriticalSection);
 585
 586     if (Index < ProcessCount)
 587         HandleCount = pPerfData[Index].HandleCount;
 588     else
 589         HandleCount = 0;
 590
 591     LeaveCriticalSection(&PerfDataCriticalSection);
 592
 593     return HandleCount;
 594 }
 595
 596 ULONG PerfDataGetThreadCount(ULONG Index)
 597 {
 598     ULONG    ThreadCount;
 599
 600     EnterCriticalSection(&PerfDataCriticalSection);
 601
 602     if (Index < ProcessCount)
 603         ThreadCount = pPerfData[Index].ThreadCount;
 604     else
 605         ThreadCount = 0;
 606
 607     LeaveCriticalSection(&PerfDataCriticalSection);
 608
 609     return ThreadCount;
 610 }
 611
 612 ULONG PerfDataGetUSERObjectCount(ULONG Index)
 613 {
 614     ULONG    USERObjectCount;
 615
 616     EnterCriticalSection(&PerfDataCriticalSection);
 617
 618     if (Index < ProcessCount)
 619         USERObjectCount = pPerfData[Index].USERObjectCount;
 620     else
 621         USERObjectCount = 0;
 622
 623     LeaveCriticalSection(&PerfDataCriticalSection);
 624
 625     return USERObjectCount;
 626 }
 627
 628 ULONG PerfDataGetGDIObjectCount(ULONG Index)
 629 {
 630     ULONG    GDIObjectCount;
 631
 632     EnterCriticalSection(&PerfDataCriticalSection);
 633
 634     if (Index < ProcessCount)
 635         GDIObjectCount = pPerfData[Index].GDIObjectCount;
 636     else
 637         GDIObjectCount = 0;
 638
 639     LeaveCriticalSection(&PerfDataCriticalSection);
 640
 641     return GDIObjectCount;
 642 }
 643
 644 BOOL PerfDataGetIOCounters(ULONG Index, PIO_COUNTERS pIoCounters)
 645 {
 646     BOOL    bSuccessful;
 647
 648     EnterCriticalSection(&PerfDataCriticalSection);
 649
 650     if (Index < ProcessCount)
 651     {
 652         memcpy(pIoCounters, &pPerfData[Index].IOCounters, sizeof(IO_COUNTERS));
 653         bSuccessful = TRUE;
 654     }
 655     else
 656         bSuccessful = FALSE;
 657
 658     LeaveCriticalSection(&PerfDataCriticalSection);
 659
 660     return bSuccessful;
 661 }
 662
 663 ULONG PerfDataGetCommitChargeTotalK(void)
 664 {
 665     ULONG    Total;
 666     ULONG    PageSize;
 667
 668     EnterCriticalSection(&PerfDataCriticalSection);
 669
 670     Total = SystemPerfInfo.TotalCommittedPages;
 671     PageSize = SystemBasicInfo.PageSize;
 672
 673     LeaveCriticalSection(&PerfDataCriticalSection);
 674
 675     Total = Total * (PageSize / 1024);
 676
 677     return Total;
 678 }
 679
 680 ULONG PerfDataGetCommitChargeLimitK(void)
 681 {
 682     ULONG    Limit;
 683     ULONG    PageSize;
 684
 685     EnterCriticalSection(&PerfDataCriticalSection);
 686
 687     Limit = SystemPerfInfo.TotalCommitLimit;
 688     PageSize = SystemBasicInfo.PageSize;
 689
 690     LeaveCriticalSection(&PerfDataCriticalSection);
 691
 692     Limit = Limit * (PageSize / 1024);
 693
 694     return Limit;
 695 }
 696
 697 ULONG PerfDataGetCommitChargePeakK(void)
 698 {
 699     ULONG    Peak;
 700     ULONG    PageSize;
 701
 702     EnterCriticalSection(&PerfDataCriticalSection);
 703
 704     Peak = SystemPerfInfo.PeakCommitment;
 705     PageSize = SystemBasicInfo.PageSize;
 706
 707     LeaveCriticalSection(&PerfDataCriticalSection);
 708
 709     Peak = Peak * (PageSize / 1024);
 710
 711     return Peak;
 712 }
 713
 714 ULONG PerfDataGetKernelMemoryTotalK(void)
 715 {
 716     ULONG    Total;
 717     ULONG    Paged;
 718     ULONG    NonPaged;
 719     ULONG    PageSize;
 720
 721     EnterCriticalSection(&PerfDataCriticalSection);
 722
 723     Paged = SystemPerfInfo.PagedPoolUsage;
 724     NonPaged = SystemPerfInfo.NonPagedPoolUsage;
 725     PageSize = SystemBasicInfo.PageSize;
 726
 727     LeaveCriticalSection(&PerfDataCriticalSection);
 728
 729     Paged = Paged * (PageSize / 1024);
 730     NonPaged = NonPaged * (PageSize / 1024);
 731
 732     Total = Paged + NonPaged;
 733
 734     return Total;
 735 }
 736
 737 ULONG PerfDataGetKernelMemoryPagedK(void)
 738 {
 739     ULONG    Paged;
 740     ULONG    PageSize;
 741
 742     EnterCriticalSection(&PerfDataCriticalSection);
 743
 744     Paged = SystemPerfInfo.PagedPoolUsage;
 745     PageSize = SystemBasicInfo.PageSize;
 746
 747     LeaveCriticalSection(&PerfDataCriticalSection);
 748
 749     Paged = Paged * (PageSize / 1024);
 750
 751     return Paged;
 752 }
 753
 754 ULONG PerfDataGetKernelMemoryNonPagedK(void)
 755 {
 756     ULONG    NonPaged;
 757     ULONG    PageSize;
 758
 759     EnterCriticalSection(&PerfDataCriticalSection);
 760
 761     NonPaged = SystemPerfInfo.NonPagedPoolUsage;
 762     PageSize = SystemBasicInfo.PageSize;
 763
 764     LeaveCriticalSection(&PerfDataCriticalSection);
 765
 766     NonPaged = NonPaged * (PageSize / 1024);
 767
 768     return NonPaged;
 769 }
 770
 771 ULONG PerfDataGetPhysicalMemoryTotalK(void)
 772 {
 773     ULONG    Total;
 774     ULONG    PageSize;
 775
 776     EnterCriticalSection(&PerfDataCriticalSection);
 777
 778     Total = SystemBasicInfo.MmNumberOfPhysicalPages;
 779     PageSize = SystemBasicInfo.PageSize;
 780
 781     LeaveCriticalSection(&PerfDataCriticalSection);
 782
 783     Total = Total * (PageSize / 1024);
 784
 785     return Total;
 786 }
 787
 788 ULONG PerfDataGetPhysicalMemoryAvailableK(void)
 789 {
 790     ULONG    Available;
 791     ULONG    PageSize;
 792
 793     EnterCriticalSection(&PerfDataCriticalSection);
 794
 795     Available = SystemPerfInfo.AvailablePages;
 796     PageSize = SystemBasicInfo.PageSize;
 797
 798     LeaveCriticalSection(&PerfDataCriticalSection);
 799
 800     Available = Available * (PageSize / 1024);
 801
 802     return Available;
 803 }
 804
 805 ULONG PerfDataGetPhysicalMemorySystemCacheK(void)
 806 {
 807     ULONG    SystemCache;
 808
 809     EnterCriticalSection(&PerfDataCriticalSection);
 810
 811     SystemCache = SystemCacheInfo.CurrentSize;
 812
 813     LeaveCriticalSection(&PerfDataCriticalSection);
 814
 815     SystemCache = SystemCache / 1024;
 816
 817     return SystemCache;
 818 }
 819
 820 ULONG PerfDataGetSystemHandleCount(void)
 821 {
 822     ULONG    HandleCount;
 823
 824     EnterCriticalSection(&PerfDataCriticalSection);
 825
 826     HandleCount = SystemHandleInfo.Count;
 827
 828     LeaveCriticalSection(&PerfDataCriticalSection);
 829
 830     return HandleCount;
 831 }
 832
 833 ULONG PerfDataGetTotalThreadCount(void)
 834 {
 835     ULONG    ThreadCount = 0;
 836     ULONG    i;
 837
 838     EnterCriticalSection(&PerfDataCriticalSection);
 839
 840     for (i=0; i<ProcessCount; i++)
 841     {
 842         ThreadCount += pPerfData[i].ThreadCount;
 843     }
 844
 845     LeaveCriticalSection(&PerfDataCriticalSection);
 846
 847     return ThreadCount;
 848 }