perflib.h File Reference

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

Go to the source code of this file.

Classes
struct	_PERF_COUNTERSET_INFO
struct	_PERF_COUNTERSET_INSTANCE
struct	_PERF_COUNTER_INFO
struct	_PROVIDER_CONTEXT
struct	_PERF_COUNTER_IDENTIFIER
struct	_PERF_DATA_HEADER

Macros
#define	PERF_COUNTERSET_FLAG_MULTIPLE   0x00000002
#define	PERF_COUNTERSET_FLAG_AGGREGATE   0x00000004
#define	PERF_COUNTERSET_FLAG_HISTORY   0x00000008
#define	PERF_COUNTERSET_FLAG_INSTANCE   0x00000010
#define	PERF_COUNTERSET_SINGLE_INSTANCE   0
#define	PERF_COUNTERSET_MULTI_INSTANCES   PERF_COUNTERSET_FLAG_MULTIPLE
#define	PERF_COUNTERSET_SINGLE_AGGREGATE   PERF_COUNTERSET_FLAG_AGGREGATE
#define	PERF_COUNTERSET_MULTI_AGGREGATE   (PERF_COUNTERSET_FLAG_AGGREGATE | PERF_COUNTERSET_FLAG_MULTIPLE)
#define	PERF_COUNTERSET_SINGLE_AGGREGATE_HISTORY   (PERF_COUNTERSET_FLAG_HISTORY | PERF_COUNTERSET_SINGLE_AGGREGATE)
#define	PERF_COUNTERSET_INSTANCE_AGGREGATE   (PERF_COUNTERSET_MULTI_AGGREGATE | PERF_COUNTERSET_FLAG_INSTANCE)
#define	PERF_ATTRIB_BY_REFERENCE   0x00000001
#define	PERF_ATTRIB_NO_DISPLAYABLE   0x00000002
#define	PERF_ATTRIB_NO_GROUP_SEPARATOR   0x00000004
#define	PERF_ATTRIB_DISPLAY_AS_REAL   0x00000008
#define	PERF_ATTRIB_DISPLAY_AS_HEX   0x00000010
#define	PERF_WILDCARD_COUNTER   0xFFFFFFFF
#define	PERF_WILDCARD_INSTANCE   L"*"

Typedefs
typedef void *	__WINE_ALLOC_SIZE(1) CDECL *PERF_MEM_ALLOC) (SIZE_T
typedef void void *typedef void(CDECL *	PERF_MEM_FREE) (LPVOID, LPVOID)
typedef ULONG(WINAPI *	PERFLIBREQUEST) (ULONG, PVOID, ULONG)
typedef struct _PERF_COUNTERSET_INFO	PERF_COUNTERSET_INFO
typedef struct _PERF_COUNTERSET_INFO *	PPERF_COUNTERSET_INFO
typedef struct _PERF_COUNTERSET_INSTANCE	PERF_COUNTERSET_INSTANCE
typedef struct _PERF_COUNTERSET_INSTANCE *	PPERF_COUNTERSET_INSTANCE
typedef struct _PERF_COUNTER_INFO	PERF_COUNTER_INFO
typedef struct _PERF_COUNTER_INFO *	PPERF_COUNTER_INFO
typedef struct _PROVIDER_CONTEXT	PERF_PROVIDER_CONTEXT
typedef struct _PROVIDER_CONTEXT *	PPERF_PROVIDER_CONTEXT
typedef struct _PERF_COUNTER_IDENTIFIER	PERF_COUNTER_IDENTIFIER
typedef struct _PERF_COUNTER_IDENTIFIER *	PPERF_COUNTER_IDENTIFIER
typedef struct _PERF_DATA_HEADER	PERF_DATA_HEADER
typedef struct _PERF_DATA_HEADER *	PPERF_DATA_HEADER

Functions
PERF_COUNTERSET_INSTANCE WINAPI *	PerfCreateInstance (HANDLE, const GUID *, const WCHAR *, ULONG)
ULONG WINAPI	PerfDeleteInstance (HANDLE, PERF_COUNTERSET_INSTANCE *)
ULONG WINAPI	PerfSetCounterRefValue (HANDLE, PERF_COUNTERSET_INSTANCE *, ULONG, void *)
ULONG WINAPI	PerfSetCounterSetInfo (HANDLE, PERF_COUNTERSET_INFO *, ULONG)
ULONG WINAPI	PerfStartProvider (GUID *, PERFLIBREQUEST, HANDLE *)
ULONG WINAPI	PerfStartProviderEx (GUID *, PERF_PROVIDER_CONTEXT *, HANDLE *)
ULONG WINAPI	PerfStopProvider (HANDLE)
ULONG WINAPI	PerfAddCounters (HANDLE, PERF_COUNTER_IDENTIFIER *, DWORD)
ULONG WINAPI	PerfCloseQueryHandle (HANDLE)
ULONG WINAPI	PerfOpenQueryHandle (const WCHAR *, HANDLE *)
ULONG WINAPI	PerfQueryCounterData (HANDLE, PERF_DATA_HEADER *, DWORD, DWORD *)

Macro Definition Documentation

PERF_ATTRIB_BY_REFERENCE

#define PERF_ATTRIB_BY_REFERENCE   0x00000001

Definition at line 69 of file perflib.h.

PERF_ATTRIB_DISPLAY_AS_HEX

#define PERF_ATTRIB_DISPLAY_AS_HEX   0x00000010

Definition at line 73 of file perflib.h.

PERF_ATTRIB_DISPLAY_AS_REAL

#define PERF_ATTRIB_DISPLAY_AS_REAL   0x00000008

Definition at line 72 of file perflib.h.

PERF_ATTRIB_NO_DISPLAYABLE

#define PERF_ATTRIB_NO_DISPLAYABLE   0x00000002

Definition at line 70 of file perflib.h.

PERF_ATTRIB_NO_GROUP_SEPARATOR

#define PERF_ATTRIB_NO_GROUP_SEPARATOR   0x00000004

Definition at line 71 of file perflib.h.

PERF_COUNTERSET_FLAG_AGGREGATE

#define PERF_COUNTERSET_FLAG_AGGREGATE   0x00000004

Definition at line 39 of file perflib.h.

PERF_COUNTERSET_FLAG_HISTORY

#define PERF_COUNTERSET_FLAG_HISTORY   0x00000008

Definition at line 40 of file perflib.h.

PERF_COUNTERSET_FLAG_INSTANCE

#define PERF_COUNTERSET_FLAG_INSTANCE   0x00000010

Definition at line 41 of file perflib.h.

PERF_COUNTERSET_FLAG_MULTIPLE

#define PERF_COUNTERSET_FLAG_MULTIPLE   0x00000002

Definition at line 38 of file perflib.h.

PERF_COUNTERSET_INSTANCE_AGGREGATE

#define PERF_COUNTERSET_INSTANCE_AGGREGATE   (PERF_COUNTERSET_MULTI_AGGREGATE | PERF_COUNTERSET_FLAG_INSTANCE)

Definition at line 48 of file perflib.h.

PERF_COUNTERSET_MULTI_AGGREGATE

#define PERF_COUNTERSET_MULTI_AGGREGATE   (PERF_COUNTERSET_FLAG_AGGREGATE | PERF_COUNTERSET_FLAG_MULTIPLE)

Definition at line 46 of file perflib.h.

PERF_COUNTERSET_MULTI_INSTANCES

#define PERF_COUNTERSET_MULTI_INSTANCES   PERF_COUNTERSET_FLAG_MULTIPLE

Definition at line 44 of file perflib.h.

PERF_COUNTERSET_SINGLE_AGGREGATE

#define PERF_COUNTERSET_SINGLE_AGGREGATE   PERF_COUNTERSET_FLAG_AGGREGATE

Definition at line 45 of file perflib.h.

PERF_COUNTERSET_SINGLE_AGGREGATE_HISTORY

#define PERF_COUNTERSET_SINGLE_AGGREGATE_HISTORY   (PERF_COUNTERSET_FLAG_HISTORY | PERF_COUNTERSET_SINGLE_AGGREGATE)

Definition at line 47 of file perflib.h.

PERF_COUNTERSET_SINGLE_INSTANCE

#define PERF_COUNTERSET_SINGLE_INSTANCE   0

Definition at line 43 of file perflib.h.

PERF_WILDCARD_COUNTER

#define PERF_WILDCARD_COUNTER   0xFFFFFFFF

Definition at line 94 of file perflib.h.

PERF_WILDCARD_INSTANCE

#define PERF_WILDCARD_INSTANCE   L"*"

Definition at line 95 of file perflib.h.

Typedef Documentation

__WINE_ALLOC_SIZE

typedef void * __WINE_ALLOC_SIZE(1) CDECL *PERF_MEM_ALLOC)(SIZE_T

Definition at line 26 of file perflib.h.

PERF_COUNTER_IDENTIFIER

typedef struct _PERF_COUNTER_IDENTIFIER PERF_COUNTER_IDENTIFIER

PERF_COUNTER_INFO

typedef struct _PERF_COUNTER_INFO PERF_COUNTER_INFO

PERF_COUNTERSET_INFO

typedef struct _PERF_COUNTERSET_INFO PERF_COUNTERSET_INFO

PERF_COUNTERSET_INSTANCE

typedef struct _PERF_COUNTERSET_INSTANCE PERF_COUNTERSET_INSTANCE

PERF_DATA_HEADER

typedef struct _PERF_DATA_HEADER PERF_DATA_HEADER

PERF_MEM_FREE

typedef void void *typedef void(CDECL * PERF_MEM_FREE) (LPVOID, LPVOID)

Definition at line 27 of file perflib.h.

PERF_PROVIDER_CONTEXT

typedef struct _PROVIDER_CONTEXT PERF_PROVIDER_CONTEXT

PERFLIBREQUEST

typedef ULONG(WINAPI * PERFLIBREQUEST) (ULONG, PVOID, ULONG)

Definition at line 28 of file perflib.h.

PPERF_COUNTER_IDENTIFIER

typedef struct _PERF_COUNTER_IDENTIFIER * PPERF_COUNTER_IDENTIFIER

PPERF_COUNTER_INFO

typedef struct _PERF_COUNTER_INFO * PPERF_COUNTER_INFO

PPERF_COUNTERSET_INFO

typedef struct _PERF_COUNTERSET_INFO * PPERF_COUNTERSET_INFO

PPERF_COUNTERSET_INSTANCE

typedef struct _PERF_COUNTERSET_INSTANCE * PPERF_COUNTERSET_INSTANCE

PPERF_DATA_HEADER

typedef struct _PERF_DATA_HEADER * PPERF_DATA_HEADER

PPERF_PROVIDER_CONTEXT

typedef struct _PROVIDER_CONTEXT * PPERF_PROVIDER_CONTEXT

Function Documentation

PerfAddCounters()

ULONG WINAPI PerfAddCounters	(	HANDLE	,
		PERF_COUNTER_IDENTIFIER *	,
		DWORD
	)

PerfCloseQueryHandle()

ULONG WINAPI PerfCloseQueryHandle

(

HANDLE

)

PerfCreateInstance()

PERF_COUNTERSET_INSTANCE WINAPI * PerfCreateInstance	(	HANDLE	handle,
		const GUID *	guid,
		const WCHAR *	name,
		ULONG	id
	)

Definition at line 181 of file main.c.

{
    struct perf_provider *prov = perf_provider_from_handle( handle );
    struct counterset_template *template;
    struct counterset_instance *inst;
    unsigned int i;
    ULONG size;
 
    FIXME( "handle %p, guid %s, name %s, id %lu semi-stub.\n", handle, debugstr_guid(guid), debugstr_w(name), id );
 
    if (!prov || !guid || !name)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return NULL;
    }
 
    for (i = 0; i < prov->counterset_count; ++i)
        if (IsEqualGUID(guid, &prov->countersets[i]->counterset.CounterSetGuid)) break;
 
    if (i == prov->counterset_count)
    {
        SetLastError( ERROR_NOT_FOUND );
        return NULL;
    }
 
    template = prov->countersets[i];
 
    LIST_FOR_EACH_ENTRY(inst, &prov->instance_list, struct counterset_instance, entry)
    {
        if (inst->template == template && inst->instance.InstanceId == id)
        {
            SetLastError( ERROR_ALREADY_EXISTS );
            return NULL;
        }
    }
 
    size = (sizeof(PERF_COUNTERSET_INSTANCE) + template->counterset.NumCounters * sizeof(UINT64)
            + (lstrlenW( name ) + 1) * sizeof(WCHAR) + 7) & ~7;
    inst = heap_alloc_zero( offsetof(struct counterset_instance, instance) + size );
    if (!inst)
    {
        SetLastError( ERROR_OUTOFMEMORY );
        return NULL;
    }
 
    inst->template = template;
    inst->instance.CounterSetGuid = *guid;
    inst->instance.dwSize = size;
    inst->instance.InstanceId = id;
    inst->instance.InstanceNameOffset = sizeof(PERF_COUNTERSET_INSTANCE)
                                        + template->counterset.NumCounters * sizeof(UINT64);
    inst->instance.InstanceNameSize = (lstrlenW( name ) + 1) * sizeof(WCHAR);
    memcpy( (BYTE *)&inst->instance + inst->instance.InstanceNameOffset, name, inst->instance.InstanceNameSize );
    list_add_tail( &prov->instance_list, &inst->entry );
 
    return &inst->instance;
}

PerfDeleteInstance()

ULONG WINAPI PerfDeleteInstance	(	HANDLE	provider,
		PERF_COUNTERSET_INSTANCE *	block
	)

Definition at line 243 of file main.c.

{
    struct perf_provider *prov = perf_provider_from_handle( provider );
    struct counterset_instance *inst;
 
    TRACE( "provider %p, block %p.\n", provider, block );
 
    if (!prov || !block) return ERROR_INVALID_PARAMETER;
 
    inst = CONTAINING_RECORD(block, struct counterset_instance, instance);
    list_remove( &inst->entry );
    heap_free( inst );
 
    return ERROR_SUCCESS;
}

PerfOpenQueryHandle()

ULONG WINAPI PerfOpenQueryHandle	(	const WCHAR *	,
		HANDLE *
	)

PerfQueryCounterData()

ULONG WINAPI PerfQueryCounterData	(	HANDLE	,
		PERF_DATA_HEADER *	,
		DWORD	,
		DWORD *
	)

PerfSetCounterRefValue()

ULONG WINAPI PerfSetCounterRefValue	(	HANDLE	provider,
		PERF_COUNTERSET_INSTANCE *	instance,
		ULONG	counterid,
		void *	address
	)

Definition at line 307 of file main.c.

{
    struct perf_provider *prov = perf_provider_from_handle( provider );
    struct counterset_template *template;
    struct counterset_instance *inst;
    unsigned int i;
 
    FIXME( "provider %p, instance %p, counterid %lu, address %p semi-stub.\n",
           provider, instance, counterid, address );
 
    if (!prov || !instance || !address) return ERROR_INVALID_PARAMETER;
 
    inst = CONTAINING_RECORD(instance, struct counterset_instance, instance);
    template = inst->template;
 
    for (i = 0; i < template->counterset.NumCounters; ++i)
        if (template->counter[i].CounterId == counterid) break;
 
    if (i == template->counterset.NumCounters) return ERROR_NOT_FOUND;
    *(void **)((BYTE *)&inst->instance + sizeof(PERF_COUNTERSET_INSTANCE) + template->counter[i].Offset) = address;
 
    return STATUS_SUCCESS;
}

PerfSetCounterSetInfo()

ULONG WINAPI PerfSetCounterSetInfo	(	HANDLE	handle,
		PERF_COUNTERSET_INFO *	template,
		ULONG	size
	)

Definition at line 262 of file main.c.

{
    struct perf_provider *prov = perf_provider_from_handle( handle );
    struct counterset_template **new_array;
    struct counterset_template *new;
    unsigned int i;
 
    FIXME( "handle %p, template %p, size %lu semi-stub.\n", handle, template, size );
 
    if (!prov || !template) return ERROR_INVALID_PARAMETER;
    if (!template->NumCounters) return ERROR_INVALID_PARAMETER;
    if (size < sizeof(*template) || (size - (sizeof(*template))) / sizeof(PERF_COUNTER_INFO) < template->NumCounters)
        return ERROR_INVALID_PARAMETER;
 
    for (i = 0; i < prov->counterset_count; ++i)
    {
        if (IsEqualGUID( &template->CounterSetGuid, &prov->countersets[i]->counterset.CounterSetGuid ))
            return ERROR_ALREADY_EXISTS;
    }
 
    size = offsetof( struct counterset_template, counter[template->NumCounters] );
    if (!(new = heap_alloc( size ))) return ERROR_OUTOFMEMORY;
 
    if (prov->counterset_count)
        new_array = heap_realloc( prov->countersets, sizeof(*prov->countersets) * (prov->counterset_count + 1) );
    else
        new_array = heap_alloc( sizeof(*prov->countersets) );
 
    if (!new_array)
    {
        heap_free( new );
        return ERROR_OUTOFMEMORY;
    }
    memcpy( new, template, size );
    for (i = 0; i < template->NumCounters; ++i)
        new->counter[i].Offset = i * sizeof(UINT64);
    new_array[prov->counterset_count++] = new;
    prov->countersets = new_array;
 
    return STATUS_SUCCESS;
}

PerfStartProvider()

ULONG WINAPI PerfStartProvider	(	GUID *	guid,
		PERFLIBREQUEST	callback,
		HANDLE *	provider
	)

Definition at line 335 of file main.c.

{
    PERF_PROVIDER_CONTEXT ctx;
 
    FIXME( "guid %s, callback %p, provider %p semi-stub.\n", debugstr_guid(guid), callback, provider );
 
    memset( &ctx, 0, sizeof(ctx) );
    ctx.ContextSize = sizeof(ctx);
    ctx.ControlCallback = callback;
 
    return PerfStartProviderEx( guid, &ctx, provider );
}

PerfStartProviderEx()

ULONG WINAPI PerfStartProviderEx	(	GUID *	guid,
		PERF_PROVIDER_CONTEXT *	context,
		HANDLE *	provider
	)

Definition at line 351 of file main.c.

{
    struct perf_provider *prov;
 
    FIXME( "guid %s, context %p, provider %p semi-stub.\n", debugstr_guid(guid), context, provider );
 
    if (!guid || !context || !provider) return ERROR_INVALID_PARAMETER;
    if (context->ContextSize < sizeof(*context)) return ERROR_INVALID_PARAMETER;
 
    if (context->MemAllocRoutine || context->MemFreeRoutine)
        FIXME("Memory allocation routine is not supported.\n");
 
    if (!(prov = heap_alloc_zero( sizeof(*prov) ))) return ERROR_OUTOFMEMORY;
    list_init( &prov->instance_list );
    memcpy( &prov->guid, guid, sizeof(prov->guid) );
    prov->callback = context->ControlCallback;
    *provider = prov;
 
    return STATUS_SUCCESS;
}

Referenced by PerfStartProvider().

PerfStopProvider()

ULONG WINAPI PerfStopProvider

(

HANDLE

handle

)

Definition at line 375 of file main.c.

{
    struct perf_provider *prov = perf_provider_from_handle( handle );
    struct counterset_instance *inst, *next;
    unsigned int i;
 
    TRACE( "handle %p.\n", handle );
 
    if (!list_empty( &prov->instance_list ))
        WARN( "Stopping provider with active counter instances.\n" );
 
    LIST_FOR_EACH_ENTRY_SAFE(inst, next, &prov->instance_list, struct counterset_instance, entry)
    {
        list_remove( &inst->entry );
        heap_free( inst );
    }
 
    for (i = 0; i < prov->counterset_count; ++i)
        heap_free( prov->countersets[i] );
    heap_free( prov->countersets );
    heap_free( prov );
    return STATUS_SUCCESS;
}