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