QueryAllTracesW-Funktion (evntrace.h)

Die QueryAllTraces--Funktion ruft die Eigenschaften und Statistiken für alle Ereignisablaufverfolgungssitzungen ab, für die der Aufrufer über die Berechtigung zum Abfragen verfügt.

Syntax

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

Parameter

[out] PropertyArray

Ein Array von Zeigern auf EVENT_TRACE_PROPERTIES Strukturen, die Sitzungseigenschaften und Statistiken für die Ereignisablaufverfolgungssitzungen empfangen.

Sie müssen nur die Wnode.BufferSize-, LoggerNameOffset- und LogFileNameOffset Member der EVENT_TRACE_PROPERTIES-Struktur festlegen. Die anderen Member sollten alle auf Null festgelegt werden.

[in] PropertyArrayCount

Anzahl der Strukturen im PropertyArray Array. Dieser Wert muss kleiner oder gleich 64 sein, die maximale Anzahl von Ereignisablaufverfolgungssitzungen, die ETW unterstützt.

Windows 10:PropertyArrayCount- kann größer als 64 sein, und einige Systeme unterstützen möglicherweise mehr als 64 Ablaufverfolgungssitzungen.

[out] LoggerCount

Die tatsächliche Anzahl der ereignisablaufverfolgungssitzungen, die auf dem Computer gestartet wurden.

Rückgabewert

Wenn die Funktion erfolgreich ist, wird der Rückgabewert ERROR_SUCCESS.

Wenn die Funktion fehlschlägt, ist der Rückgabewert einer der Systemfehlercodes. Im Folgenden finden Sie einige häufige Fehler und deren Ursachen.

• ERROR_INVALID_PARAMETER

  Eine der folgenden Punkte ist wahr:

  • PropertyArrayCount- ist null oder größer als die maximale Anzahl unterstützter Sitzungen.
  • PropertyArray- ist NULL-

• ERROR_MORE_DATA

  Das Eigenschaftenarray ist zu klein, um Informationen für alle Sitzungen zu empfangen (SessionCount ist größer als PropertyArrayCount). Die Funktion füllt das Eigenschaftenarray mit der Anzahl der Eigenschaftenstrukturen aus, die in PropertyArrayCountangegeben sind.

Bemerkungen

Ereignisablaufverfolgungscontroller rufen diese Funktion auf.

Diese Funktion ruft die Ablaufverfolgungssitzungen ab, die der Aufrufer zum Abfragen besitzt. Benutzer, die mit erhöhten Administratorrechten, Benutzern in der Gruppe "Performance Log Users" ausgeführt werden, und Dienste, die als LocalSystem, LocalService, NetworkService ausgeführt werden, können alle Ablaufverfolgungssitzungen anzeigen.

Diese Funktion gibt keine privaten Protokollierungssitzungen zurück.

Um Informationen für eine einzelne Sitzung abzurufen, verwenden Sie die ControlTrace--Funktion, und legen Sie den ControlCode Parameter auf EVENT_TRACE_CONTROL_QUERYfest.

Beispiele

Das folgende Beispiel zeigt, wie diese Funktion aufgerufen wird.

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

Anforderungen

Siehe auch

ControlTrace-

EVENT_TRACE_PROPERTIES

EnumerateTraceGuids