#include "precomp.h"
#include <aclapi.h>
#include <ndk/psfuncs.h>
#include <ndk/exfuncs.h>

Include dependency graph for perfdata.c:

Classes
struct	_SIDTOUSERNAME

Macros
#define	WIN32_LEAN_AND_MEAN

#define	NTOS_MODE_USER

#define	CMD_LINE_MIN(a, b) (a < b ? a - sizeof(WCHAR) : b)

Typedefs
typedef struct _SIDTOUSERNAME	SIDTOUSERNAME

typedef struct _SIDTOUSERNAME *	PSIDTOUSERNAME

Functions
BOOL	PerfDataInitialize (void)

void	PerfDataUninitialize (void)

static void	SidToUserName (PSID Sid, LPWSTR szBuffer, DWORD BufferSize)

VOID WINAPI	CachedGetUserFromSid (PSID pSid, LPWSTR pUserName, PULONG pcwcUserName)

void	PerfDataRefresh (void)

ULONG	PerfDataGetProcessIndex (ULONG pid)

ULONG	PerfDataGetProcessCount (void)

ULONG	PerfDataGetProcessorUsage (void)

ULONG	PerfDataGetProcessorSystemUsage (void)

BOOL	PerfDataGetImageName (ULONG Index, LPWSTR lpImageName, ULONG nMaxCount)

ULONG	PerfDataGetProcessId (ULONG Index)

BOOL	PerfDataGetUserName (ULONG Index, LPWSTR lpUserName, ULONG nMaxCount)

BOOL	PerfDataGetCommandLine (ULONG Index, LPWSTR lpCommandLine, ULONG nMaxCount)

void	PerfDataDeallocCommandLineCache ()

ULONG	PerfDataGetSessionId (ULONG Index)

ULONG	PerfDataGetCPUUsage (ULONG Index)

LARGE_INTEGER	PerfDataGetCPUTime (ULONG Index)

ULONG	PerfDataGetWorkingSetSizeBytes (ULONG Index)

ULONG	PerfDataGetPeakWorkingSetSizeBytes (ULONG Index)

ULONG	PerfDataGetWorkingSetSizeDelta (ULONG Index)

ULONG	PerfDataGetPageFaultCount (ULONG Index)

ULONG	PerfDataGetPageFaultCountDelta (ULONG Index)

ULONG	PerfDataGetVirtualMemorySizeBytes (ULONG Index)

ULONG	PerfDataGetPagedPoolUsagePages (ULONG Index)

ULONG	PerfDataGetNonPagedPoolUsagePages (ULONG Index)

ULONG	PerfDataGetBasePriority (ULONG Index)

ULONG	PerfDataGetHandleCount (ULONG Index)

ULONG	PerfDataGetThreadCount (ULONG Index)

ULONG	PerfDataGetUSERObjectCount (ULONG Index)

ULONG	PerfDataGetGDIObjectCount (ULONG Index)

BOOL	PerfDataGetIOCounters (ULONG Index, PIO_COUNTERS pIoCounters)

ULONG	PerfDataGetCommitChargeTotalK (void)

ULONG	PerfDataGetCommitChargeLimitK (void)

ULONG	PerfDataGetCommitChargePeakK (void)

ULONG	PerfDataGetKernelMemoryTotalK (void)

ULONG	PerfDataGetKernelMemoryPagedK (void)

ULONG	PerfDataGetKernelMemoryNonPagedK (void)

ULONG	PerfDataGetPhysicalMemoryTotalK (void)

ULONG	PerfDataGetPhysicalMemoryAvailableK (void)

ULONG	PerfDataGetPhysicalMemorySystemCacheK (void)

ULONG	PerfDataGetSystemHandleCount (void)

ULONG	PerfDataGetTotalThreadCount (void)

BOOL	PerfDataGet (ULONG Index, PPERFDATA *lppData)

Variables
CRITICAL_SECTION	PerfDataCriticalSection

PPERFDATA	pPerfDataOld = NULL

PPERFDATA	pPerfData = NULL

ULONG	ProcessCountOld = 0

ULONG	ProcessCount = 0

double	dbIdleTime

double	dbKernelTime

double	dbSystemTime

LARGE_INTEGER	liOldIdleTime = {{0,0}}

double	OldKernelTime = 0

LARGE_INTEGER	liOldSystemTime = {{0,0}}

SYSTEM_PERFORMANCE_INFORMATION	SystemPerfInfo

SYSTEM_BASIC_INFORMATION	SystemBasicInfo

SYSTEM_FILECACHE_INFORMATION	SystemCacheInfo

ULONG	SystemNumberOfHandles

PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION	SystemProcessorTimeInfo = NULL

PSID	SystemUserSid = NULL

PCMD_LINE_CACHE	global_cache = NULL

static LIST_ENTRY	SidToUserNameHead = {&SidToUserNameHead, &SidToUserNameHead}

Macro Definition Documentation

◆ CMD_LINE_MIN

#define CMD_LINE_MIN	(	a,
		b
	)	(a < b ? a - sizeof(WCHAR) : b)

Definition at line 53 of file perfdata.c.

◆ NTOS_MODE_USER

#define NTOS_MODE_USER

Definition at line 29 of file perfdata.c.

◆ WIN32_LEAN_AND_MEAN

#define WIN32_LEAN_AND_MEAN

Definition at line 26 of file perfdata.c.

Typedef Documentation

◆ PSIDTOUSERNAME

typedef struct _SIDTOUSERNAME * PSIDTOUSERNAME

◆ SIDTOUSERNAME

typedef struct _SIDTOUSERNAME SIDTOUSERNAME

Function Documentation

◆ CachedGetUserFromSid()

VOID WINAPI CachedGetUserFromSid	(	PSID	pSid,
		LPWSTR	pUserName,
		PULONG	pcwcUserName
	)

Definition at line 127 of file perfdata.c.

 {
     PLIST_ENTRY pCur;
     PSIDTOUSERNAME pEntry;
     ULONG cbSid, cwcUserName;
 
     cwcUserName = *pcwcUserName;
 
     /* Walk through the list */
     for(pCur = SidToUserNameHead.Flink;
         pCur != &SidToUserNameHead;
         pCur = pCur->Flink)
     {
         pEntry = CONTAINING_RECORD(pCur, SIDTOUSERNAME, List);
         if (EqualSid((PSID)&pEntry->Data, pSid))
         {
             wcsncpy(pUserName, pEntry->pszName, cwcUserName);
             *pcwcUserName = wcslen(pUserName);
             return;
         }
     }
 
     /* We didn't find the SID in the list, get the name conventional */
     SidToUserName(pSid, pUserName, cwcUserName);
     *pcwcUserName = wcslen(pUserName);
 
     /* Allocate a new entry */
     cwcUserName = *pcwcUserName + 1;
     cbSid = GetLengthSid(pSid);
     pEntry = HeapAlloc(GetProcessHeap(), 0, sizeof(SIDTOUSERNAME) + cbSid + cwcUserName * sizeof(WCHAR));
 
     /* Copy the Sid and name to our entry */
     CopySid(cbSid, (PSID)&pEntry->Data, pSid);
     pEntry->pszName = (LPWSTR)(pEntry->Data + cbSid);
     wcsncpy(pEntry->pszName, pUserName, cwcUserName);
 
     /* Insert the new entry */
     pEntry->List.Flink = &SidToUserNameHead;
     pEntry->List.Blink = SidToUserNameHead.Blink;
     SidToUserNameHead.Blink->Flink = &pEntry->List;
     SidToUserNameHead.Blink = &pEntry->List;
 
     return;
 }

Referenced by PerfDataRefresh().

◆ PerfDataDeallocCommandLineCache()

void PerfDataDeallocCommandLineCache ( )

Definition at line 650 of file perfdata.c.

 {
     PCMD_LINE_CACHE cache = global_cache;
     PCMD_LINE_CACHE cache_old;
 
     while (cache && cache->pnext != NULL)
     {
         cache_old = cache;
         cache = cache->pnext;
 
         HeapFree(GetProcessHeap(), 0, cache_old);
     }
 }

Referenced by TaskManagerWndProc().

◆ PerfDataGet()

BOOL PerfDataGet	(	ULONG	Index,
		PPERFDATA *	lppData
	)

Definition at line 1124 of file perfdata.c.

 {
     BOOL  bSuccessful = FALSE;
 
     EnterCriticalSection(&PerfDataCriticalSection);
     if (Index < ProcessCount)
     {
         *lppData = pPerfData + Index;
         bSuccessful = TRUE;
     }
     LeaveCriticalSection(&PerfDataCriticalSection);
     return bSuccessful;
 }

◆ PerfDataGetBasePriority()

ULONG PerfDataGetBasePriority ( ULONG Index )

Definition at line 838 of file perfdata.c.

 {
     ULONG  BasePriority;
 
     EnterCriticalSection(&PerfDataCriticalSection);
 
     if (Index < ProcessCount)
         BasePriority = pPerfData[Index].BasePriority;
     else
         BasePriority = 0;
 
     LeaveCriticalSection(&PerfDataCriticalSection);
 
     return BasePriority;
 }

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

◆ PerfDataGetCommandLine()

BOOL PerfDataGetCommandLine	(	ULONG	Index,
		LPWSTR	lpCommandLine,
		ULONG	nMaxCount
	)

Definition at line 540 of file perfdata.c.

 {
     static const LPWSTR ellipsis = L"...";
 
     PROCESS_BASIC_INFORMATION pbi = {0};
     UNICODE_STRING CommandLineStr = {0};
 
     PVOID ProcessParams = NULL;
     HANDLE hProcess;
     ULONG ProcessId;
 
     NTSTATUS Status;
     BOOL result;
 
     PCMD_LINE_CACHE new_entry;
     LPWSTR new_string;
 
     PCMD_LINE_CACHE cache = global_cache;
 
     /* [A] Search for a string already in cache? If so, use it */
     while (cache && cache->pnext != NULL)
     {
         if (cache->idx == Index && cache->str != NULL)
         {
             /* Found it. Use it, and add some ellipsis at the very end to make it cute */
             wcsncpy(lpCommandLine, cache->str, CMD_LINE_MIN(nMaxCount, cache->len));
             wcscpy(lpCommandLine + CMD_LINE_MIN(nMaxCount, cache->len) - wcslen(ellipsis), ellipsis);
             return TRUE;
         }
 
         cache = cache->pnext;
     }
 
     /* [B] We don't; let's allocate and load a value from the process mem... and cache it */
     ProcessId = PerfDataGetProcessId(Index);
 
     /* Default blank command line in case things don't work out */
     wcsncpy(lpCommandLine, L"", nMaxCount);
 
     /* Ask for a handle to the target process so that we can read its memory and query stuff */
     hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, ProcessId);
     if (!hProcess)
         goto cleanup;
 
     /* First off, get the ProcessEnvironmentBlock location in that process' address space */
     Status = NtQueryInformationProcess(hProcess, 0, &pbi, sizeof(pbi), NULL);
     if (!NT_SUCCESS(Status))
         goto cleanup;
 
     /* Then get the PEB.ProcessParameters member pointer */
     result = ReadProcessMemory(hProcess,
                                (PVOID)((ULONG_PTR)pbi.PebBaseAddress + FIELD_OFFSET(PEB, ProcessParameters)),
                                &ProcessParams,
                                sizeof(ProcessParams),
                                NULL);
     if (!result)
         goto cleanup;
 
     /* Then copy the PEB->ProcessParameters.CommandLine member
        to get the pointer to the string buffer and its size */
     result = ReadProcessMemory(hProcess,
                                (PVOID)((ULONG_PTR)ProcessParams + FIELD_OFFSET(RTL_USER_PROCESS_PARAMETERS, CommandLine)),
                                &CommandLineStr,
                                sizeof(CommandLineStr),
                                NULL);
     if (!result)
         goto cleanup;
 
     /* Allocate the next cache entry and its accompanying string in one go */
     new_entry = HeapAlloc(GetProcessHeap(),
                           HEAP_ZERO_MEMORY,
                           sizeof(CMD_LINE_CACHE) + CommandLineStr.Length + sizeof(UNICODE_NULL));
     if (!new_entry)
         goto cleanup;
 
     new_string = (LPWSTR)((ULONG_PTR)new_entry + sizeof(CMD_LINE_CACHE));
 
     /* Bingo, the command line should be stored there,
        copy the string from the other process */
     result = ReadProcessMemory(hProcess,
                                CommandLineStr.Buffer,
                                new_string,
                                CommandLineStr.Length,
                                NULL);
     if (!result)
     {
         /* Weird, after successfully reading the mem of that process
            various times it fails now, forget it and bail out */
         HeapFree(GetProcessHeap(), 0, new_entry);
         goto cleanup;
     }
 
     /* Add our pointer to the cache... */
     new_entry->idx = Index;
     new_entry->str = new_string;
     new_entry->len = CommandLineStr.Length;
 
     if (!global_cache)
         global_cache = new_entry;
     else
         cache->pnext = new_entry;
 
     /* ... and print the buffer for the first time */
     wcsncpy(lpCommandLine, new_string, CMD_LINE_MIN(nMaxCount, CommandLineStr.Length));
 
 cleanup:
     if (hProcess) CloseHandle(hProcess);
     return TRUE;
 }

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

◆ PerfDataGetCommitChargeLimitK()

ULONG PerfDataGetCommitChargeLimitK ( void )

Definition at line 954 of file perfdata.c.

 {
     ULONG  Limit;
     ULONG  PageSize;
 
     EnterCriticalSection(&PerfDataCriticalSection);
 
     Limit = SystemPerfInfo.CommitLimit;
     PageSize = SystemBasicInfo.PageSize;
 
     LeaveCriticalSection(&PerfDataCriticalSection);
 
     Limit = Limit * (PageSize / 1024);
 
     return Limit;
 }

Referenced by Graph_DrawMemUsageGraph(), and PerformancePageRefreshThread().

◆ PerfDataGetCommitChargePeakK()

ULONG PerfDataGetCommitChargePeakK ( void )

Definition at line 971 of file perfdata.c.

 {
     ULONG  Peak;
     ULONG  PageSize;
 
     EnterCriticalSection(&PerfDataCriticalSection);
 
     Peak = SystemPerfInfo.PeakCommitment;
     PageSize = SystemBasicInfo.PageSize;
 
     LeaveCriticalSection(&PerfDataCriticalSection);
 
     Peak = Peak * (PageSize / 1024);
 
     return Peak;
 }

Referenced by PerformancePageRefreshThread().

◆ PerfDataGetCommitChargeTotalK()

ULONG PerfDataGetCommitChargeTotalK ( void )

Definition at line 937 of file perfdata.c.

 {
     ULONG  Total;
     ULONG  PageSize;
 
     EnterCriticalSection(&PerfDataCriticalSection);
 
     Total = SystemPerfInfo.CommittedPages;
     PageSize = SystemBasicInfo.PageSize;
 
     LeaveCriticalSection(&PerfDataCriticalSection);
 
     Total = Total * (PageSize / 1024);
 
     return Total;
 }

Referenced by Graph_DrawMemUsageGraph(), and PerformancePageRefreshThread().

◆ PerfDataGetCPUTime()

LARGE_INTEGER PerfDataGetCPUTime ( ULONG Index )

Definition at line 696 of file perfdata.c.

 {
     LARGE_INTEGER  CpuTime = {{0,0}};
 
     EnterCriticalSection(&PerfDataCriticalSection);
 
     if (Index < ProcessCount)
         CpuTime = pPerfData[Index].CPUTime;
 
     LeaveCriticalSection(&PerfDataCriticalSection);
 
     return CpuTime;
 }

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

◆ PerfDataGetCPUUsage()

ULONG PerfDataGetCPUUsage ( ULONG Index )

Definition at line 680 of file perfdata.c.

 {
     ULONG  CpuUsage;
 
     EnterCriticalSection(&PerfDataCriticalSection);
 
     if (Index < ProcessCount)
         CpuUsage = pPerfData[Index].CPUUsage;
     else
         CpuUsage = 0;
 
     LeaveCriticalSection(&PerfDataCriticalSection);
 
     return CpuUsage;
 }

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

◆ PerfDataGetGDIObjectCount()

ULONG PerfDataGetGDIObjectCount ( ULONG Index )

Definition at line 902 of file perfdata.c.

 {
     ULONG  GDIObjectCount;
 
     EnterCriticalSection(&PerfDataCriticalSection);
 
     if (Index < ProcessCount)
         GDIObjectCount = pPerfData[Index].GDIObjectCount;
     else
         GDIObjectCount = 0;
 
     LeaveCriticalSection(&PerfDataCriticalSection);
 
     return GDIObjectCount;
 }

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

◆ PerfDataGetHandleCount()

ULONG PerfDataGetHandleCount ( ULONG Index )

Definition at line 854 of file perfdata.c.

 {
     ULONG  HandleCount;
 
     EnterCriticalSection(&PerfDataCriticalSection);
 
     if (Index < ProcessCount)
         HandleCount = pPerfData[Index].HandleCount;
     else
         HandleCount = 0;
 
     LeaveCriticalSection(&PerfDataCriticalSection);
 
     return HandleCount;
 }

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

◆ PerfDataGetImageName()

BOOL PerfDataGetImageName	(	ULONG	Index,
		LPWSTR	lpImageName,
		ULONG	nMaxCount
	)

Definition at line 490 of file perfdata.c.

 {
     BOOL  bSuccessful;
 
     EnterCriticalSection(&PerfDataCriticalSection);
 
     if (Index < ProcessCount) {
         wcsncpy(lpImageName, pPerfData[Index].ImageName, nMaxCount);
         bSuccessful = TRUE;
     } else {
         bSuccessful = FALSE;
     }
     LeaveCriticalSection(&PerfDataCriticalSection);
     return bSuccessful;
 }

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

◆ PerfDataGetIOCounters()

BOOL PerfDataGetIOCounters	(	ULONG	Index,
		PIO_COUNTERS	pIoCounters
	)

Definition at line 918 of file perfdata.c.

 {
     BOOL  bSuccessful;
 
     EnterCriticalSection(&PerfDataCriticalSection);
 
     if (Index < ProcessCount)
     {
         memcpy(pIoCounters, &pPerfData[Index].IOCounters, sizeof(IO_COUNTERS));
         bSuccessful = TRUE;
     }
     else
         bSuccessful = FALSE;
 
     LeaveCriticalSection(&PerfDataCriticalSection);
 
     return bSuccessful;
 }

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

◆ PerfDataGetKernelMemoryNonPagedK()

ULONG PerfDataGetKernelMemoryNonPagedK ( void )

Definition at line 1028 of file perfdata.c.

 {
     ULONG  NonPaged;
     ULONG  PageSize;
 
     EnterCriticalSection(&PerfDataCriticalSection);
 
     NonPaged = SystemPerfInfo.NonPagedPoolPages;
     PageSize = SystemBasicInfo.PageSize;
 
     LeaveCriticalSection(&PerfDataCriticalSection);
 
     NonPaged = NonPaged * (PageSize / 1024);
 
     return NonPaged;
 }

Referenced by PerformancePageRefreshThread().

◆ PerfDataGetKernelMemoryPagedK()

ULONG PerfDataGetKernelMemoryPagedK ( void )

Definition at line 1011 of file perfdata.c.

 {
     ULONG  Paged;
     ULONG  PageSize;
 
     EnterCriticalSection(&PerfDataCriticalSection);
 
     Paged = SystemPerfInfo.PagedPoolPages;
     PageSize = SystemBasicInfo.PageSize;
 
     LeaveCriticalSection(&PerfDataCriticalSection);
 
     Paged = Paged * (PageSize / 1024);
 
     return Paged;
 }

Referenced by PerformancePageRefreshThread().

◆ PerfDataGetKernelMemoryTotalK()

ULONG PerfDataGetKernelMemoryTotalK ( void )

Definition at line 988 of file perfdata.c.

 {
     ULONG  Total;
     ULONG  Paged;
     ULONG  NonPaged;
     ULONG  PageSize;
 
     EnterCriticalSection(&PerfDataCriticalSection);
 
     Paged = SystemPerfInfo.PagedPoolPages;
     NonPaged = SystemPerfInfo.NonPagedPoolPages;
     PageSize = SystemBasicInfo.PageSize;
 
     LeaveCriticalSection(&PerfDataCriticalSection);
 
     Paged = Paged * (PageSize / 1024);
     NonPaged = NonPaged * (PageSize / 1024);
 
     Total = Paged + NonPaged;
 
     return Total;
 }

Referenced by PerformancePageRefreshThread().

◆ PerfDataGetNonPagedPoolUsagePages()

ULONG PerfDataGetNonPagedPoolUsagePages ( ULONG Index )

Definition at line 822 of file perfdata.c.

 {
     ULONG  NonPagedPoolUsage;
 
     EnterCriticalSection(&PerfDataCriticalSection);
 
     if (Index < ProcessCount)
         NonPagedPoolUsage = pPerfData[Index].NonPagedPoolUsagePages;
     else
         NonPagedPoolUsage = 0;
 
     LeaveCriticalSection(&PerfDataCriticalSection);
 
     return NonPagedPoolUsage;
 }

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

◆ PerfDataGetPagedPoolUsagePages()

ULONG PerfDataGetPagedPoolUsagePages ( ULONG Index )

Definition at line 806 of file perfdata.c.

 {
     ULONG  PagedPoolUsage;
 
     EnterCriticalSection(&PerfDataCriticalSection);
 
     if (Index < ProcessCount)
         PagedPoolUsage = pPerfData[Index].PagedPoolUsagePages;
     else
         PagedPoolUsage = 0;
 
     LeaveCriticalSection(&PerfDataCriticalSection);
 
     return PagedPoolUsage;
 }

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

◆ PerfDataGetPageFaultCount()

ULONG PerfDataGetPageFaultCount ( ULONG Index )

Definition at line 758 of file perfdata.c.

 {
     ULONG  PageFaultCount;
 
     EnterCriticalSection(&PerfDataCriticalSection);
 
     if (Index < ProcessCount)
         PageFaultCount = pPerfData[Index].PageFaultCount;
     else
         PageFaultCount = 0;
 
     LeaveCriticalSection(&PerfDataCriticalSection);
 
     return PageFaultCount;
 }

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

◆ PerfDataGetPageFaultCountDelta()

ULONG PerfDataGetPageFaultCountDelta ( ULONG Index )

Definition at line 774 of file perfdata.c.

 {
     ULONG  PageFaultCountDelta;
 
     EnterCriticalSection(&PerfDataCriticalSection);
 
     if (Index < ProcessCount)
         PageFaultCountDelta = pPerfData[Index].PageFaultCountDelta;
     else
         PageFaultCountDelta = 0;
 
     LeaveCriticalSection(&PerfDataCriticalSection);
 
     return PageFaultCountDelta;
 }

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

◆ PerfDataGetPeakWorkingSetSizeBytes()

ULONG PerfDataGetPeakWorkingSetSizeBytes ( ULONG Index )

Definition at line 726 of file perfdata.c.

 {
     ULONG  PeakWorkingSetSizeBytes;
 
     EnterCriticalSection(&PerfDataCriticalSection);
 
     if (Index < ProcessCount)
         PeakWorkingSetSizeBytes = pPerfData[Index].PeakWorkingSetSizeBytes;
     else
         PeakWorkingSetSizeBytes = 0;
 
     LeaveCriticalSection(&PerfDataCriticalSection);
 
     return PeakWorkingSetSizeBytes;
 }

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

◆ PerfDataGetPhysicalMemoryAvailableK()

ULONG PerfDataGetPhysicalMemoryAvailableK ( void )

Definition at line 1062 of file perfdata.c.

 {
     ULONG  Available;
     ULONG  PageSize;
 
     EnterCriticalSection(&PerfDataCriticalSection);
 
     Available = SystemPerfInfo.AvailablePages;
     PageSize = SystemBasicInfo.PageSize;
 
     LeaveCriticalSection(&PerfDataCriticalSection);
 
     Available = Available * (PageSize / 1024);
 
     return Available;
 }

Referenced by PerformancePageRefreshThread().

◆ PerfDataGetPhysicalMemorySystemCacheK()

ULONG PerfDataGetPhysicalMemorySystemCacheK ( void )

Definition at line 1079 of file perfdata.c.

 {
     ULONG  SystemCache;
     ULONG  PageSize;
 
     EnterCriticalSection(&PerfDataCriticalSection);
 
     PageSize = SystemBasicInfo.PageSize;
     SystemCache = SystemCacheInfo.CurrentSizeIncludingTransitionInPages * PageSize;
 
     LeaveCriticalSection(&PerfDataCriticalSection);
 
     return SystemCache / 1024;
 }

Referenced by PerformancePageRefreshThread().

◆ PerfDataGetPhysicalMemoryTotalK()

ULONG PerfDataGetPhysicalMemoryTotalK ( void )

Definition at line 1045 of file perfdata.c.

 {
     ULONG  Total;
     ULONG  PageSize;
 
     EnterCriticalSection(&PerfDataCriticalSection);
 
     Total = SystemBasicInfo.NumberOfPhysicalPages;
     PageSize = SystemBasicInfo.PageSize;
 
     LeaveCriticalSection(&PerfDataCriticalSection);
 
     Total = Total * (PageSize / 1024);
 
     return Total;
 }

Referenced by PerformancePageRefreshThread().

◆ PerfDataGetProcessCount()

ULONG PerfDataGetProcessCount ( void )

Definition at line 463 of file perfdata.c.

 {
     ULONG Result;
     EnterCriticalSection(&PerfDataCriticalSection);
     Result = ProcessCount;
     LeaveCriticalSection(&PerfDataCriticalSection);
     return Result;
 }

Referenced by PerformancePageRefreshThread(), and UpdateProcesses().

◆ PerfDataGetProcessId()

ULONG PerfDataGetProcessId ( ULONG Index )

Definition at line 506 of file perfdata.c.

 {
     ULONG  ProcessId;
 
     EnterCriticalSection(&PerfDataCriticalSection);
 
     if (Index < ProcessCount)
         ProcessId = PtrToUlong(pPerfData[Index].ProcessId);
     else
         ProcessId = 0;
 
     LeaveCriticalSection(&PerfDataCriticalSection);
 
     return ProcessId;
 }

Referenced by AddProcess(), PerfDataGetCommandLine(), and PerfDataGetText().

◆ PerfDataGetProcessIndex()

ULONG PerfDataGetProcessIndex ( ULONG pid )

Definition at line 440 of file perfdata.c.

 {
     ULONG idx;
 
     EnterCriticalSection(&PerfDataCriticalSection);
 
     for (idx = 0; idx < ProcessCount; idx++)
     {
         if (PtrToUlong(pPerfData[idx].ProcessId) == pid)
         {
             break;
         }
     }
 
     LeaveCriticalSection(&PerfDataCriticalSection);
 
     if (idx == ProcessCount)
     {
         return -1;
     }
     return idx;
 }

Referenced by ProcessPageCompareFunc(), and ProcessPageOnNotify().

◆ PerfDataGetProcessorSystemUsage()

ULONG PerfDataGetProcessorSystemUsage ( void )

Definition at line 481 of file perfdata.c.

 {
     ULONG Result;
     EnterCriticalSection(&PerfDataCriticalSection);
     Result = (ULONG)dbKernelTime;
     LeaveCriticalSection(&PerfDataCriticalSection);
     return Result;
 }

Referenced by Graph_DrawCpuUsageGraph(), and PerformancePageRefreshThread().

◆ PerfDataGetProcessorUsage()

ULONG PerfDataGetProcessorUsage ( void )

Definition at line 472 of file perfdata.c.

 {
     ULONG Result;
     EnterCriticalSection(&PerfDataCriticalSection);
     Result = (ULONG)dbIdleTime;
     LeaveCriticalSection(&PerfDataCriticalSection);
     return Result;
 }

Referenced by Graph_DrawCpuUsageGraph(), PerformancePageRefreshThread(), TrayIcon_GetProcessorUsageIcon(), TrayIcon_ShellAddTrayIcon(), and TrayIcon_ShellUpdateTrayIcon().

◆ PerfDataGetSessionId()

ULONG PerfDataGetSessionId ( ULONG Index )

Definition at line 664 of file perfdata.c.

 {
     ULONG  SessionId;
 
     EnterCriticalSection(&PerfDataCriticalSection);
 
     if (Index < ProcessCount)
         SessionId = pPerfData[Index].SessionId;
     else
         SessionId = 0;
 
     LeaveCriticalSection(&PerfDataCriticalSection);
 
     return SessionId;
 }

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

◆ PerfDataGetSystemHandleCount()

ULONG PerfDataGetSystemHandleCount ( void )

Definition at line 1094 of file perfdata.c.

 {
     ULONG  HandleCount;
 
     EnterCriticalSection(&PerfDataCriticalSection);
 
     HandleCount = SystemNumberOfHandles;
 
     LeaveCriticalSection(&PerfDataCriticalSection);
 
     return HandleCount;
 }

Referenced by PerformancePageRefreshThread().

◆ PerfDataGetThreadCount()

ULONG PerfDataGetThreadCount ( ULONG Index )

Definition at line 870 of file perfdata.c.

 {
     ULONG  ThreadCount;
 
     EnterCriticalSection(&PerfDataCriticalSection);
 
     if (Index < ProcessCount)
         ThreadCount = pPerfData[Index].ThreadCount;
     else
         ThreadCount = 0;
 
     LeaveCriticalSection(&PerfDataCriticalSection);
 
     return ThreadCount;
 }

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

◆ PerfDataGetTotalThreadCount()

ULONG PerfDataGetTotalThreadCount ( void )

Definition at line 1107 of file perfdata.c.

 {
     ULONG  ThreadCount = 0;
     ULONG  i;
 
     EnterCriticalSection(&PerfDataCriticalSection);
 
     for (i=0; i<ProcessCount; i++)
     {
         ThreadCount += pPerfData[i].ThreadCount;
     }
 
     LeaveCriticalSection(&PerfDataCriticalSection);
 
     return ThreadCount;
 }

Referenced by PerformancePageRefreshThread().

◆ PerfDataGetUserName()

BOOL PerfDataGetUserName	(	ULONG	Index,
		LPWSTR	lpUserName,
		ULONG	nMaxCount
	)

Definition at line 522 of file perfdata.c.

 {
     BOOL  bSuccessful;
 
     EnterCriticalSection(&PerfDataCriticalSection);
 
     if (Index < ProcessCount) {
         wcsncpy(lpUserName, pPerfData[Index].UserName, nMaxCount);
         bSuccessful = TRUE;
     } else {
         bSuccessful = FALSE;
     }
 
     LeaveCriticalSection(&PerfDataCriticalSection);
 
     return bSuccessful;
 }

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

◆ PerfDataGetUSERObjectCount()

ULONG PerfDataGetUSERObjectCount ( ULONG Index )

Definition at line 886 of file perfdata.c.

 {
     ULONG  USERObjectCount;
 
     EnterCriticalSection(&PerfDataCriticalSection);
 
     if (Index < ProcessCount)
         USERObjectCount = pPerfData[Index].USERObjectCount;
     else
         USERObjectCount = 0;
 
     LeaveCriticalSection(&PerfDataCriticalSection);
 
     return USERObjectCount;
 }

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

◆ PerfDataGetVirtualMemorySizeBytes()

ULONG PerfDataGetVirtualMemorySizeBytes ( ULONG Index )

Definition at line 790 of file perfdata.c.

 {
     ULONG  VirtualMemorySizeBytes;
 
     EnterCriticalSection(&PerfDataCriticalSection);
 
     if (Index < ProcessCount)
         VirtualMemorySizeBytes = pPerfData[Index].VirtualMemorySizeBytes;
     else
         VirtualMemorySizeBytes = 0;
 
     LeaveCriticalSection(&PerfDataCriticalSection);
 
     return VirtualMemorySizeBytes;
 }

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

◆ PerfDataGetWorkingSetSizeBytes()

ULONG PerfDataGetWorkingSetSizeBytes ( ULONG Index )

Definition at line 710 of file perfdata.c.

 {
     ULONG  WorkingSetSizeBytes;
 
     EnterCriticalSection(&PerfDataCriticalSection);
 
     if (Index < ProcessCount)
         WorkingSetSizeBytes = pPerfData[Index].WorkingSetSizeBytes;
     else
         WorkingSetSizeBytes = 0;
 
     LeaveCriticalSection(&PerfDataCriticalSection);
 
     return WorkingSetSizeBytes;
 }

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

◆ PerfDataGetWorkingSetSizeDelta()

ULONG PerfDataGetWorkingSetSizeDelta ( ULONG Index )

Definition at line 742 of file perfdata.c.

 {
     ULONG  WorkingSetSizeDelta;
 
     EnterCriticalSection(&PerfDataCriticalSection);
 
     if (Index < ProcessCount)
         WorkingSetSizeDelta = pPerfData[Index].WorkingSetSizeDelta;
     else
         WorkingSetSizeDelta = 0;
 
     LeaveCriticalSection(&PerfDataCriticalSection);
 
     return WorkingSetSizeDelta;
 }

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

◆ PerfDataInitialize()

BOOL PerfDataInitialize ( void )

Definition at line 64 of file perfdata.c.

 {
     SID_IDENTIFIER_AUTHORITY NtSidAuthority = {SECURITY_NT_AUTHORITY};
     NTSTATUS    status;
 
     InitializeCriticalSection(&PerfDataCriticalSection);
 
     /*
      * Get number of processors in the system
      */
     status = NtQuerySystemInformation(SystemBasicInformation, &SystemBasicInfo, sizeof(SystemBasicInfo), NULL);
     if (!NT_SUCCESS(status))
         return FALSE;
 
     /*
      * Create the SYSTEM Sid
      */
     AllocateAndInitializeSid(&NtSidAuthority, 1, SECURITY_LOCAL_SYSTEM_RID, 0, 0, 0, 0, 0, 0, 0, &SystemUserSid);
     return TRUE;
 }

Referenced by wWinMain().

◆ PerfDataRefresh()

void PerfDataRefresh ( void )

Definition at line 175 of file perfdata.c.

 {
     ULONG                                      ulSize;
     NTSTATUS                                   status;
     LPBYTE                                     pBuffer;
     ULONG                                      BufferSize;
     PSYSTEM_PROCESS_INFORMATION                pSPI;
     PPERFDATA                                  pPDOld;
     ULONG                                      Idx, Idx2;
     HANDLE                                     hProcess;
     HANDLE                                     hProcessToken;
     SYSTEM_PERFORMANCE_INFORMATION             SysPerfInfo;
     SYSTEM_TIMEOFDAY_INFORMATION               SysTimeInfo;
     SYSTEM_FILECACHE_INFORMATION               SysCacheInfo;
     SYSTEM_HANDLE_INFORMATION                  SysHandleInfoData;
     PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION  SysProcessorTimeInfo;
     double                                     CurrentKernelTime;
     PSECURITY_DESCRIPTOR                       ProcessSD;
     PSID                                       ProcessUser;
     ULONG                                      Buffer[64]; /* must be 4 bytes aligned! */
     ULONG                                      cwcUserName;
 
     /* Get new system time */
     status = NtQuerySystemInformation(SystemTimeOfDayInformation, &SysTimeInfo, sizeof(SysTimeInfo), NULL);
     if (!NT_SUCCESS(status))
         return;
 
     /* Get new CPU's idle time */
     status = NtQuerySystemInformation(SystemPerformanceInformation, &SysPerfInfo, sizeof(SysPerfInfo), NULL);
     if (!NT_SUCCESS(status))
         return;
 
     /* Get system cache information */
     status = NtQuerySystemInformation(SystemFileCacheInformation, &SysCacheInfo, sizeof(SysCacheInfo), NULL);
     if (!NT_SUCCESS(status))
         return;
 
     /* Get processor time information */
     SysProcessorTimeInfo = (PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION)HeapAlloc(GetProcessHeap(), 0, sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION) * SystemBasicInfo.NumberOfProcessors);
     status = NtQuerySystemInformation(SystemProcessorPerformanceInformation, SysProcessorTimeInfo, sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION) * SystemBasicInfo.NumberOfProcessors, &ulSize);
 
     if (!NT_SUCCESS(status))
     {
         if (SysProcessorTimeInfo != NULL)
             HeapFree(GetProcessHeap(), 0, SysProcessorTimeInfo);
         return;
     }
 
     /* Get handle information
      * Number of handles is enough, no need for data array.
      */
     status = NtQuerySystemInformation(SystemHandleInformation, &SysHandleInfoData, sizeof(SysHandleInfoData), NULL);
     /* On unexpected error, reuse previous value.
      * STATUS_SUCCESS (0-1 handle) should never happen.
      */
     if (status != STATUS_INFO_LENGTH_MISMATCH)
         SysHandleInfoData.NumberOfHandles = SystemNumberOfHandles;
 
     /* Get process information
      * We don't know how much data there is so just keep
      * increasing the buffer size until the call succeeds
      */
     BufferSize = 0;
     do
     {
         BufferSize += 0x10000;
         pBuffer = (LPBYTE)HeapAlloc(GetProcessHeap(), 0, BufferSize);
 
         status = NtQuerySystemInformation(SystemProcessInformation, pBuffer, BufferSize, &ulSize);
 
         if (status == STATUS_INFO_LENGTH_MISMATCH) {
             HeapFree(GetProcessHeap(), 0, pBuffer);
         }
 
     } while (status == STATUS_INFO_LENGTH_MISMATCH);
 
     EnterCriticalSection(&PerfDataCriticalSection);
 
     /*
      * Save system performance info
      */
     memcpy(&SystemPerfInfo, &SysPerfInfo, sizeof(SYSTEM_PERFORMANCE_INFORMATION));
 
     /*
      * Save system cache info
      */
     memcpy(&SystemCacheInfo, &SysCacheInfo, sizeof(SYSTEM_FILECACHE_INFORMATION));
 
     /*
      * Save system processor time info
      */
     if (SystemProcessorTimeInfo) {
         HeapFree(GetProcessHeap(), 0, SystemProcessorTimeInfo);
     }
     SystemProcessorTimeInfo = SysProcessorTimeInfo;
 
     /*
      * Save system handle info
      */
     SystemNumberOfHandles = SysHandleInfoData.NumberOfHandles;
 
     for (CurrentKernelTime=0, Idx=0; Idx<(ULONG)SystemBasicInfo.NumberOfProcessors; Idx++) {
         CurrentKernelTime += Li2Double(SystemProcessorTimeInfo[Idx].KernelTime);
         CurrentKernelTime += Li2Double(SystemProcessorTimeInfo[Idx].DpcTime);
         CurrentKernelTime += Li2Double(SystemProcessorTimeInfo[Idx].InterruptTime);
     }
 
     /* If it's a first call - skip idle time calcs */
     if (liOldIdleTime.QuadPart != 0) {
         /*  CurrentValue = NewValue - OldValue */
         dbIdleTime = Li2Double(SysPerfInfo.IdleProcessTime) - Li2Double(liOldIdleTime);
         dbKernelTime = CurrentKernelTime - OldKernelTime;
         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.NumberOfProcessors; /* + 0.5; */
         dbKernelTime = 100.0 - dbKernelTime * 100.0 / (double)SystemBasicInfo.NumberOfProcessors; /* + 0.5; */
     }
 
     /* Store new CPU's idle and system time */
     liOldIdleTime = SysPerfInfo.IdleProcessTime;
     liOldSystemTime = SysTimeInfo.CurrentTime;
     OldKernelTime = CurrentKernelTime;
 
     /* Determine the process count
      * We loop through the data we got from NtQuerySystemInformation
      * and count how many structures there are (until RelativeOffset is 0)
      */
     ProcessCountOld = ProcessCount;
     ProcessCount = 0;
     pSPI = (PSYSTEM_PROCESS_INFORMATION)pBuffer;
     while (pSPI) {
         ProcessCount++;
         if (pSPI->NextEntryOffset == 0)
             break;
         pSPI = (PSYSTEM_PROCESS_INFORMATION)((LPBYTE)pSPI + pSPI->NextEntryOffset);
     }
 
     /* Now alloc a new PERFDATA array and fill in the data */
     pPerfData = (PPERFDATA)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 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;
         if (pPerfDataOld) {
             for (Idx2=0; Idx2<ProcessCountOld; Idx2++) {
                 if (pPerfDataOld[Idx2].ProcessId == pSPI->UniqueProcessId) {
                     pPDOld = &pPerfDataOld[Idx2];
                     break;
                 }
             }
         }
 
         if (pSPI->ImageName.Buffer) {
             /* Don't assume a UNICODE_STRING Buffer is zero terminated: */
             int len = pSPI->ImageName.Length / 2;
             /* Check against max size and allow for terminating zero (already zeroed): */
             if(len >= MAX_PATH)len=MAX_PATH - 1;
             wcsncpy(pPerfData[Idx].ImageName, pSPI->ImageName.Buffer, len);
         } else {
             LoadStringW(hInst, IDS_IDLE_PROCESS, pPerfData[Idx].ImageName,
                        sizeof(pPerfData[Idx].ImageName) / sizeof(pPerfData[Idx].ImageName[0]));
         }
 
         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.NumberOfProcessors; /* + 0.5; */
             pPerfData[Idx].CPUUsage = (ULONG)CpuTime;
         }
         pPerfData[Idx].CPUTime.QuadPart = pSPI->UserTime.QuadPart + pSPI->KernelTime.QuadPart;
         pPerfData[Idx].WorkingSetSizeBytes = pSPI->WorkingSetSize;
         pPerfData[Idx].PeakWorkingSetSizeBytes = pSPI->PeakWorkingSetSize;
         if (pPDOld)
             pPerfData[Idx].WorkingSetSizeDelta = labs((LONG)pSPI->WorkingSetSize - (LONG)pPDOld->WorkingSetSizeBytes);
         else
             pPerfData[Idx].WorkingSetSizeDelta = 0;
         pPerfData[Idx].PageFaultCount = pSPI->PageFaultCount;
         if (pPDOld)
             pPerfData[Idx].PageFaultCountDelta = labs((LONG)pSPI->PageFaultCount - (LONG)pPDOld->PageFaultCount);
         else
             pPerfData[Idx].PageFaultCountDelta = 0;
         pPerfData[Idx].VirtualMemorySizeBytes = pSPI->VirtualSize;
         pPerfData[Idx].PagedPoolUsagePages = pSPI->QuotaPeakPagedPoolUsage;
         pPerfData[Idx].NonPagedPoolUsagePages = pSPI->QuotaPeakNonPagedPoolUsage;
         pPerfData[Idx].BasePriority = pSPI->BasePriority;
         pPerfData[Idx].HandleCount = pSPI->HandleCount;
         pPerfData[Idx].ThreadCount = pSPI->NumberOfThreads;
         pPerfData[Idx].SessionId = pSPI->SessionId;
         pPerfData[Idx].UserName[0] = UNICODE_NULL;
         pPerfData[Idx].USERObjectCount = 0;
         pPerfData[Idx].GDIObjectCount = 0;
         ProcessUser = SystemUserSid;
         ProcessSD = NULL;
 
         if (pSPI->UniqueProcessId != NULL) {
             hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | READ_CONTROL, FALSE, PtrToUlong(pSPI->UniqueProcessId));
             if (hProcess) {
                 /* don't query the information of the system process. It's possible but
                    returns Administrators as the owner of the process instead of SYSTEM */
                 if (pSPI->UniqueProcessId != (HANDLE)0x4)
                 {
                     if (OpenProcessToken(hProcess, TOKEN_QUERY, &hProcessToken))
                     {
                         DWORD RetLen = 0;
                         BOOL Ret;
 
                         Ret = GetTokenInformation(hProcessToken, TokenUser, (LPVOID)Buffer, sizeof(Buffer), &RetLen);
                         CloseHandle(hProcessToken);
 
                         if (Ret)
                             ProcessUser = ((PTOKEN_USER)Buffer)->User.Sid;
                         else
                             goto ReadProcOwner;
                     }
                     else
                     {
 ReadProcOwner:
                         GetSecurityInfo(hProcess, SE_KERNEL_OBJECT, OWNER_SECURITY_INFORMATION, &ProcessUser, NULL, NULL, NULL, &ProcessSD);
                     }
 
                     pPerfData[Idx].USERObjectCount = GetGuiResources(hProcess, GR_USEROBJECTS);
                     pPerfData[Idx].GDIObjectCount = GetGuiResources(hProcess, GR_GDIOBJECTS);
                 }
 
                 GetProcessIoCounters(hProcess, &pPerfData[Idx].IOCounters);
                 CloseHandle(hProcess);
             } else {
                 goto ClearInfo;
             }
         } else {
 ClearInfo:
             /* clear information we were unable to fetch */
             ZeroMemory(&pPerfData[Idx].IOCounters, sizeof(IO_COUNTERS));
         }
 
         cwcUserName = sizeof(pPerfData[0].UserName) / sizeof(pPerfData[0].UserName[0]);
         CachedGetUserFromSid(ProcessUser, pPerfData[Idx].UserName, &cwcUserName);
 
         if (ProcessSD != NULL)
         {
             LocalFree((HLOCAL)ProcessSD);
         }
 
         pPerfData[Idx].UserTime.QuadPart = pSPI->UserTime.QuadPart;
         pPerfData[Idx].KernelTime.QuadPart = pSPI->KernelTime.QuadPart;
         pSPI = (PSYSTEM_PROCESS_INFORMATION)((LPBYTE)pSPI + pSPI->NextEntryOffset);
     }
     HeapFree(GetProcessHeap(), 0, pBuffer);
     if (pPerfDataOld) {
         HeapFree(GetProcessHeap(), 0, pPerfDataOld);
     }
     pPerfDataOld = pPerfData;
     LeaveCriticalSection(&PerfDataCriticalSection);
 }

Referenced by OnCreate(), and TaskManagerWndProc().

◆ PerfDataUninitialize()

void PerfDataUninitialize ( void )

Definition at line 85 of file perfdata.c.

 {
     PLIST_ENTRY pCur;
     PSIDTOUSERNAME pEntry;
 
     if (pPerfData != NULL)
         HeapFree(GetProcessHeap(), 0, pPerfData);
 
     DeleteCriticalSection(&PerfDataCriticalSection);
 
     if (SystemUserSid != NULL)
     {
         FreeSid(SystemUserSid);
         SystemUserSid = NULL;
     }
 
     /* Free user names cache list */
     pCur = SidToUserNameHead.Flink;
     while (pCur != &SidToUserNameHead)
     {
         pEntry = CONTAINING_RECORD(pCur, SIDTOUSERNAME, List);
         pCur = pCur->Flink;
         HeapFree(GetProcessHeap(), 0, pEntry);
     }
 
     if (SystemProcessorTimeInfo) {
         HeapFree(GetProcessHeap(), 0, SystemProcessorTimeInfo);
     }
 }

Referenced by wWinMain().

◆ SidToUserName()

static void SidToUserName	(	PSID	Sid,
		LPWSTR	szBuffer,
		DWORD	BufferSize
	)

static

Definition at line 115 of file perfdata.c.

 {
     static WCHAR szDomainNameUnused[255];
     DWORD DomainNameLen = sizeof(szDomainNameUnused) / sizeof(szDomainNameUnused[0]);
     SID_NAME_USE Use;
 
     if (Sid != NULL)
         LookupAccountSidW(NULL, Sid, szBuffer, &BufferSize, szDomainNameUnused, &DomainNameLen, &Use);
 }