pdh.h File Reference

#include <windows.h>
#include <winperf.h>

Include dependency graph for pdh.h:

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

Go to the source code of this file.

Classes
struct	_PDH_FMT_COUNTERVALUE
struct	_PDH_RAW_COUNTER
struct	_PDH_COUNTER_PATH_ELEMENTS_A
struct	_PDH_COUNTER_PATH_ELEMENTS_W
struct	_PDH_DATA_ITEM_PATH_ELEMENTS_A
struct	_PDH_DATA_ITEM_PATH_ELEMENTS_W
struct	_PDH_COUNTER_INFO_A
struct	_PDH_COUNTER_INFO_W

Macros
#define	PDH_CVERSION_WIN40   0x0400
#define	PDH_CVERSION_WIN50   0x0500
#define	PDH_VERSION   0x0503
#define	PDH_MAX_SCALE   7
#define	PDH_MIN_SCALE   (-7)
#define	PDH_MAX_COUNTER_NAME   1024
#define	PDH_FMT_LONG   0x00000100
#define	PDH_FMT_DOUBLE   0x00000200
#define	PDH_FMT_LARGE   0x00000400
#define	PDH_FMT_NOSCALE   0x00001000
#define	PDH_FMT_1000   0x00002000
#define	PDH_FMT_NOCAP100   0x00008000
#define	DATA_SOURCE_REGISTRY   0x00000001
#define	DATA_SOURCE_LOGFILE   0x00000002
#define	DATA_SOURCE_WBEM   0x00000004
#define	PdhAddCounter   WINELIB_NAME_AW(PdhAddCounter)
#define	PdhAddEnglishCounter   WINELIB_NAME_AW(PdhAddEnglishCounter)
#define	PdhEnumObjectItems   WINELIB_NAME_AW(PdhEnumObjectItems)
#define	PdhGetCounterInfo   WINELIB_NAME_AW(PdhGetCounterInfo)
#define	PdhLookupPerfIndexByName   WINELIB_NAME_AW(PdhLookupPerfIndexByName)
#define	PdhLookupPerfNameByIndex   WINELIB_NAME_AW(PdhLookupPerfNameByIndex)
#define	PdhMakeCounterPath   WINELIB_NAME_AW(PdhMakeCounterPath)
#define	PdhOpenQuery   WINELIB_NAME_AW(PdhOpenQuery)
#define	PdhValidatePath   WINELIB_NAME_AW(PdhValidatePath)
#define	PdhValidatePathEx   WINELIB_NAME_AW(PdhValidatePathEx)

Typedefs
typedef LONG	PDH_STATUS
typedef HANDLE	PDH_HQUERY
typedef HANDLE	PDH_HCOUNTER
typedef HANDLE	PDH_HLOG
typedef struct _PDH_FMT_COUNTERVALUE	PDH_FMT_COUNTERVALUE
typedef struct _PDH_FMT_COUNTERVALUE *	PPDH_FMT_COUNTERVALUE
typedef struct _PDH_RAW_COUNTER	PDH_RAW_COUNTER
typedef struct _PDH_RAW_COUNTER *	PPDH_RAW_COUNTER
typedef struct _PDH_COUNTER_PATH_ELEMENTS_A	PDH_COUNTER_PATH_ELEMENTS_A
typedef struct _PDH_COUNTER_PATH_ELEMENTS_A *	PPDH_COUNTER_PATH_ELEMENTS_A
typedef struct _PDH_COUNTER_PATH_ELEMENTS_W	PDH_COUNTER_PATH_ELEMENTS_W
typedef struct _PDH_COUNTER_PATH_ELEMENTS_W *	PPDH_COUNTER_PATH_ELEMENTS_W
typedef struct _PDH_DATA_ITEM_PATH_ELEMENTS_A	PDH_DATA_ITEM_PATH_ELEMENTS_A
typedef struct _PDH_DATA_ITEM_PATH_ELEMENTS_A *	PPDH_DATA_ITEM_PATH_ELEMENTS_A
typedef struct _PDH_DATA_ITEM_PATH_ELEMENTS_W	PDH_DATA_ITEM_PATH_ELEMENTS_W
typedef struct _PDH_DATA_ITEM_PATH_ELEMENTS_W *	PPDH_DATA_ITEM_PATH_ELEMENTS_W
typedef struct _PDH_COUNTER_INFO_A	PDH_COUNTER_INFO_A
typedef struct _PDH_COUNTER_INFO_A *	PPDH_COUNTER_INFO_A
typedef struct _PDH_COUNTER_INFO_W	PDH_COUNTER_INFO_W
typedef struct _PDH_COUNTER_INFO_W *	PPDH_COUNTER_INFO_W

Functions
PDH_STATUS WINAPI	PdhAddCounterA (PDH_HQUERY, LPCSTR, DWORD_PTR, PDH_HCOUNTER *)
PDH_STATUS WINAPI	PdhAddCounterW (PDH_HQUERY, LPCWSTR, DWORD_PTR, PDH_HCOUNTER *)
PDH_STATUS WINAPI	PdhAddEnglishCounterA (PDH_HQUERY, LPCSTR, DWORD_PTR, PDH_HCOUNTER *)
PDH_STATUS WINAPI	PdhAddEnglishCounterW (PDH_HQUERY, LPCWSTR, DWORD_PTR, PDH_HCOUNTER *)
PDH_STATUS WINAPI	PdhCloseQuery (PDH_HQUERY)
PDH_STATUS WINAPI	PdhCollectQueryData (PDH_HQUERY)
PDH_STATUS WINAPI	PdhCollectQueryDataEx (PDH_HQUERY, DWORD, HANDLE)
PDH_STATUS WINAPI	PdhCollectQueryDataWithTime (PDH_HQUERY, LONGLONG *)
PDH_STATUS WINAPI	PdhEnumObjectItemsA (LPCSTR, LPCSTR, LPCSTR, LPSTR, LPDWORD, LPSTR, LPDWORD, DWORD, DWORD)
PDH_STATUS WINAPI	PdhEnumObjectItemsW (LPCWSTR, LPCWSTR, LPCWSTR, LPWSTR, LPDWORD, LPWSTR, LPDWORD, DWORD, DWORD)
PDH_STATUS WINAPI	PdhGetCounterInfoA (PDH_HCOUNTER, BOOLEAN, LPDWORD, PPDH_COUNTER_INFO_A)
PDH_STATUS WINAPI	PdhGetCounterInfoW (PDH_HCOUNTER, BOOLEAN, LPDWORD, PPDH_COUNTER_INFO_W)
PDH_STATUS WINAPI	PdhGetCounterTimeBase (PDH_HCOUNTER, LONGLONG *)
PDH_STATUS WINAPI	PdhGetDllVersion (LPDWORD)
PDH_STATUS WINAPI	PdhGetFormattedCounterValue (PDH_HCOUNTER, DWORD, LPDWORD, PPDH_FMT_COUNTERVALUE)
PDH_STATUS WINAPI	PdhGetRawCounterValue (PDH_HCOUNTER, LPDWORD, PPDH_RAW_COUNTER)
PDH_STATUS WINAPI	PdhLookupPerfIndexByNameA (LPCSTR, LPCSTR, LPDWORD)
PDH_STATUS WINAPI	PdhLookupPerfIndexByNameW (LPCWSTR, LPCWSTR, LPDWORD)
PDH_STATUS WINAPI	PdhLookupPerfNameByIndexA (LPCSTR, DWORD, LPSTR, LPDWORD)
PDH_STATUS WINAPI	PdhLookupPerfNameByIndexW (LPCWSTR, DWORD, LPWSTR, LPDWORD)
PDH_STATUS WINAPI	PdhMakeCounterPathA (PDH_COUNTER_PATH_ELEMENTS_A *, LPSTR, LPDWORD, DWORD)
PDH_STATUS WINAPI	PdhMakeCounterPathW (PDH_COUNTER_PATH_ELEMENTS_W *, LPWSTR, LPDWORD, DWORD)
PDH_STATUS WINAPI	PdhOpenQueryA (LPCSTR, DWORD_PTR, PDH_HQUERY *)
PDH_STATUS WINAPI	PdhOpenQueryW (LPCWSTR, DWORD_PTR, PDH_HQUERY *)
PDH_STATUS WINAPI	PdhRemoveCounter (PDH_HCOUNTER)
PDH_STATUS WINAPI	PdhSetCounterScaleFactor (PDH_HCOUNTER, LONG)
PDH_STATUS WINAPI	PdhSetDefaultRealTimeDataSource (DWORD)
PDH_STATUS WINAPI	PdhValidatePathA (LPCSTR)
PDH_STATUS WINAPI	PdhValidatePathW (LPCWSTR)
PDH_STATUS WINAPI	PdhValidatePathExA (PDH_HLOG, LPCSTR)
PDH_STATUS WINAPI	PdhValidatePathExW (PDH_HLOG, LPCWSTR)

Macro Definition Documentation

DATA_SOURCE_LOGFILE

#define DATA_SOURCE_LOGFILE   0x00000002

Definition at line 57 of file pdh.h.

DATA_SOURCE_REGISTRY

#define DATA_SOURCE_REGISTRY   0x00000001

Definition at line 56 of file pdh.h.

DATA_SOURCE_WBEM

#define DATA_SOURCE_WBEM   0x00000004

Definition at line 58 of file pdh.h.

PDH_CVERSION_WIN40

#define PDH_CVERSION_WIN40   0x0400

Definition at line 40 of file pdh.h.

PDH_CVERSION_WIN50

#define PDH_CVERSION_WIN50   0x0500

Definition at line 41 of file pdh.h.

PDH_FMT_1000

#define PDH_FMT_1000   0x00002000

Definition at line 53 of file pdh.h.

PDH_FMT_DOUBLE

#define PDH_FMT_DOUBLE   0x00000200

Definition at line 50 of file pdh.h.

PDH_FMT_LARGE

#define PDH_FMT_LARGE   0x00000400

Definition at line 51 of file pdh.h.

PDH_FMT_LONG

#define PDH_FMT_LONG   0x00000100

Definition at line 49 of file pdh.h.

PDH_FMT_NOCAP100

#define PDH_FMT_NOCAP100   0x00008000

Definition at line 54 of file pdh.h.

PDH_FMT_NOSCALE

#define PDH_FMT_NOSCALE   0x00001000

Definition at line 52 of file pdh.h.

PDH_MAX_COUNTER_NAME

#define PDH_MAX_COUNTER_NAME   1024

Definition at line 47 of file pdh.h.

PDH_MAX_SCALE

#define PDH_MAX_SCALE   7

Definition at line 44 of file pdh.h.

PDH_MIN_SCALE

#define PDH_MIN_SCALE   (-7)

Definition at line 45 of file pdh.h.

PDH_VERSION

#define PDH_VERSION   0x0503

Definition at line 42 of file pdh.h.

PdhAddCounter

#define PdhAddCounter   WINELIB_NAME_AW(PdhAddCounter)

Definition at line 178 of file pdh.h.

PdhAddEnglishCounter

#define PdhAddEnglishCounter   WINELIB_NAME_AW(PdhAddEnglishCounter)

Definition at line 181 of file pdh.h.

PdhEnumObjectItems

#define PdhEnumObjectItems   WINELIB_NAME_AW(PdhEnumObjectItems)

Definition at line 188 of file pdh.h.

PdhGetCounterInfo

#define PdhGetCounterInfo   WINELIB_NAME_AW(PdhGetCounterInfo)

Definition at line 191 of file pdh.h.

PdhLookupPerfIndexByName

#define PdhLookupPerfIndexByName   WINELIB_NAME_AW(PdhLookupPerfIndexByName)

Definition at line 198 of file pdh.h.

PdhLookupPerfNameByIndex

#define PdhLookupPerfNameByIndex   WINELIB_NAME_AW(PdhLookupPerfNameByIndex)

Definition at line 201 of file pdh.h.

PdhMakeCounterPath

#define PdhMakeCounterPath   WINELIB_NAME_AW(PdhMakeCounterPath)

Definition at line 204 of file pdh.h.

PdhOpenQuery

#define PdhOpenQuery   WINELIB_NAME_AW(PdhOpenQuery)

Definition at line 207 of file pdh.h.

PdhValidatePath

#define PdhValidatePath   WINELIB_NAME_AW(PdhValidatePath)

Definition at line 213 of file pdh.h.

PdhValidatePathEx

#define PdhValidatePathEx   WINELIB_NAME_AW(PdhValidatePathEx)

Definition at line 216 of file pdh.h.

Typedef Documentation

PDH_COUNTER_INFO_A

typedef struct _PDH_COUNTER_INFO_A PDH_COUNTER_INFO_A

PDH_COUNTER_INFO_W

typedef struct _PDH_COUNTER_INFO_W PDH_COUNTER_INFO_W

PDH_COUNTER_PATH_ELEMENTS_A

typedef struct _PDH_COUNTER_PATH_ELEMENTS_A PDH_COUNTER_PATH_ELEMENTS_A

PDH_COUNTER_PATH_ELEMENTS_W

typedef struct _PDH_COUNTER_PATH_ELEMENTS_W PDH_COUNTER_PATH_ELEMENTS_W

PDH_DATA_ITEM_PATH_ELEMENTS_A

typedef struct _PDH_DATA_ITEM_PATH_ELEMENTS_A PDH_DATA_ITEM_PATH_ELEMENTS_A

PDH_DATA_ITEM_PATH_ELEMENTS_W

typedef struct _PDH_DATA_ITEM_PATH_ELEMENTS_W PDH_DATA_ITEM_PATH_ELEMENTS_W

PDH_FMT_COUNTERVALUE

typedef struct _PDH_FMT_COUNTERVALUE PDH_FMT_COUNTERVALUE

PDH_HCOUNTER

typedef HANDLE PDH_HCOUNTER

Definition at line 37 of file pdh.h.

PDH_HLOG

typedef HANDLE PDH_HLOG

Definition at line 38 of file pdh.h.

PDH_HQUERY

typedef HANDLE PDH_HQUERY

Definition at line 36 of file pdh.h.

PDH_RAW_COUNTER

typedef struct _PDH_RAW_COUNTER PDH_RAW_COUNTER

PDH_STATUS

static PDH_STATUS

Definition at line 35 of file pdh.h.

PPDH_COUNTER_INFO_A

typedef struct _PDH_COUNTER_INFO_A * PPDH_COUNTER_INFO_A

PPDH_COUNTER_INFO_W

typedef struct _PDH_COUNTER_INFO_W * PPDH_COUNTER_INFO_W

PPDH_COUNTER_PATH_ELEMENTS_A

typedef struct _PDH_COUNTER_PATH_ELEMENTS_A * PPDH_COUNTER_PATH_ELEMENTS_A

PPDH_COUNTER_PATH_ELEMENTS_W

typedef struct _PDH_COUNTER_PATH_ELEMENTS_W * PPDH_COUNTER_PATH_ELEMENTS_W

PPDH_DATA_ITEM_PATH_ELEMENTS_A

typedef struct _PDH_DATA_ITEM_PATH_ELEMENTS_A * PPDH_DATA_ITEM_PATH_ELEMENTS_A

PPDH_DATA_ITEM_PATH_ELEMENTS_W

typedef struct _PDH_DATA_ITEM_PATH_ELEMENTS_W * PPDH_DATA_ITEM_PATH_ELEMENTS_W

PPDH_FMT_COUNTERVALUE

typedef struct _PDH_FMT_COUNTERVALUE * PPDH_FMT_COUNTERVALUE

PPDH_RAW_COUNTER

typedef struct _PDH_RAW_COUNTER * PPDH_RAW_COUNTER

Function Documentation

PdhAddCounterA()

PDH_STATUS WINAPI PdhAddCounterA	(	PDH_HQUERY	,
		LPCSTR	,
		DWORD_PTR	,
		PDH_HCOUNTER *
	)

Definition at line 242 of file pdh_main.c.

{
    PDH_STATUS ret;
    WCHAR *pathW;

    TRACE("%p %s %lx %p\n", query, debugstr_a(path), userdata, counter);

    if (!path) return PDH_INVALID_ARGUMENT;

    if (!(pathW = pdh_strdup_aw( path )))
        return PDH_MEMORY_ALLOCATION_FAILURE;

    ret = PdhAddCounterW( query, pathW, userdata, counter );

    heap_free( pathW );
    return ret;
}

Referenced by PdhAddEnglishCounterA(), test_PdhAddCounterA(), test_PdhCollectQueryDataEx(), test_PdhCollectQueryDataWithTime(), test_PdhGetCounterInfoA(), test_PdhGetCounterTimeBase(), test_PdhGetFormattedCounterValue(), test_PdhGetRawCounterValue(), and test_PdhSetCounterScaleFactor().

PdhAddCounterW()

PDH_STATUS WINAPI PdhAddCounterW	(	PDH_HQUERY	,
		LPCWSTR	,
		DWORD_PTR	,
		PDH_HCOUNTER *
	)

Definition at line 264 of file pdh_main.c.

{
    struct query *query = hquery;
    struct counter *counter;
    unsigned int i;

    TRACE("%p %s %lx %p\n", hquery, debugstr_w(path), userdata, hcounter);

    if (!path  || !hcounter) return PDH_INVALID_ARGUMENT;

    EnterCriticalSection( &pdh_handle_cs );
    if (!query || query->magic != PDH_MAGIC_QUERY)
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_INVALID_HANDLE;
    }

    *hcounter = NULL;
    for (i = 0; i < ARRAY_SIZE(counter_sources); i++)
    {
        if (pdh_match_path( counter_sources[i].path, path ))
        {
            if ((counter = create_counter()))
            {
                counter->path         = pdh_strdup( counter_sources[i].path );
                counter->collect      = counter_sources[i].collect;
                counter->type         = counter_sources[i].type;
                counter->defaultscale = counter_sources[i].scale;
                counter->base         = counter_sources[i].base;
                counter->queryuser    = query->user;
                counter->user         = userdata;

                list_add_tail( &query->counters, &counter->entry );
                *hcounter = counter;

                LeaveCriticalSection( &pdh_handle_cs );
                return ERROR_SUCCESS;
            }
            LeaveCriticalSection( &pdh_handle_cs );
            return PDH_MEMORY_ALLOCATION_FAILURE;
        }
    }
    LeaveCriticalSection( &pdh_handle_cs );
    return PDH_CSTATUS_NO_COUNTER;
}

Referenced by PdhAddCounterA(), PdhAddEnglishCounterW(), test_PdhAddCounterW(), and test_PdhGetCounterInfoW().

PdhAddEnglishCounterA()

PDH_STATUS WINAPI PdhAddEnglishCounterA	(	PDH_HQUERY	,
		LPCSTR	,
		DWORD_PTR	,
		PDH_HCOUNTER *
	)

Definition at line 314 of file pdh_main.c.

{
    TRACE("%p %s %lx %p\n", query, debugstr_a(path), userdata, counter);

    if (!query) return PDH_INVALID_ARGUMENT;
    return PdhAddCounterA( query, path, userdata, counter );
}

Referenced by init_function_ptrs().

PdhAddEnglishCounterW()

PDH_STATUS WINAPI PdhAddEnglishCounterW	(	PDH_HQUERY	,
		LPCWSTR	,
		DWORD_PTR	,
		PDH_HCOUNTER *
	)

Definition at line 326 of file pdh_main.c.

{
    TRACE("%p %s %lx %p\n", query, debugstr_w(path), userdata, counter);

    if (!query) return PDH_INVALID_ARGUMENT;
    return PdhAddCounterW( query, path, userdata, counter );
}

Referenced by init_function_ptrs().

PdhCloseQuery()

PDH_STATUS WINAPI PdhCloseQuery

(

PDH_HQUERY

)

Definition at line 397 of file pdh_main.c.

{
    struct query *query = handle;
    struct list *item, *next;

    TRACE("%p\n", handle);

    EnterCriticalSection( &pdh_handle_cs );
    if (!query || query->magic != PDH_MAGIC_QUERY)
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_INVALID_HANDLE;
    }

    if (query->thread)
    {
        HANDLE thread = query->thread;
        SetEvent( query->stop );
        LeaveCriticalSection( &pdh_handle_cs );

        WaitForSingleObject( thread, INFINITE );

        EnterCriticalSection( &pdh_handle_cs );
        if (query->magic != PDH_MAGIC_QUERY)
        {
            LeaveCriticalSection( &pdh_handle_cs );
            return ERROR_SUCCESS;
        }
        CloseHandle( query->stop );
        CloseHandle( query->thread );
        query->thread = NULL;
    }

    LIST_FOR_EACH_SAFE( item, next, &query->counters )
    {
        struct counter *counter = LIST_ENTRY( item, struct counter, entry );

        list_remove( &counter->entry );
        destroy_counter( counter );
    }

    destroy_query( query );

    LeaveCriticalSection( &pdh_handle_cs );
    return ERROR_SUCCESS;
}

Referenced by test_PdhAddCounterA(), test_PdhAddCounterW(), test_PdhAddEnglishCounterA(), test_PdhAddEnglishCounterW(), test_PdhCollectQueryDataEx(), test_PdhCollectQueryDataWithTime(), test_PdhGetCounterInfoA(), test_PdhGetCounterInfoW(), test_PdhGetCounterTimeBase(), test_PdhGetFormattedCounterValue(), test_PdhGetRawCounterValue(), test_PdhOpenQueryA(), test_PdhOpenQueryW(), and test_PdhSetCounterScaleFactor().

PdhCollectQueryData()

PDH_STATUS WINAPI PdhCollectQueryData

(

PDH_HQUERY

)

Definition at line 464 of file pdh_main.c.

{
    struct query *query = handle;

    TRACE("%p\n", handle);

    EnterCriticalSection( &pdh_handle_cs );
    if (!query || query->magic != PDH_MAGIC_QUERY)
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_INVALID_HANDLE;
    }

    if (list_empty( &query->counters ))
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_NO_DATA;
    }

    collect_query_data( query );

    LeaveCriticalSection( &pdh_handle_cs );
    return ERROR_SUCCESS;
}

Referenced by test_PdhAddCounterA(), test_PdhAddCounterW(), test_PdhAddEnglishCounterA(), test_PdhAddEnglishCounterW(), test_PdhCollectQueryDataEx(), test_PdhCollectQueryDataWithTime(), test_PdhGetFormattedCounterValue(), and test_PdhGetRawCounterValue().

PdhCollectQueryDataEx()

PDH_STATUS WINAPI PdhCollectQueryDataEx	(	PDH_HQUERY	,
		DWORD	,
		HANDLE
	)

Definition at line 520 of file pdh_main.c.

{
    PDH_STATUS ret;
    struct query *query = handle;

    TRACE("%p %d %p\n", handle, interval, event);

    EnterCriticalSection( &pdh_handle_cs );
    if (!query || query->magic != PDH_MAGIC_QUERY)
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_INVALID_HANDLE;
    }
    if (list_empty( &query->counters ))
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_NO_DATA;
    }
    if (query->thread)
    {
        HANDLE thread = query->thread;
        SetEvent( query->stop );
        LeaveCriticalSection( &pdh_handle_cs );

        WaitForSingleObject( thread, INFINITE );

        EnterCriticalSection( &pdh_handle_cs );
        if (query->magic != PDH_MAGIC_QUERY)
        {
            LeaveCriticalSection( &pdh_handle_cs );
            return PDH_INVALID_HANDLE;
        }
        CloseHandle( query->thread );
        query->thread = NULL;
    }
    else if (!(query->stop = CreateEventW( NULL, FALSE, FALSE, NULL )))
    {
        ret = GetLastError();
        LeaveCriticalSection( &pdh_handle_cs );
        return ret;
    }
    query->wait = event;
    query->interval = interval * 1000;
    if (!(query->thread = CreateThread( NULL, 0, collect_query_thread, query, 0, NULL )))
    {
        ret = GetLastError();
        CloseHandle( query->stop );

        LeaveCriticalSection( &pdh_handle_cs );
        return ret;
    }

    LeaveCriticalSection( &pdh_handle_cs );
    return ERROR_SUCCESS;
}

Referenced by test_PdhCollectQueryDataEx().

PdhCollectQueryDataWithTime()

PDH_STATUS WINAPI PdhCollectQueryDataWithTime	(	PDH_HQUERY	,
		LONGLONG *
	)

Definition at line 579 of file pdh_main.c.

{
    struct query *query = handle;
    struct counter *counter;
    struct list *item;

    TRACE("%p %p\n", handle, timestamp);

    if (!timestamp) return PDH_INVALID_ARGUMENT;

    EnterCriticalSection( &pdh_handle_cs );
    if (!query || query->magic != PDH_MAGIC_QUERY)
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_INVALID_HANDLE;
    }
    if (list_empty( &query->counters ))
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_NO_DATA;
    }

    collect_query_data( query );

    item = list_head( &query->counters );
    counter = LIST_ENTRY( item, struct counter, entry );

    *timestamp = ((LONGLONG)counter->stamp.dwHighDateTime << 32) | counter->stamp.dwLowDateTime;

    LeaveCriticalSection( &pdh_handle_cs );
    return ERROR_SUCCESS;
}

Referenced by init_function_ptrs().

PdhEnumObjectItemsA()

PDH_STATUS WINAPI PdhEnumObjectItemsA	(	LPCSTR	,
		LPCSTR	,
		LPCSTR	,
		LPSTR	,
		LPDWORD	,
		LPSTR	,
		LPDWORD	,
		DWORD	,
		DWORD
	)

Definition at line 1243 of file pdh_main.c.

{
    FIXME("%s, %s, %s, %p, %p, %p, %p, %d, 0x%x: stub\n", debugstr_a(szDataSource), debugstr_a(szMachineName),
         debugstr_a(szObjectName), mszCounterList, pcchCounterListLength, mszInstanceList,
         pcchInstanceListLength, dwDetailLevel, dwFlags);

    return PDH_NOT_IMPLEMENTED;
}

PdhEnumObjectItemsW()

PDH_STATUS WINAPI PdhEnumObjectItemsW	(	LPCWSTR	,
		LPCWSTR	,
		LPCWSTR	,
		LPWSTR	,
		LPDWORD	,
		LPWSTR	,
		LPDWORD	,
		DWORD	,
		DWORD
	)

Definition at line 1257 of file pdh_main.c.

{
    FIXME("%s, %s, %s, %p, %p, %p, %p, %d, 0x%x: stub\n", debugstr_w(szDataSource), debugstr_w(szMachineName),
         debugstr_w(szObjectName), mszCounterList, pcchCounterListLength, mszInstanceList,
         pcchInstanceListLength, dwDetailLevel, dwFlags);

    return PDH_NOT_IMPLEMENTED;
}

PdhGetCounterInfoA()

PDH_STATUS WINAPI PdhGetCounterInfoA	(	PDH_HCOUNTER	,
		BOOLEAN	,
		LPDWORD	,
		PPDH_COUNTER_INFO_A
	)

Definition at line 651 of file pdh_main.c.

{
    struct counter *counter = handle;

    TRACE("%p %d %p %p\n", handle, text, size, info);

    EnterCriticalSection( &pdh_handle_cs );
    if (!counter || counter->magic != PDH_MAGIC_COUNTER)
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_INVALID_HANDLE;
    }
    if (!size)
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_INVALID_ARGUMENT;
    }
    if (*size < sizeof(PDH_COUNTER_INFO_A))
    {
        *size = sizeof(PDH_COUNTER_INFO_A);
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_MORE_DATA;
    }

    memset( info, 0, sizeof(PDH_COUNTER_INFO_A) );

    info->dwType          = counter->type;
    info->CStatus         = counter->status;
    info->lScale          = counter->scale;
    info->lDefaultScale   = counter->defaultscale;
    info->dwUserData      = counter->user;
    info->dwQueryUserData = counter->queryuser;

    *size = sizeof(PDH_COUNTER_INFO_A);

    LeaveCriticalSection( &pdh_handle_cs );
    return ERROR_SUCCESS;
}

Referenced by test_PdhGetCounterInfoA().

PdhGetCounterInfoW()

PDH_STATUS WINAPI PdhGetCounterInfoW	(	PDH_HCOUNTER	,
		BOOLEAN	,
		LPDWORD	,
		PPDH_COUNTER_INFO_W
	)

Definition at line 693 of file pdh_main.c.

{
    struct counter *counter = handle;

    TRACE("%p %d %p %p\n", handle, text, size, info);

    EnterCriticalSection( &pdh_handle_cs );
    if (!counter || counter->magic != PDH_MAGIC_COUNTER)
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_INVALID_HANDLE;
    }
    if (!size)
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_INVALID_ARGUMENT;
    }
    if (*size < sizeof(PDH_COUNTER_INFO_W))
    {
        *size = sizeof(PDH_COUNTER_INFO_W);
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_MORE_DATA;
    }

    memset( info, 0, sizeof(PDH_COUNTER_INFO_W) );

    info->dwType          = counter->type;
    info->CStatus         = counter->status;
    info->lScale          = counter->scale;
    info->lDefaultScale   = counter->defaultscale;
    info->dwUserData      = counter->user;
    info->dwQueryUserData = counter->queryuser;

    *size = sizeof(PDH_COUNTER_INFO_W);

    LeaveCriticalSection( &pdh_handle_cs );
    return ERROR_SUCCESS;
}

Referenced by test_PdhGetCounterInfoW().

PdhGetCounterTimeBase()

PDH_STATUS WINAPI PdhGetCounterTimeBase	(	PDH_HCOUNTER	,
		LONGLONG *
	)

Definition at line 735 of file pdh_main.c.

{
    struct counter *counter = handle;

    TRACE("%p %p\n", handle, base);

    if (!base) return PDH_INVALID_ARGUMENT;

    EnterCriticalSection( &pdh_handle_cs );
    if (!counter || counter->magic != PDH_MAGIC_COUNTER)
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_INVALID_HANDLE;
    }

    *base = counter->base;

    LeaveCriticalSection( &pdh_handle_cs );
    return ERROR_SUCCESS;
}

Referenced by test_PdhGetCounterTimeBase().

PdhGetDllVersion()

PDH_STATUS WINAPI PdhGetDllVersion

(

LPDWORD

)

Definition at line 759 of file pdh_main.c.

{
    if (!version)
        return PDH_INVALID_ARGUMENT;

    *version = PDH_VERSION;

    return ERROR_SUCCESS;
}

Referenced by test_PdhGetDllVersion().

PdhGetFormattedCounterValue()

PDH_STATUS WINAPI PdhGetFormattedCounterValue	(	PDH_HCOUNTER	,
		DWORD	,
		LPDWORD	,
		PPDH_FMT_COUNTERVALUE
	)

Definition at line 772 of file pdh_main.c.

{
    PDH_STATUS ret;
    struct counter *counter = handle;

    TRACE("%p %x %p %p\n", handle, format, type, value);

    if (!value) return PDH_INVALID_ARGUMENT;

    EnterCriticalSection( &pdh_handle_cs );
    if (!counter || counter->magic != PDH_MAGIC_COUNTER)
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_INVALID_HANDLE;
    }
    if (counter->status)
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_INVALID_DATA;
    }
    if (!(ret = format_value( counter, format, &counter->one, &counter->two, value )))
    {
        value->CStatus = ERROR_SUCCESS;
        if (type) *type = counter->type;
    }

    LeaveCriticalSection( &pdh_handle_cs );
    return ret;
}

Referenced by test_PdhCollectQueryDataEx(), and test_PdhGetFormattedCounterValue().

PdhGetRawCounterValue()

PDH_STATUS WINAPI PdhGetRawCounterValue	(	PDH_HCOUNTER	,
		LPDWORD	,
		PPDH_RAW_COUNTER
	)

Definition at line 806 of file pdh_main.c.

{
    struct counter *counter = handle;

    TRACE("%p %p %p\n", handle, type, value);

    if (!value) return PDH_INVALID_ARGUMENT;

    EnterCriticalSection( &pdh_handle_cs );
    if (!counter || counter->magic != PDH_MAGIC_COUNTER)
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_INVALID_HANDLE;
    }

    value->CStatus                  = counter->status;
    value->TimeStamp.dwLowDateTime  = counter->stamp.dwLowDateTime;
    value->TimeStamp.dwHighDateTime = counter->stamp.dwHighDateTime;
    value->FirstValue               = counter->one.largevalue;
    value->SecondValue              = counter->two.largevalue;
    value->MultiCount               = 1; /* FIXME */

    if (type) *type = counter->type;

    LeaveCriticalSection( &pdh_handle_cs );
    return ERROR_SUCCESS;
}

Referenced by test_PdhGetRawCounterValue().

PdhLookupPerfIndexByNameA()

PDH_STATUS WINAPI PdhLookupPerfIndexByNameA	(	LPCSTR	,
		LPCSTR	,
		LPDWORD
	)

Definition at line 838 of file pdh_main.c.

{
    PDH_STATUS ret;
    WCHAR *machineW = NULL;
    WCHAR *nameW;

    TRACE("%s %s %p\n", debugstr_a(machine), debugstr_a(name), index);

    if (!name) return PDH_INVALID_ARGUMENT;

    if (machine && !(machineW = pdh_strdup_aw( machine ))) return PDH_MEMORY_ALLOCATION_FAILURE;

    if (!(nameW = pdh_strdup_aw( name )))
        return PDH_MEMORY_ALLOCATION_FAILURE;

    ret = PdhLookupPerfIndexByNameW( machineW, nameW, index );

    heap_free( nameW );
    heap_free( machineW );
    return ret;
}

Referenced by test_PdhLookupPerfIndexByNameA().

PdhLookupPerfIndexByNameW()

PDH_STATUS WINAPI PdhLookupPerfIndexByNameW	(	LPCWSTR	,
		LPCWSTR	,
		LPDWORD
	)

Definition at line 863 of file pdh_main.c.

{
    unsigned int i;

    TRACE("%s %s %p\n", debugstr_w(machine), debugstr_w(name), index);

    if (!name || !index) return PDH_INVALID_ARGUMENT;

    if (machine)
    {
        FIXME("remote machine not supported\n");
        return PDH_CSTATUS_NO_MACHINE;
    }
    for (i = 0; i < ARRAY_SIZE(counter_sources); i++)
    {
        if (pdh_match_path( counter_sources[i].path, name ))
        {
            *index = counter_sources[i].index;
            return ERROR_SUCCESS;
        }
    }
    return PDH_STRING_NOT_FOUND;
}

Referenced by PdhLookupPerfIndexByNameA(), and test_PdhLookupPerfIndexByNameW().

PdhLookupPerfNameByIndexA()

PDH_STATUS WINAPI PdhLookupPerfNameByIndexA	(	LPCSTR	,
		DWORD	,
		LPSTR	,
		LPDWORD
	)

Definition at line 890 of file pdh_main.c.

{
    PDH_STATUS ret;
    WCHAR *machineW = NULL;
    WCHAR bufferW[PDH_MAX_COUNTER_NAME];
    DWORD sizeW = ARRAY_SIZE(bufferW);

    TRACE("%s %d %p %p\n", debugstr_a(machine), index, buffer, size);

    if (!buffer || !size) return PDH_INVALID_ARGUMENT;

    if (machine && !(machineW = pdh_strdup_aw( machine ))) return PDH_MEMORY_ALLOCATION_FAILURE;

    if (!(ret = PdhLookupPerfNameByIndexW( machineW, index, bufferW, &sizeW )))
    {
        int required = WideCharToMultiByte( CP_ACP, 0, bufferW, -1, NULL, 0, NULL, NULL );

        if (*size < required) ret = PDH_MORE_DATA;
        else WideCharToMultiByte( CP_ACP, 0, bufferW, -1, buffer, required, NULL, NULL );
        *size = required;
    }
    heap_free( machineW );
    return ret;
}

Referenced by test_PdhLookupPerfNameByIndexA().

PdhLookupPerfNameByIndexW()

PDH_STATUS WINAPI PdhLookupPerfNameByIndexW	(	LPCWSTR	,
		DWORD	,
		LPWSTR	,
		LPDWORD
	)

Definition at line 918 of file pdh_main.c.

{
    PDH_STATUS ret;
    unsigned int i;

    TRACE("%s %d %p %p\n", debugstr_w(machine), index, buffer, size);

    if (machine)
    {
        FIXME("remote machine not supported\n");
        return PDH_CSTATUS_NO_MACHINE;
    }

    if (!buffer || !size) return PDH_INVALID_ARGUMENT;
    if (!index) return ERROR_SUCCESS;

    for (i = 0; i < ARRAY_SIZE(counter_sources); i++)
    {
        if (counter_sources[i].index == index)
        {
            WCHAR *p = wcsrchr( counter_sources[i].path, '\\' ) + 1;
            unsigned int required = lstrlenW( p ) + 1;

            if (*size < required) ret = PDH_MORE_DATA;
            else
            {
                lstrcpyW( buffer, p );
                ret = ERROR_SUCCESS;
            }
            *size = required;
            return ret;
        }
    }
    return PDH_INVALID_ARGUMENT;
}

Referenced by PdhLookupPerfNameByIndexA(), and test_PdhLookupPerfNameByIndexW().

PdhMakeCounterPathA()

PDH_STATUS WINAPI PdhMakeCounterPathA	(	PDH_COUNTER_PATH_ELEMENTS_A *	,
		LPSTR	,
		LPDWORD	,
		DWORD
	)

Definition at line 1137 of file pdh_main.c.

{
    PDH_STATUS ret = PDH_MEMORY_ALLOCATION_FAILURE;
    PDH_COUNTER_PATH_ELEMENTS_W eW;
    WCHAR *bufferW;
    DWORD buflenW;

    TRACE("%p %p %p 0x%08x\n", e, buffer, buflen, flags);

    if (!e || !buflen) return PDH_INVALID_ARGUMENT;

    memset( &eW, 0, sizeof(eW) );
    if (e->szMachineName    && !(eW.szMachineName    = pdh_strdup_aw( e->szMachineName ))) goto done;
    if (e->szObjectName     && !(eW.szObjectName     = pdh_strdup_aw( e->szObjectName ))) goto done;
    if (e->szInstanceName   && !(eW.szInstanceName   = pdh_strdup_aw( e->szInstanceName ))) goto done;
    if (e->szParentInstance && !(eW.szParentInstance = pdh_strdup_aw( e->szParentInstance ))) goto done;
    if (e->szCounterName    && !(eW.szCounterName    = pdh_strdup_aw( e->szCounterName ))) goto done;
    eW.dwInstanceIndex = e->dwInstanceIndex;

    buflenW = 0;
    ret = PdhMakeCounterPathW( &eW, NULL, &buflenW, flags );
    if (ret == PDH_MORE_DATA)
    {
        if ((bufferW = heap_alloc( buflenW * sizeof(WCHAR) )))
        {
            if (!(ret = PdhMakeCounterPathW( &eW, bufferW, &buflenW, flags )))
            {
                int len = WideCharToMultiByte(CP_ACP, 0, bufferW, -1, NULL, 0, NULL, NULL);
                if (*buflen >= len) WideCharToMultiByte(CP_ACP, 0, bufferW, -1, buffer, *buflen, NULL, NULL);
                else ret = PDH_MORE_DATA;
                *buflen = len;
            }
            heap_free( bufferW );
        }
        else
            ret = PDH_MEMORY_ALLOCATION_FAILURE;
    }

done:
    heap_free( eW.szMachineName );
    heap_free( eW.szObjectName );
    heap_free( eW.szInstanceName );
    heap_free( eW.szParentInstance );
    heap_free( eW.szCounterName );
    return ret;
}

Referenced by test_PdhMakeCounterPathA().

PdhMakeCounterPathW()

PDH_STATUS WINAPI PdhMakeCounterPathW	(	PDH_COUNTER_PATH_ELEMENTS_W *	,
		LPWSTR	,
		LPDWORD	,
		DWORD
	)

Definition at line 1188 of file pdh_main.c.

{
    static const WCHAR bslash[] = {'\\',0};
    static const WCHAR fslash[] = {'/',0};
    static const WCHAR lparen[] = {'(',0};
    static const WCHAR rparen[] = {')',0};
    static const WCHAR fmt[]    = {'#','%','u',0};

    WCHAR path[PDH_MAX_COUNTER_NAME], instance[12];
    PDH_STATUS ret = ERROR_SUCCESS;
    DWORD len;

    TRACE("%p %p %p 0x%08x\n", e, buffer, buflen, flags);

    if (flags) FIXME("unimplemented flags 0x%08x\n", flags);

    if (!e || !e->szCounterName || !e->szObjectName || !buflen)
        return PDH_INVALID_ARGUMENT;

    path[0] = 0;
    if (e->szMachineName)
    {
        lstrcatW(path, bslash);
        lstrcatW(path, bslash);
        lstrcatW(path, e->szMachineName);
    }
    lstrcatW(path, bslash);
    lstrcatW(path, e->szObjectName);
    if (e->szInstanceName)
    {
        lstrcatW(path, lparen);
        if (e->szParentInstance)
        {
            lstrcatW(path, e->szParentInstance);
            lstrcatW(path, fslash);
        }
        lstrcatW(path, e->szInstanceName);
        swprintf(instance, fmt, e->dwInstanceIndex);
        lstrcatW(path, instance);
        lstrcatW(path, rparen);
    }
    lstrcatW(path, bslash);
    lstrcatW(path, e->szCounterName);

    len = lstrlenW(path) + 1;
    if (*buflen >= len) lstrcpyW(buffer, path);
    else ret = PDH_MORE_DATA;
    *buflen = len;
    return ret;
}

Referenced by PdhMakeCounterPathA().

PdhOpenQueryA()

PDH_STATUS WINAPI PdhOpenQueryA	(	LPCSTR	,
		DWORD_PTR	,
		PDH_HQUERY *
	)

Definition at line 957 of file pdh_main.c.

{
    PDH_STATUS ret;
    WCHAR *sourceW = NULL;

    TRACE("%s %lx %p\n", debugstr_a(source), userdata, query);

    if (source && !(sourceW = pdh_strdup_aw( source ))) return PDH_MEMORY_ALLOCATION_FAILURE;

    ret = PdhOpenQueryW( sourceW, userdata, query );
    heap_free( sourceW );

    return ret;
}

Referenced by test_PdhAddCounterA(), test_PdhAddEnglishCounterA(), test_PdhCollectQueryDataEx(), test_PdhCollectQueryDataWithTime(), test_PdhGetCounterInfoA(), test_PdhGetCounterTimeBase(), test_PdhGetFormattedCounterValue(), test_PdhGetRawCounterValue(), test_PdhOpenQueryA(), and test_PdhSetCounterScaleFactor().

PdhOpenQueryW()

PDH_STATUS WINAPI PdhOpenQueryW	(	LPCWSTR	,
		DWORD_PTR	,
		PDH_HQUERY *
	)

Definition at line 975 of file pdh_main.c.

{
    struct query *query;

    TRACE("%s %lx %p\n", debugstr_w(source), userdata, handle);

    if (!handle) return PDH_INVALID_ARGUMENT;

    if (source)
    {
        FIXME("log file data source not supported\n");
        return PDH_INVALID_ARGUMENT;
    }
    if ((query = create_query()))
    {
        query->user = userdata;
        *handle = query;

        return ERROR_SUCCESS;
    }
    return PDH_MEMORY_ALLOCATION_FAILURE;
}

Referenced by PdhOpenQueryA(), test_PdhAddCounterW(), test_PdhAddEnglishCounterW(), test_PdhGetCounterInfoW(), and test_PdhOpenQueryW().

PdhRemoveCounter()

PDH_STATUS WINAPI PdhRemoveCounter

(

PDH_HCOUNTER

)

Definition at line 1001 of file pdh_main.c.

{
    struct counter *counter = handle;

    TRACE("%p\n", handle);

    EnterCriticalSection( &pdh_handle_cs );
    if (!counter || counter->magic != PDH_MAGIC_COUNTER)
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_INVALID_HANDLE;
    }

    list_remove( &counter->entry );
    destroy_counter( counter );

    LeaveCriticalSection( &pdh_handle_cs );
    return ERROR_SUCCESS;
}

Referenced by test_PdhAddCounterA(), test_PdhAddCounterW(), test_PdhAddEnglishCounterA(), and test_PdhAddEnglishCounterW().

PdhSetCounterScaleFactor()

PDH_STATUS WINAPI PdhSetCounterScaleFactor	(	PDH_HCOUNTER	,
		LONG
	)

Definition at line 1024 of file pdh_main.c.

{
    struct counter *counter = handle;

    TRACE("%p\n", handle);

    EnterCriticalSection( &pdh_handle_cs );
    if (!counter || counter->magic != PDH_MAGIC_COUNTER)
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_INVALID_HANDLE;
    }
    if (factor < PDH_MIN_SCALE || factor > PDH_MAX_SCALE)
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_INVALID_ARGUMENT;
    }

    counter->scale = factor;

    LeaveCriticalSection( &pdh_handle_cs );
    return ERROR_SUCCESS;
}

Referenced by test_PdhGetCounterInfoA(), test_PdhGetCounterInfoW(), test_PdhGetFormattedCounterValue(), and test_PdhSetCounterScaleFactor().

PdhSetDefaultRealTimeDataSource()

PDH_STATUS WINAPI PdhSetDefaultRealTimeDataSource

(

DWORD

)

Definition at line 1271 of file pdh_main.c.

{
    FIXME("%u\n", source);
    return ERROR_SUCCESS;
}

PdhValidatePathA()

PDH_STATUS WINAPI PdhValidatePathA

(

LPCSTR

)

Definition at line 1051 of file pdh_main.c.

{
    PDH_STATUS ret;
    WCHAR *pathW;

    TRACE("%s\n", debugstr_a(path));

    if (!path) return PDH_INVALID_ARGUMENT;
    if (!(pathW = pdh_strdup_aw( path ))) return PDH_MEMORY_ALLOCATION_FAILURE;

    ret = PdhValidatePathW( pathW );

    heap_free( pathW );
    return ret;
}

Referenced by PdhValidatePathExA(), and test_PdhValidatePathA().

PdhValidatePathExA()

PDH_STATUS WINAPI PdhValidatePathExA	(	PDH_HLOG	,
		LPCSTR
	)

Definition at line 1107 of file pdh_main.c.

{
    TRACE("%p %s\n", source, debugstr_a(path));

    if (source)
    {
        FIXME("log file data source not supported\n");
        return ERROR_SUCCESS;
    }
    return PdhValidatePathA( path );
}

Referenced by init_function_ptrs().

PdhValidatePathExW()

PDH_STATUS WINAPI PdhValidatePathExW	(	PDH_HLOG	,
		LPCWSTR
	)

Definition at line 1122 of file pdh_main.c.

{
    TRACE("%p %s\n", source, debugstr_w(path));

    if (source)
    {
        FIXME("log file data source not supported\n");
        return ERROR_SUCCESS;
    }
    return PdhValidatePathW( path );
}

Referenced by init_function_ptrs().

PdhValidatePathW()

PDH_STATUS WINAPI PdhValidatePathW

(

LPCWSTR

)

Definition at line 1077 of file pdh_main.c.

{
    PDH_STATUS ret;
    unsigned int i;

    TRACE("%s\n", debugstr_w(path));

    if ((ret = validate_path( path ))) return ret;

    for (i = 0; i < ARRAY_SIZE(counter_sources); i++)
        if (pdh_match_path( counter_sources[i].path, path )) return ERROR_SUCCESS;

    return PDH_CSTATUS_NO_COUNTER;
}

Referenced by PdhValidatePathA(), PdhValidatePathExW(), and test_PdhValidatePathW().