perfdata.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_PERFDATA
struct	_CMD_LINE_CACHE

Macros
#define	Li2Double(x)   ((double)((x).HighPart) * 4.294967296E9 + (double)((x).LowPart))

Typedefs
typedef struct _PERFDATA	PERFDATA
typedef struct _PERFDATA *	PPERFDATA
typedef struct _CMD_LINE_CACHE	CMD_LINE_CACHE
typedef struct _CMD_LINE_CACHE *	PCMD_LINE_CACHE

Functions
BOOL	PerfDataInitialize (void)
void	PerfDataUninitialize (void)
void	PerfDataRefresh (void)
BOOL	PerfDataGet (ULONG Index, PPERFDATA *lppData)
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)

Macro Definition Documentation

Li2Double

#define Li2Double

(

x

)

((double)((x).HighPart) * 4.294967296E9 + (double)((x).LowPart))

Definition at line 11 of file perfdata.h.

Typedef Documentation

CMD_LINE_CACHE

typedef struct _CMD_LINE_CACHE CMD_LINE_CACHE

PCMD_LINE_CACHE

typedef struct _CMD_LINE_CACHE * PCMD_LINE_CACHE

PERFDATA

typedef struct _PERFDATA PERFDATA

PPERFDATA

typedef struct _PERFDATA * PPERFDATA

Function Documentation

PerfDataDeallocCommandLineCache()

void PerfDataDeallocCommandLineCache

(

)

Definition at line 648 of file perfdata.c.

{
    PCMD_LINE_CACHE cache, pnext;
 
    for (cache = global_cache; cache; cache = pnext)
    {
        pnext = cache->pnext;
        HeapFree(GetProcessHeap(), 0, cache);
    }
 
    global_cache = NULL;
}

Referenced by TaskManagerWndProc().

PerfDataGet()

BOOL PerfDataGet	(	ULONG	Index,
		PPERFDATA *	lppData
	)

Definition at line 1121 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 835 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 538 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 951 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 968 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 934 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 693 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 677 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 899 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 851 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 488 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 915 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 1025 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 1008 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 985 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 819 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 803 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 755 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 771 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 723 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 1059 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 1076 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 1042 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 461 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 504 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 438 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 479 of file perfdata.c.

{
    ULONG Result;
    EnterCriticalSection(&PerfDataCriticalSection);
    Result = (ULONG)min(max(dbKernelTime, 0.), 100.);
    LeaveCriticalSection(&PerfDataCriticalSection);
    return Result;
}

Referenced by Graph_DrawCpuUsageGraph(), and PerformancePageRefreshThread().

PerfDataGetProcessorUsage()

ULONG PerfDataGetProcessorUsage

(

void

)

Definition at line 470 of file perfdata.c.

{
    ULONG Result;
    EnterCriticalSection(&PerfDataCriticalSection);
    Result = (ULONG)min(max(dbIdleTime, 0.), 100.);
    LeaveCriticalSection(&PerfDataCriticalSection);
    return Result;
}

Referenced by Graph_DrawCpuUsageGraph(), PerformancePageRefreshThread(), and TrayIcon_Update().

PerfDataGetSessionId()

ULONG PerfDataGetSessionId

(

ULONG

Index

)

Definition at line 661 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 1091 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 867 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 1104 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 520 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 883 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 787 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 707 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 739 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 49 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);
 
    /*
     * Set up global info storage
     */
    SystemProcessorTimeInfo = (PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION)HeapAlloc(GetProcessHeap(),
                               0, sizeof(*SystemProcessorTimeInfo) * SystemBasicInfo.NumberOfProcessors);
 
    return SystemProcessorTimeInfo != NULL;
}

Referenced by wWinMain().

PerfDataRefresh()

void PerfDataRefresh

(

void

)

Definition at line 165 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;
    BOOL                                       bIsWow64;
 
    /* 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
     */
    memcpy(SystemProcessorTimeInfo, SysProcessorTimeInfo,
           sizeof(*SystemProcessorTimeInfo) * SystemBasicInfo.NumberOfProcessors);
 
    if (SysProcessorTimeInfo) {
        HeapFree(GetProcessHeap(), 0, 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,
                       _countof(pPerfData[Idx].ImageName));
        }
 
        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);
                }
 
                if (IsWow64Process(hProcess, &bIsWow64) && bIsWow64)
                {
                    wcscat(pPerfData[Idx].ImageName, L" *32");
                }
 
                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 = _countof(pPerfData[0].UserName);
        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 _tmain(), OnCreate(), and TaskManagerWndProc().

PerfDataUninitialize()

void PerfDataUninitialize

(

void

)

Definition at line 77 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().