perfdata.c File Reference

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

Include dependency graph for perfdata.c:

Go to the source code of this file.

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
SYSTEM_HANDLE_INFORMATION	SystemHandleInfo
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.

Referenced by PerfDataGetCommandLine().

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.

Referenced by PerfDataRefresh().

{
    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 = cwcUserName;
            return;
        }
    }

    /* We didn't find the SID in the list, get the name conventional */
    SidToUserName(pSid, pUserName, cwcUserName);

    /* Allocate a new entry */
    *pcwcUserName = wcslen(pUserName);
    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;
}

PerfDataDeallocCommandLineCache()

void PerfDataDeallocCommandLineCache

(

)

Definition at line 659 of file perfdata.c.

Referenced by TaskManagerWndProc().

{
    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);
    }
}

PerfDataGet()

BOOL PerfDataGet	(	ULONG	Index,
		PPERFDATA *	lppData
	)

Definition at line 1133 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 847 of file perfdata.c.

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

{
    ULONG  BasePriority;

    EnterCriticalSection(&PerfDataCriticalSection);

    if (Index < ProcessCount)
        BasePriority = pPerfData[Index].BasePriority;
    else
        BasePriority = 0;

    LeaveCriticalSection(&PerfDataCriticalSection);

    return BasePriority;
}

PerfDataGetCommandLine()

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

Definition at line 549 of file perfdata.c.

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

{
    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;
}

PerfDataGetCommitChargeLimitK()

ULONG PerfDataGetCommitChargeLimitK

(

void

)

Definition at line 963 of file perfdata.c.

Referenced by Graph_DrawMemUsageGraph(), and PerformancePageRefreshThread().

{
    ULONG  Limit;
    ULONG  PageSize;

    EnterCriticalSection(&PerfDataCriticalSection);

    Limit = SystemPerfInfo.CommitLimit;
    PageSize = SystemBasicInfo.PageSize;

    LeaveCriticalSection(&PerfDataCriticalSection);

    Limit = Limit * (PageSize / 1024);

    return Limit;
}

PerfDataGetCommitChargePeakK()

ULONG PerfDataGetCommitChargePeakK

(

void

)

Definition at line 980 of file perfdata.c.

Referenced by PerformancePageRefreshThread().

{
    ULONG  Peak;
    ULONG  PageSize;

    EnterCriticalSection(&PerfDataCriticalSection);

    Peak = SystemPerfInfo.PeakCommitment;
    PageSize = SystemBasicInfo.PageSize;

    LeaveCriticalSection(&PerfDataCriticalSection);

    Peak = Peak * (PageSize / 1024);

    return Peak;
}

PerfDataGetCommitChargeTotalK()

ULONG PerfDataGetCommitChargeTotalK

(

void

)

Definition at line 946 of file perfdata.c.

Referenced by Graph_DrawMemUsageGraph(), and PerformancePageRefreshThread().

{
    ULONG  Total;
    ULONG  PageSize;

    EnterCriticalSection(&PerfDataCriticalSection);

    Total = SystemPerfInfo.CommittedPages;
    PageSize = SystemBasicInfo.PageSize;

    LeaveCriticalSection(&PerfDataCriticalSection);

    Total = Total * (PageSize / 1024);

    return Total;
}

PerfDataGetCPUTime()

LARGE_INTEGER PerfDataGetCPUTime

(

ULONG

Index

)

Definition at line 705 of file perfdata.c.

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

{
    LARGE_INTEGER  CpuTime = {{0,0}};

    EnterCriticalSection(&PerfDataCriticalSection);

    if (Index < ProcessCount)
        CpuTime = pPerfData[Index].CPUTime;

    LeaveCriticalSection(&PerfDataCriticalSection);

    return CpuTime;
}

PerfDataGetCPUUsage()

ULONG PerfDataGetCPUUsage

(

ULONG

Index

)

Definition at line 689 of file perfdata.c.

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

{
    ULONG  CpuUsage;

    EnterCriticalSection(&PerfDataCriticalSection);

    if (Index < ProcessCount)
        CpuUsage = pPerfData[Index].CPUUsage;
    else
        CpuUsage = 0;

    LeaveCriticalSection(&PerfDataCriticalSection);

    return CpuUsage;
}

PerfDataGetGDIObjectCount()

ULONG PerfDataGetGDIObjectCount

(

ULONG

Index

)

Definition at line 911 of file perfdata.c.

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

{
    ULONG  GDIObjectCount;

    EnterCriticalSection(&PerfDataCriticalSection);

    if (Index < ProcessCount)
        GDIObjectCount = pPerfData[Index].GDIObjectCount;
    else
        GDIObjectCount = 0;

    LeaveCriticalSection(&PerfDataCriticalSection);

    return GDIObjectCount;
}

PerfDataGetHandleCount()

ULONG PerfDataGetHandleCount

(

ULONG

Index

)

Definition at line 863 of file perfdata.c.

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

{
    ULONG  HandleCount;

    EnterCriticalSection(&PerfDataCriticalSection);

    if (Index < ProcessCount)
        HandleCount = pPerfData[Index].HandleCount;
    else
        HandleCount = 0;

    LeaveCriticalSection(&PerfDataCriticalSection);

    return HandleCount;
}

PerfDataGetImageName()

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

Definition at line 499 of file perfdata.c.

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

{
    BOOL  bSuccessful;

    EnterCriticalSection(&PerfDataCriticalSection);

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

PerfDataGetIOCounters()

BOOL PerfDataGetIOCounters	(	ULONG	Index,
		PIO_COUNTERS	pIoCounters
	)

Definition at line 927 of file perfdata.c.

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

{
    BOOL  bSuccessful;

    EnterCriticalSection(&PerfDataCriticalSection);

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

    LeaveCriticalSection(&PerfDataCriticalSection);

    return bSuccessful;
}

PerfDataGetKernelMemoryNonPagedK()

ULONG PerfDataGetKernelMemoryNonPagedK

(

void

)

Definition at line 1037 of file perfdata.c.

Referenced by PerformancePageRefreshThread().

{
    ULONG  NonPaged;
    ULONG  PageSize;

    EnterCriticalSection(&PerfDataCriticalSection);

    NonPaged = SystemPerfInfo.NonPagedPoolPages;
    PageSize = SystemBasicInfo.PageSize;

    LeaveCriticalSection(&PerfDataCriticalSection);

    NonPaged = NonPaged * (PageSize / 1024);

    return NonPaged;
}

PerfDataGetKernelMemoryPagedK()

ULONG PerfDataGetKernelMemoryPagedK

(

void

)

Definition at line 1020 of file perfdata.c.

Referenced by PerformancePageRefreshThread().

{
    ULONG  Paged;
    ULONG  PageSize;

    EnterCriticalSection(&PerfDataCriticalSection);

    Paged = SystemPerfInfo.PagedPoolPages;
    PageSize = SystemBasicInfo.PageSize;

    LeaveCriticalSection(&PerfDataCriticalSection);

    Paged = Paged * (PageSize / 1024);

    return Paged;
}

PerfDataGetKernelMemoryTotalK()

ULONG PerfDataGetKernelMemoryTotalK

(

void

)

Definition at line 997 of file perfdata.c.

Referenced by PerformancePageRefreshThread().

{
    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;
}

PerfDataGetNonPagedPoolUsagePages()

ULONG PerfDataGetNonPagedPoolUsagePages

(

ULONG

Index

)

Definition at line 831 of file perfdata.c.

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

{
    ULONG  NonPagedPoolUsage;

    EnterCriticalSection(&PerfDataCriticalSection);

    if (Index < ProcessCount)
        NonPagedPoolUsage = pPerfData[Index].NonPagedPoolUsagePages;
    else
        NonPagedPoolUsage = 0;

    LeaveCriticalSection(&PerfDataCriticalSection);

    return NonPagedPoolUsage;
}

PerfDataGetPagedPoolUsagePages()

ULONG PerfDataGetPagedPoolUsagePages

(

ULONG

Index

)

Definition at line 815 of file perfdata.c.

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

{
    ULONG  PagedPoolUsage;

    EnterCriticalSection(&PerfDataCriticalSection);

    if (Index < ProcessCount)
        PagedPoolUsage = pPerfData[Index].PagedPoolUsagePages;
    else
        PagedPoolUsage = 0;

    LeaveCriticalSection(&PerfDataCriticalSection);

    return PagedPoolUsage;
}

PerfDataGetPageFaultCount()

ULONG PerfDataGetPageFaultCount

(

ULONG

Index

)

Definition at line 767 of file perfdata.c.

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

{
    ULONG  PageFaultCount;

    EnterCriticalSection(&PerfDataCriticalSection);

    if (Index < ProcessCount)
        PageFaultCount = pPerfData[Index].PageFaultCount;
    else
        PageFaultCount = 0;

    LeaveCriticalSection(&PerfDataCriticalSection);

    return PageFaultCount;
}

PerfDataGetPageFaultCountDelta()

ULONG PerfDataGetPageFaultCountDelta

(

ULONG

Index

)

Definition at line 783 of file perfdata.c.

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

{
    ULONG  PageFaultCountDelta;

    EnterCriticalSection(&PerfDataCriticalSection);

    if (Index < ProcessCount)
        PageFaultCountDelta = pPerfData[Index].PageFaultCountDelta;
    else
        PageFaultCountDelta = 0;

    LeaveCriticalSection(&PerfDataCriticalSection);

    return PageFaultCountDelta;
}

PerfDataGetPeakWorkingSetSizeBytes()

ULONG PerfDataGetPeakWorkingSetSizeBytes

(

ULONG

Index

)

Definition at line 735 of file perfdata.c.

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

{
    ULONG  PeakWorkingSetSizeBytes;

    EnterCriticalSection(&PerfDataCriticalSection);

    if (Index < ProcessCount)
        PeakWorkingSetSizeBytes = pPerfData[Index].PeakWorkingSetSizeBytes;
    else
        PeakWorkingSetSizeBytes = 0;

    LeaveCriticalSection(&PerfDataCriticalSection);

    return PeakWorkingSetSizeBytes;
}

PerfDataGetPhysicalMemoryAvailableK()

ULONG PerfDataGetPhysicalMemoryAvailableK

(

void

)

Definition at line 1071 of file perfdata.c.

Referenced by PerformancePageRefreshThread().

{
    ULONG  Available;
    ULONG  PageSize;

    EnterCriticalSection(&PerfDataCriticalSection);

    Available = SystemPerfInfo.AvailablePages;
    PageSize = SystemBasicInfo.PageSize;

    LeaveCriticalSection(&PerfDataCriticalSection);

    Available = Available * (PageSize / 1024);

    return Available;
}

PerfDataGetPhysicalMemorySystemCacheK()

ULONG PerfDataGetPhysicalMemorySystemCacheK

(

void

)

Definition at line 1088 of file perfdata.c.

Referenced by PerformancePageRefreshThread().

{
    ULONG  SystemCache;
    ULONG  PageSize;

    EnterCriticalSection(&PerfDataCriticalSection);

    PageSize = SystemBasicInfo.PageSize;
    SystemCache = SystemCacheInfo.CurrentSizeIncludingTransitionInPages * PageSize;

    LeaveCriticalSection(&PerfDataCriticalSection);

    return SystemCache / 1024;
}

PerfDataGetPhysicalMemoryTotalK()

ULONG PerfDataGetPhysicalMemoryTotalK

(

void

)

Definition at line 1054 of file perfdata.c.

Referenced by PerformancePageRefreshThread().

{
    ULONG  Total;
    ULONG  PageSize;

    EnterCriticalSection(&PerfDataCriticalSection);

    Total = SystemBasicInfo.NumberOfPhysicalPages;
    PageSize = SystemBasicInfo.PageSize;

    LeaveCriticalSection(&PerfDataCriticalSection);

    Total = Total * (PageSize / 1024);

    return Total;
}

PerfDataGetProcessCount()

ULONG PerfDataGetProcessCount

(

void

)

Definition at line 472 of file perfdata.c.

Referenced by PerformancePageRefreshThread(), and UpdateProcesses().

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

PerfDataGetProcessId()

ULONG PerfDataGetProcessId

(

ULONG

Index

)

Definition at line 515 of file perfdata.c.

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

{
    ULONG  ProcessId;

    EnterCriticalSection(&PerfDataCriticalSection);

    if (Index < ProcessCount)
        ProcessId = PtrToUlong(pPerfData[Index].ProcessId);
    else
        ProcessId = 0;

    LeaveCriticalSection(&PerfDataCriticalSection);

    return ProcessId;
}

PerfDataGetProcessIndex()

ULONG PerfDataGetProcessIndex

(

ULONG

pid

)

Definition at line 449 of file perfdata.c.

Referenced by ProcessPageCompareFunc(), and ProcessPageOnNotify().

{
    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;
}

PerfDataGetProcessorSystemUsage()

ULONG PerfDataGetProcessorSystemUsage

(

void

)

Definition at line 490 of file perfdata.c.

Referenced by Graph_DrawCpuUsageGraph(), and PerformancePageRefreshThread().

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

PerfDataGetProcessorUsage()

ULONG PerfDataGetProcessorUsage

(

void

)

Definition at line 481 of file perfdata.c.

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

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

PerfDataGetSessionId()

ULONG PerfDataGetSessionId

(

ULONG

Index

)

Definition at line 673 of file perfdata.c.

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

{
    ULONG  SessionId;

    EnterCriticalSection(&PerfDataCriticalSection);

    if (Index < ProcessCount)
        SessionId = pPerfData[Index].SessionId;
    else
        SessionId = 0;

    LeaveCriticalSection(&PerfDataCriticalSection);

    return SessionId;
}

PerfDataGetSystemHandleCount()

ULONG PerfDataGetSystemHandleCount

(

void

)

Definition at line 1103 of file perfdata.c.

Referenced by PerformancePageRefreshThread().

{
    ULONG  HandleCount;

    EnterCriticalSection(&PerfDataCriticalSection);

    HandleCount = SystemHandleInfo.NumberOfHandles;

    LeaveCriticalSection(&PerfDataCriticalSection);

    return HandleCount;
}

PerfDataGetThreadCount()

ULONG PerfDataGetThreadCount

(

ULONG

Index

)

Definition at line 879 of file perfdata.c.

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

{
    ULONG  ThreadCount;

    EnterCriticalSection(&PerfDataCriticalSection);

    if (Index < ProcessCount)
        ThreadCount = pPerfData[Index].ThreadCount;
    else
        ThreadCount = 0;

    LeaveCriticalSection(&PerfDataCriticalSection);

    return ThreadCount;
}

PerfDataGetTotalThreadCount()

ULONG PerfDataGetTotalThreadCount

(

void

)

Definition at line 1116 of file perfdata.c.

Referenced by PerformancePageRefreshThread().

{
    ULONG  ThreadCount = 0;
    ULONG  i;

    EnterCriticalSection(&PerfDataCriticalSection);

    for (i=0; i<ProcessCount; i++)
    {
        ThreadCount += pPerfData[i].ThreadCount;
    }

    LeaveCriticalSection(&PerfDataCriticalSection);

    return ThreadCount;
}

PerfDataGetUserName()

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

Definition at line 531 of file perfdata.c.

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

{
    BOOL  bSuccessful;

    EnterCriticalSection(&PerfDataCriticalSection);

    if (Index < ProcessCount) {
        wcsncpy(lpUserName, pPerfData[Index].UserName, nMaxCount);
        bSuccessful = TRUE;
    } else {
        bSuccessful = FALSE;
    }

    LeaveCriticalSection(&PerfDataCriticalSection);

    return bSuccessful;
}

PerfDataGetUSERObjectCount()

ULONG PerfDataGetUSERObjectCount

(

ULONG

Index

)

Definition at line 895 of file perfdata.c.

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

{
    ULONG  USERObjectCount;

    EnterCriticalSection(&PerfDataCriticalSection);

    if (Index < ProcessCount)
        USERObjectCount = pPerfData[Index].USERObjectCount;
    else
        USERObjectCount = 0;

    LeaveCriticalSection(&PerfDataCriticalSection);

    return USERObjectCount;
}

PerfDataGetVirtualMemorySizeBytes()

ULONG PerfDataGetVirtualMemorySizeBytes

(

ULONG

Index

)

Definition at line 799 of file perfdata.c.

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

{
    ULONG  VirtualMemorySizeBytes;

    EnterCriticalSection(&PerfDataCriticalSection);

    if (Index < ProcessCount)
        VirtualMemorySizeBytes = pPerfData[Index].VirtualMemorySizeBytes;
    else
        VirtualMemorySizeBytes = 0;

    LeaveCriticalSection(&PerfDataCriticalSection);

    return VirtualMemorySizeBytes;
}

PerfDataGetWorkingSetSizeBytes()

ULONG PerfDataGetWorkingSetSizeBytes

(

ULONG

Index

)

Definition at line 719 of file perfdata.c.

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

{
    ULONG  WorkingSetSizeBytes;

    EnterCriticalSection(&PerfDataCriticalSection);

    if (Index < ProcessCount)
        WorkingSetSizeBytes = pPerfData[Index].WorkingSetSizeBytes;
    else
        WorkingSetSizeBytes = 0;

    LeaveCriticalSection(&PerfDataCriticalSection);

    return WorkingSetSizeBytes;
}

PerfDataGetWorkingSetSizeDelta()

ULONG PerfDataGetWorkingSetSizeDelta

(

ULONG

Index

)

Definition at line 751 of file perfdata.c.

Referenced by PerfDataGetText(), and ProcessPageCompareFunc().

{
    ULONG  WorkingSetSizeDelta;

    EnterCriticalSection(&PerfDataCriticalSection);

    if (Index < ProcessCount)
        WorkingSetSizeDelta = pPerfData[Index].WorkingSetSizeDelta;
    else
        WorkingSetSizeDelta = 0;

    LeaveCriticalSection(&PerfDataCriticalSection);

    return WorkingSetSizeDelta;
}

PerfDataInitialize()

BOOL PerfDataInitialize

(

void

)

Definition at line 64 of file perfdata.c.

Referenced by wWinMain().

{
    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;
}

PerfDataRefresh()

void PerfDataRefresh

(

void

)

Definition at line 175 of file perfdata.c.

Referenced by OnCreate(), and TaskManagerWndProc().

{
    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;
    LPBYTE                                     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
     * 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;
        SysHandleInfoData = (LPBYTE)HeapAlloc(GetProcessHeap(), 0, BufferSize);

        status = NtQuerySystemInformation(SystemHandleInformation, SysHandleInfoData, BufferSize, &ulSize);

        if (status == STATUS_INFO_LENGTH_MISMATCH) {
            HeapFree(GetProcessHeap(), 0, SysHandleInfoData);
        }

    } while (status == STATUS_INFO_LENGTH_MISMATCH);

    /* 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
     */
    memcpy(&SystemHandleInfo, SysHandleInfoData, sizeof(SYSTEM_HANDLE_INFORMATION));
    HeapFree(GetProcessHeap(), 0, SysHandleInfoData);

    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);
}

PerfDataUninitialize()

void PerfDataUninitialize

(

void

)

Definition at line 85 of file perfdata.c.

Referenced by wWinMain().

{
    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);
    }
}

SidToUserName()

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

static

Definition at line 115 of file perfdata.c.

Referenced by CachedGetUserFromSid().

{
    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);
}

Variable Documentation

dbIdleTime

double dbIdleTime

Definition at line 38 of file perfdata.c.

Referenced by PerfDataGetProcessorUsage(), and PerfDataRefresh().

dbKernelTime

double dbKernelTime

Definition at line 39 of file perfdata.c.

Referenced by PerfDataGetProcessorSystemUsage(), and PerfDataRefresh().

dbSystemTime

double dbSystemTime

Definition at line 40 of file perfdata.c.

Referenced by PerfDataRefresh().

global_cache

PCMD_LINE_CACHE global_cache = NULL

Definition at line 51 of file perfdata.c.

Referenced by PerfDataDeallocCommandLineCache(), and PerfDataGetCommandLine().

liOldIdleTime

LARGE_INTEGER liOldIdleTime = {{0,0}}

Definition at line 41 of file perfdata.c.

liOldSystemTime

LARGE_INTEGER liOldSystemTime = {{0,0}}

Definition at line 43 of file perfdata.c.

OldKernelTime

double OldKernelTime = 0

Definition at line 42 of file perfdata.c.

Referenced by PerfDataRefresh().

PerfDataCriticalSection

CRITICAL_SECTION PerfDataCriticalSection

Definition at line 33 of file perfdata.c.

pPerfData

PPERFDATA pPerfData = NULL

Definition at line 35 of file perfdata.c.

Referenced by PerfDataRefresh().

pPerfDataOld

PPERFDATA pPerfDataOld = NULL

Definition at line 34 of file perfdata.c.

ProcessCount

ULONG ProcessCount = 0

Definition at line 37 of file perfdata.c.

Referenced by PerfDataGet(), PerfDataGetBasePriority(), PerfDataGetCPUTime(), PerfDataGetCPUUsage(), PerfDataGetGDIObjectCount(), PerfDataGetHandleCount(), PerfDataGetImageName(), PerfDataGetIOCounters(), PerfDataGetNonPagedPoolUsagePages(), PerfDataGetPagedPoolUsagePages(), PerfDataGetPageFaultCount(), PerfDataGetPageFaultCountDelta(), PerfDataGetPeakWorkingSetSizeBytes(), PerfDataGetProcessCount(), PerfDataGetProcessId(), PerfDataGetProcessIndex(), PerfDataGetSessionId(), PerfDataGetThreadCount(), PerfDataGetTotalThreadCount(), PerfDataGetUserName(), PerfDataGetUSERObjectCount(), PerfDataGetVirtualMemorySizeBytes(), PerfDataGetWorkingSetSizeBytes(), PerfDataGetWorkingSetSizeDelta(), PerfDataRefresh(), and PspCreateProcess().

ProcessCountOld

ULONG ProcessCountOld = 0

Definition at line 36 of file perfdata.c.

Referenced by PerfDataRefresh().

SidToUserNameHead

LIST_ENTRY SidToUserNameHead = {&SidToUserNameHead, &SidToUserNameHead}

static

Definition at line 62 of file perfdata.c.

Referenced by CachedGetUserFromSid().

SystemBasicInfo

SYSTEM_BASIC_INFORMATION SystemBasicInfo

Definition at line 45 of file perfdata.c.

Referenced by GetPerformanceInfo(), IntVideoPortFindAdapter(), and RtlpCreateUserStack().

SystemCacheInfo

SYSTEM_FILECACHE_INFORMATION SystemCacheInfo

Definition at line 46 of file perfdata.c.

SystemHandleInfo

SYSTEM_HANDLE_INFORMATION SystemHandleInfo

Definition at line 47 of file perfdata.c.

SystemPerfInfo

SYSTEM_PERFORMANCE_INFORMATION SystemPerfInfo

Definition at line 44 of file perfdata.c.

Referenced by GetPerformanceInfo().

SystemProcessorTimeInfo

PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION SystemProcessorTimeInfo = NULL

Definition at line 48 of file perfdata.c.

SystemUserSid

PSID SystemUserSid = NULL

Definition at line 49 of file perfdata.c.

Referenced by PerfDataRefresh().