Funzione QueryAllTracesW (evntrace.h)

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

Sintassi

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

Parametri

[out] PropertyArray

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

È sufficiente impostare Wnode.BufferSize, LoggerNameOffset e LogFileNameOffset membri 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, il 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

Numero effettivo di sessioni di traccia eventi avviate nel computer.

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 condizioni seguenti è vera:

  • PropertyArrayCount è pari a 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 di proprietà specificate in PropertyArrayCount.

Osservazioni

I controller di traccia eventi chiamano questa funzione.

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

Questa funzione non restituisce sessioni di registrazione private.

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

Esempi

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(CHAR)) +
    (MAX_LOGFILE_PATH_LEN * sizeof(CHAR));

int main()
{
    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(CHAR));
            }

            status = QueryAllTracesA(&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: %s\n"
                    "Log file: %s\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,
                    (PCSTR)((LPCBYTE)sessions[i] + sessions[i]->LoggerNameOffset),
                    (PCSTR)((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;
}

Fabbisogno

Vedere anche

ControlTrace

EVENT_TRACE_PROPERTIES

EnumerateTraceGuids