Partager via


QueryAllTracesW, fonction (evntrace.h)

La fonction QueryAllTraces récupère les propriétés et les statistiques de toutes les sessions de suivi d’événements pour lesquelles l’appelant dispose des autorisations d’interrogation.

Syntaxe

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

Paramètres

[out] PropertyArray

Tableau de pointeurs vers EVENT_TRACE_PROPERTIES structures qui reçoivent des propriétés de session et des statistiques pour les sessions de suivi d’événements.

Vous devez uniquement définir lesWnode.BufferSize , LoggerNameOffset et LogFileNameOffset membres de la structure EVENT_TRACE_PROPERTIES. Les autres membres doivent tous avoir la valeur zéro.

[in] PropertyArrayCount

Nombre de structures dans le tableau PropertyArray. Cette valeur doit être inférieure ou égale à 64, le nombre maximal de sessions de suivi d’événements pris en charge par ETW.

Windows 10 :PropertyArrayCount peut être supérieure à 64 et certains systèmes peuvent prendre en charge plus de 64 sessions de suivi.

[out] LoggerCount

Nombre réel de sessions de suivi d’événements démarrées sur l’ordinateur.

Valeur de retour

Si la fonction réussit, la valeur de retour est ERROR_SUCCESS.

Si la fonction échoue, la valeur de retour est l’un des codes d’erreur système . Voici quelques erreurs courantes et leurs causes.

  • ERROR_INVALID_PARAMETER

    L’une des valeurs suivantes est vraie :

    • PropertyArrayCount est égal ou supérieur au nombre maximal de sessions prises en charge
    • PropertyArray est NULL
  • ERROR_MORE_DATA

    Le tableau de propriétés est trop petit pour recevoir des informations pour toutes les sessions (SessionCount est supérieur à PropertyArrayCount). La fonction remplit le tableau de propriétés avec le nombre de structures de propriété spécifiées dans PropertyArrayCount.

Remarques

Les contrôleurs de trace d’événements appellent cette fonction.

Cette fonction récupère les sessions de trace que l’appelant a les autorisations nécessaires pour interroger. Les utilisateurs s’exécutant avec des privilèges d’administration élevés, des utilisateurs du groupe Utilisateurs du journal des performances et des services s’exécutant en tant que LocalSystem, LocalService, NetworkService peuvent afficher toutes les sessions de suivi.

Cette fonction ne retourne pas de sessions de journalisation privées.

Pour récupérer des informations pour une session unique, utilisez la fonction ControlTrace et définissez le paramètre ControlCode sur EVENT_TRACE_CONTROL_QUERY.

Exemples

L’exemple suivant montre comment appeler cette fonction.

#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;
}

Note

L’en-tête evntrace.h définit QueryAllTraces comme alias qui sélectionne automatiquement la version ANSI ou Unicode de cette fonction en fonction de la définition de la constante de préprocesseur UNICODE. Le mélange de l’utilisation de l’alias neutre en encodage avec du code qui n’est pas neutre en encodage peut entraîner des incompatibilités qui entraînent des erreurs de compilation ou d’exécution. Pour plus d’informations, consultez Conventions pour les prototypes de fonction.

Exigences

Exigence Valeur
client minimum pris en charge Windows 2000 Professionnel [applications de bureau uniquement]
serveur minimum pris en charge Windows 2000 Server [applications de bureau uniquement]
plateforme cible Windows
d’en-tête evntrace.h
bibliothèque Sechost.lib sur Windows 8.1 et Windows Server 2012 R2 ; Advapi32.lib sur Windows 8, Windows Server 2012, Windows 7, Windows Server 2008 R2, Windows Server 2008, Windows Vista et Windows XP
DLL Sechost.dll sur Windows 8.1 et Windows Server 2012 R2 ; Advapi32.dll sur Windows 8, Windows Server 2012, Windows 7, Windows Server 2008 R2, Windows Server 2008, Windows Vista et Windows XP

Voir aussi

ControlTrace

EVENT_TRACE_PROPERTIES

EnumerateTraceGuids