Funzione QueryAllTracesA (evntrace.h)

La funzione QueryAllTraces recupera le proprietà e le statistiche per tutte le sessioni di traccia eventi per cui il chiamante dispone delle autorizzazioni per la query.

Sintassi

ULONG WMIAPI QueryAllTracesA(
  [out] PEVENT_TRACE_PROPERTIES *PropertyArray,
  [in]  ULONG                   PropertyArrayCount,
  [out] PULONG                  LoggerCount
);

Parametri

[out] PropertyArray

Matrice di puntatori alle strutture EVENT_TRACE_PROPERTIES che ricevono proprietà e statistiche di sessione per le sessioni di traccia eventi.

È necessario impostare solo i membri Wnode.BufferSize, LoggerNameOffset e LogFileNameOffset della struttura EVENT_TRACE_PROPERTIES . Gli altri membri devono essere impostati su zero.

[in] PropertyArrayCount

Numero di strutture nella matrice PropertyArray . Questo valore deve essere minore o uguale a 64, numero massimo di sessioni di traccia eventi supportate da ETW.

Windows 10:PropertyArrayCount può essere maggiore di 64 e alcuni sistemi possono supportare più di 64 sessioni di traccia.

[out] LoggerCount

Riceve il numero di tracce per cui vengono restituiti i dati. Ciò può variare dal numero effettivo di sessioni di traccia eventi in esecuzione se il chiamante non dispone delle autorizzazioni per eseguire query su tutte le sessioni.

Valore restituito

Se la funzione ha esito positivo, il valore restituito è ERROR_SUCCESS.

Se la funzione ha esito negativo, il valore restituito è uno dei codici di errore di sistema. Di seguito sono riportati alcuni errori comuni e le relative cause.

• ERROR_INVALID_PARAMETER

  Una delle seguenti condizioni è vera:

  • PropertyArrayCount è zero o maggiore del numero massimo di sessioni supportate
  • PropertyArray è NULL

• ERROR_MORE_DATA

  La matrice di proprietà è troppo piccola per ricevere informazioni per tutte le sessioni (SessionCount è maggiore di PropertyArrayCount). La funzione riempie la matrice di proprietà con il numero di strutture delle proprietà specificate in PropertyArrayCount.

Commenti

I controller di traccia eventi chiamano questa funzione.

Questa funzione recupera le sessioni di traccia che il chiamante dispone delle autorizzazioni per la query. Gli utenti che eseguono con privilegi amministrativi elevati, utenti nel gruppo Utenti log prestazioni e servizi in esecuzione come LocalSystem, LocalService, NetworkService possono visualizzare la maggior parte delle sessioni di traccia.

Questa funzione non restituisce sessioni di registrazione private.

Per recuperare informazioni per una singola sessione, usare la funzione ControlTrace e impostare il parametro ControlCode su EVENT_TRACE_CONTROL_QUERY.

Esempio

Nell'esempio seguente viene illustrato come chiamare questa funzione.

#include <windows.h>
#include <evntrace.h>
#include <vector>

const unsigned MAX_SESSION_NAME_LEN = 1024;
const unsigned MAX_LOGFILE_PATH_LEN = 1024;
const unsigned PropertiesSize =
    sizeof(EVENT_TRACE_PROPERTIES) +
    (MAX_SESSION_NAME_LEN * sizeof(WCHAR)) +
    (MAX_LOGFILE_PATH_LEN * sizeof(WCHAR));

int wmain()
{
    ULONG status;
    std::vector<EVENT_TRACE_PROPERTIES*> sessions; // Array of pointers to property structures
    std::vector<BYTE> buffer;                      // Buffer that contains all the property structures
    ULONG sessionCount;                            // Actual number of sessions started on the computer

    // The size of the session name and log file name used by the
    // controllers are not known, therefore create a properties structure that allows
    // for the maximum size of both.

    try
    {
        sessionCount = 64; // Start with room for 64 sessions.
        do
        {
            sessions.resize(sessionCount);
            buffer.resize(PropertiesSize * sessionCount);

            for (size_t i = 0; i != sessions.size(); i += 1)
            {
                sessions[i] = (EVENT_TRACE_PROPERTIES*)&buffer[i * PropertiesSize];
                sessions[i]->Wnode.BufferSize = PropertiesSize;
                sessions[i]->LoggerNameOffset = sizeof(EVENT_TRACE_PROPERTIES);
                sessions[i]->LogFileNameOffset = sizeof(EVENT_TRACE_PROPERTIES) + (MAX_SESSION_NAME_LEN * sizeof(WCHAR));
            }

            status = QueryAllTracesW(&sessions[0], sessionCount, &sessionCount);
        } while (status == ERROR_MORE_DATA);

        if (status != ERROR_SUCCESS)
        {
            printf("Error calling QueryAllTraces: %u\n", status);
        }
        else
        {
            printf("Actual session count: %u.\n\n", sessionCount);

            for (ULONG i = 0; i < sessionCount; i++)
            {
                WCHAR sessionGuid[50];
                (void)StringFromGUID2(sessions[i]->Wnode.Guid, sessionGuid, ARRAYSIZE(sessionGuid));

                printf(
                    "Session GUID: %ls\n"
                    "Session ID: %llu\n"
                    "Session name: %ls\n"
                    "Log file: %ls\n"
                    "min buffers: %u\n"
                    "max buffers: %u\n"
                    "buffers: %u\n"
                    "buffers written: %u\n"
                    "buffers lost: %u\n"
                    "events lost: %u\n"
                    "\n",
                    sessionGuid,
                    sessions[i]->Wnode.HistoricalContext,
                    (PCWSTR)((LPCBYTE)sessions[i] + sessions[i]->LoggerNameOffset),
                    (PCWSTR)((LPCBYTE)sessions[i] + sessions[i]->LogFileNameOffset),
                    sessions[i]->MinimumBuffers,
                    sessions[i]->MaximumBuffers,
                    sessions[i]->NumberOfBuffers,
                    sessions[i]->BuffersWritten,
                    sessions[i]->LogBuffersLost,
                    sessions[i]->EventsLost);
            }
        }
    }
    catch (std::bad_alloc const&)
    {
        printf("Error allocating memory for properties.\n");
        status = ERROR_OUTOFMEMORY;
    }

    return status;
}

Requisiti

Vedi anche

ControlTrace

EVENT_TRACE_PROPERTIES

EnumerateTraceGuids