Udostępnij przez

Dodawanie śledzenia zdarzeń do sterowników Kernel-Mode

W tej sekcji opisano sposób używania śledzenia zdarzeń dla interfejsu API trybu jądra systemu Windows (ETW) w celu dodania śledzenia zdarzeń do sterowników trybu jądra. Interfejs API trybu jądra ETW został wprowadzony w systemie Windows Vista i nie jest obsługiwany we wcześniejszych systemach operacyjnych. Użyj funkcji śledzenia oprogramowania WPP lub śledzenia zdarzeń WMI , jeśli sterownik musi obsługiwać funkcję śledzenia w systemie Windows 2000 lub nowszym.

Wskazówka

Aby wyświetlić przykładowy kod pokazujący sposób implementowania funkcji ETW przy użyciu zestawu Windows Driver Kit (WDK) i programu Visual Studio, zobacz przykład Eventdrv.

W tej sekcji:

Proces roboczy — dodawanie śledzenia zdarzeń do sterowników Kernel-Mode

1. Decydowanie o typie zdarzeń do zgłoszenia i miejscu ich publikowania

2. Utwórz manifest instrumentacji, który definiuje dostawcę, zdarzenia i kanały

3. Skompiluj manifest instrumentacji przy użyciu kompilatora komunikatów (Mc.exe)

4. Dodaj wygenerowany kod, aby zgłosić (opublikować) zdarzenia (zarejestrować, wyrejestrować i napisać zdarzenia)

5. Skompiluj sterownik

6. Instalowanie manifestu

7. Przetestuj sterownik, aby zweryfikować obsługę funkcji ETW

Przepływ pracy — dodawanie śledzenia zdarzeń do sterowników Kernel-Mode

Schemat blokowy przedstawiający proces dodawania śledzenia zdarzeń do sterowników trybu jądra.

1. Decydowanie o typie zdarzeń do zgłoszenia i miejscu ich publikowania

Przed rozpoczęciem kodowania musisz zdecydować, jakiego typu zdarzenia mają być rejestrowane przez sterownik za pomocą śledzenia zdarzeń dla systemu Windows (ETW). Możesz na przykład rejestrować zdarzenia, które mogą pomóc zdiagnozować problemy po dystrybucji sterownika lub zdarzenia, które mogą pomóc podczas opracowywania sterownika. Aby uzyskać informacje, zobacz Dokumentacja dziennika zdarzeń systemu Windows.

Typy zdarzeń są identyfikowane z kanałami. Kanał to nazwany strumień zdarzeń typu Administracyjne, Operacyjne, Analityczne lub Debugowanie skierowany do określonej grupy odbiorców, podobnie jak kanał telewizyjny. Kanał dostarcza zdarzenia od dostawcy zdarzeń do dzienników zdarzeń i odbiorców zdarzeń. Aby uzyskać informacje, zobacz Definiowanie kanałów.

Podczas programowania najprawdopodobniej interesuje Cię śledzenie zdarzeń, które ułatwiają debugowanie kodu. Ten sam kanał może być używany w kodzie produkcyjnym, aby ułatwić rozwiązywanie problemów, które mogą pojawić się po wdrożeniu sterownika. Możesz również chcieć śledzić zdarzenia, których można użyć do mierzenia wydajności; te zdarzenia mogą pomóc specjalistom IT w dostrojeniu wydajności serwera i mogą pomóc zidentyfikować wąskie gardła sieci.

2. Utwórz manifest instrumentacji, który definiuje dostawcę, zdarzenia i kanały

Manifest instrumentacji to plik XML, który zawiera formalny opis zdarzeń zgłaszanych przez dostawcę. Manifest instrumentacji identyfikuje dostawcę zdarzeń, określa kanał lub kanały (maksymalnie osiem) i opisuje zdarzenia oraz szablony, które są używane przez zdarzenia. Ponadto manifest instrumentacji umożliwia lokalizowanie ciągów, dzięki czemu można lokalizować komunikaty śledzenia. System zdarzeń i odbiorcy zdarzeń mogą używać ustrukturyzowanych danych XML podanych w manifeście w celu wykonywania zapytań i analizy.

Aby uzyskać informacje o manifeście instrumentacji, zobacz Pisanie manifestu instrumentacji (Windows), Schemat EventManifest (Windows) i Używanie dziennika zdarzeń systemu Windows (Windows).

Poniższy manifest instrumentacji przedstawia dostawcę zdarzeń, który używa nazwy "Przykładowy sterownik". Należy pamiętać, że ta nazwa nie musi być taka sama jak nazwa pliku binarnego sterownika. Manifest określa również identyfikator GUID dostawcy oraz ścieżki do plików komunikatów i zasobów. Pliki komunikatów i zasobów poinformują ETW, gdzie zlokalizować zasoby potrzebne do dekodowania i zgłaszania zdarzeń. Te ścieżki wskazują lokalizację pliku sterownika (.sys). Sterownik musi być zainstalowany w określonym katalogu na komputerze docelowym.

W przykładzie użyto nazwanego systemu kanału — kanału dla zdarzeń typu Admin. Ten kanał jest zdefiniowany w pliku Winmeta.xml, który jest dostarczany z zestawem Windows Driver Kit (WDK) w katalogu%WindowsSdkDir%\include\um. Kanał systemowy jest zabezpieczony dla aplikacji działających na kontach usług systemowych. Manifest zawiera szablony zdarzeń opisujące typy danych dostarczanych ze zdarzeniami po ich opublikowaniu wraz z zawartością statyczną i dynamiczną. Ten przykładowy manifest definiuje trzy zdarzenia: StartEvent, SampleEventAi UnloadEvent.

Oprócz kanałów można skojarzyć zdarzenia z poziomami i słowami kluczowymi. Słowa kluczowe i poziomy umożliwiają włączenie zdarzeń i zapewnienie mechanizmu filtrowania zdarzeń podczas ich publikowania. Słowa kluczowe mogą służyć do grupowania logicznie powiązanych zdarzeń. Poziom może służyć do wskazywania ważności lub szczegółowości zdarzenia, na przykład krytycznego, błędu, ostrzeżenia lub informacyjnego. Plik Winmeta.xml zawiera wstępnie zdefiniowane wartości atrybutów zdarzeń.

Podczas tworzenia szablonu ładunku zdarzenia (komunikat zdarzenia i dane) należy określić typy danych wejściowych i wyjściowych. Obsługiwane typy są opisane w sekcji Uwagi złożonego typu InputType (Windows).

<?xml version='1.0' encoding='utf-8' standalone='yes'?>
<instrumentationManifest
    xmlns="http://schemas.microsoft.com/win/2004/08/events"
    xmlns:win="http://manifests.microsoft.com/win/2004/08/windows/events"
    xmlns:xs="http://www.w3.org/2001/XMLSchema"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://schemas.microsoft.com/win/2004/08/events eventman.xsd"
    >
  <instrumentation>
    <events>
      <provider
          guid="{b5a0bda9-50fe-4d0e-a83d-bae3f58c94d6}"
          messageFileName="%SystemDrive%\ETWDriverSample\Eventdrv.sys"
          name="Sample Driver"
          resourceFileName="%SystemDrive%\ETWDriverSample\Eventdrv.sys"
          symbol="DriverControlGuid"
          >
        <channels>
          <importChannel
              chid="SYSTEM"
              name="System"
              />
        </channels>
        <templates>
          <template tid="tid_load_template">
            <data
                inType="win:UInt16"
                name="DeviceNameLength"
                outType="xs:unsignedShort"
                />
            <data
                inType="win:UnicodeString"
                name="name"
                outType="xs:string"
                />
            <data
                inType="win:UInt32"
                name="Status"
                outType="xs:unsignedInt"
                />
          </template>
          <template tid="tid_unload_template">
            <data
                inType="win:Pointer"
                name="DeviceObjPtr"
                outType="win:HexInt64"
                />
          </template>
        </templates>
        <events>
          <event
              channel="SYSTEM"
              level="win:Informational"
              message="$(string.StartEvent.EventMessage)"
              opcode="win:Start"
              symbol="StartEvent"
              template="tid_load_template"
              value="1"
              />
          <event
              channel="SYSTEM"
              level="win:Informational"
              message="$(string.SampleEventA.EventMessage)"
              opcode="win:Info"
              symbol="SampleEventA"
              value="2"
              />
          <event
              channel="SYSTEM"
              level="win:Informational"
              message="$(string.UnloadEvent.EventMessage)"
              opcode="win:Stop"
              symbol="UnloadEvent"
              template="tid_unload_template"
              value="3"
              />
        </events>
      </provider>
    </events>
  </instrumentation>
  <localization xmlns="http://schemas.microsoft.com/win/2004/08/events">
    <resources culture="en-US">
      <stringTable>
        <string
            id="StartEvent.EventMessage"
            value="Driver Loaded"
            />
        <string
            id="SampleEventA.EventMessage"
            value="IRP A Occurred"
            />
        <string
            id="UnloadEvent.EventMessage"
            value="Driver Unloaded"
            />
      </stringTable>
    </resources>
  </localization>
</instrumentationManifest>

3. Skompiluj manifest instrumentacji przy użyciu kompilatora komunikatów (Mc.exe)

Przed skompilowanie kodu źródłowego należy uruchomić kompilator komunikatów (Mc.exe ). Kompilator komunikatów jest dołączony do zestawu Windows Driver Kit (WDK). Kompilator komunikatów tworzy plik nagłówka zawierający definicje dostawcy zdarzeń, atrybutów zdarzeń, kanałów i zdarzeń. Ten plik nagłówka należy uwzględnić w kodzie źródłowym. Kompilator komunikatów umieszcza również wygenerowany skrypt kompilatora zasobów (*.rc) i wygenerowane pliki .bin (zasoby binarne), które zawiera skrypt kompilatora zasobów.

Ten krok można uwzględnić w ramach procesu kompilacji na kilka sposobów:

  • Dodanie zadania kompilatora komunikatów do pliku projektu sterownika (jak pokazano w przykładzie Eventdrv).

  • Używanie programu Visual Studio do dodawania manifestu instrumentacji i konfigurowania właściwości kompilatora komunikatów.

Dodawanie zadania kompilatora komunikatów do pliku projektu Aby zapoznać się z przykładem dołączania kompilatora komunikatów do procesu kompilacji, zapoznaj się z plikiem projektu dla przykładu Eventdrv. W pliku Eventdrv.vcxproj znajduje <się sekcja MessageCompile> , która wywołuje kompilator komunikatów. Kompilator komunikatów używa pliku manifestu (evntdrv.xml) jako danych wejściowych w celu wygenerowania pliku nagłówka evntdrvEvents.h. Ta sekcja określa również ścieżki dla wygenerowanych plików RC i włącza makra rejestrowania trybu jądra. Możesz skopiować tę sekcję i dodać ją do pliku projektu sterownika (.vcxproj).


    <MessageCompile Include="evntdrv.xml">
      <GenerateKernelModeLoggingMacros>true</GenerateKernelModeLoggingMacros>
      <HeaderFilePath>.\$(IntDir)</HeaderFilePath>
      <GeneratedHeaderPath>true</GeneratedHeaderPath>
      <WinmetaPath>"$(SDK_INC_PATH)\winmeta.xml"</WinmetaPath>
      <RCFilePath>.\$(IntDir)</RCFilePath>
      <GeneratedRCAndMessagesPath>true</GeneratedRCAndMessagesPath>
      <GeneratedFilesBaseName>evntdrvEvents</GeneratedFilesBaseName>
      <UseBaseNameOfInput>true</UseBaseNameOfInput>
    </MessageCompile>

Podczas tworzenia przykładu Eventdrv.sys program Visual Studio tworzy pliki niezbędne do śledzenia zdarzeń. Dodaje również manifest evntdrv.xml do listy plików zasobów dla projektu sterownika. Możesz wybrać i wstrzymać (lub kliknąć prawym przyciskiem myszy) manifest, aby wyświetlić strony właściwości kompilatora komunikatów.

Dodawanie manifestu instrumentacji przy użyciu programu Visual Studio

Manifest instrumentacji można dodać do projektu sterownika, a następnie skonfigurować właściwości kompilatora komunikatów, aby utworzyć niezbędne pliki zasobów i nagłówków.

Aby dodać manifest instrumentacji do projektu przy użyciu programu Visual Studio

  1. W Eksploratorze rozwiązań dodaj plik manifestu do projektu sterownika. Wybierz i przytrzymaj (lub kliknij prawym przyciskiem myszy) Pliki Zasobów Dodaj Istniejący Element (na przykład evntdrv.xml lub mydriver.man).

  2. Zaznacz i przytrzymaj (lub kliknij prawym przyciskiem myszy) właśnie dodany plik i użyj stron właściwości, aby zmienić typ elementu na MessageCompile i wybierz pozycję Zastosuj.

  3. Właściwości kompilatora komunikatów są wyświetlane. W obszarze Ustawienia ogólne ustaw następujące opcje, a następnie wybierz pozycję Zastosuj.

    Ogólne Ustawienie
    Generowanie makr rejestrowania trybu jądra Tak (-km)
    Użyj podstawowej nazwy danych wejściowych Tak (-b)

  4. W obszarze Opcje pliku ustaw następujące opcje, a następnie wybierz pozycję Zastosuj.

    Opcje pliku Ustawienie
    Generowanie pliku nagłówka zawierającego licznik Tak
    Ścieżka pliku nagłówka $(IntDir)
    Generowana ścieżka plików komunikatów RC i binarnych Tak
    Ścieżka pliku RC $(IntDir)
    Nazwa podstawowa wygenerowanych plików $(Nazwa pliku)

Domyślnie kompilator komunikatów używa podstawowej nazwy pliku wejściowego jako podstawowej nazwy generowanych plików. Aby określić nazwę podstawową, ustaw pole Generated Files Base Name (-z). W przykładzie Eventdr.sys nazwa bazowa jest ustawiona na evntdrvEvents , tak aby odpowiadała nazwie pliku nagłówka evntdrvEvents.h, który jest uwzględniony w evntdrv.c.

Uwaga

Jeśli nie dołączysz wygenerowanego pliku RC w projekcie programu Visual Studio, podczas instalowania pliku manifestu mogą zostać wyświetlone komunikaty o błędach dotyczące zasobów, które nie są znajdowane.

4. Dodaj wygenerowany kod, aby podnieść (opublikować) zdarzenia (zarejestrować, wyrejestrować i zapisać zdarzenia)

W manifeście instrumentacji zdefiniowano nazwy dostawcy zdarzenia i deskryptorów zdarzeń. Podczas kompilowania manifestu instrumentacji za pomocą kompilatora komunikatów kompilator komunikatów generuje plik nagłówkowy opisujący zasoby, a także definiuje makra dla zdarzeń. Teraz musisz dodać wygenerowany kod do sterownika, aby zgłosić te zdarzenia.

  1. W pliku źródłowym dołącz plik nagłówka zdarzenia, który jest generowany przez kompilator komunikatów (MC.exe). Na przykład w przykładzie Eventdrv plik źródłowy Evntdrv.c zawiera plik nagłówka (evntdrvEvents.h), który został wygenerowany w poprzednim kroku:

    #include "evntdrvEvents.h"

  2. Dodaj makra rejestrujące i wyrejestrujące sterownik jako dostawcą zdarzeń. Na przykład w pliku nagłówkowym przykładu Eventdrv (evntdrvEvents.h) kompilator komunikatów tworzy makra na podstawie nazwy dostawcy. W manifeście przykład Eventdrv używa nazwy "Przykładowy sterownik" jako nazwy dostawcy. Kompilator komunikatów łączy nazwę dostawcy z makrem zdarzenia w celu zarejestrowania dostawcy, w tym przypadku EventRegisterSample_Driver.

    //  This is the generated header file envtdrvEvents.h
//
//  ...
//
//
// Register with ETW Vista +
//
#ifndef EventRegisterSample_Driver
#define EventRegisterSample_Driver() McGenEventRegister(&DriverControlGuid, McGenControlCallbackV2, &DriverControlGuid_Context, &Sample_DriverHandle)
#endif

    Dodaj makro EventRegister<dostawcy> do funkcji DriverEntry. Dodaj tę funkcję po kodzie, który tworzy i inicjuje obiekt urządzenia. Należy pamiętać, że należy dopasować wywołanie funkcji EventRegister<provider> z wywołaniem funkcji EventUnregister<provider>. Możesz wyrejestrować sterownik w procedurze zwalniania* kierowcy.

       // DriverEntry function
   // ...


    // Register with ETW
    //
    EventRegisterSample_Driver();

  3. Dodaj wygenerowany kod do plików źródłowych sterownika, aby zapisywać (zgłaszać) zdarzenia określone w manifeście. Plik nagłówka skompilowany z manifestu zawiera wygenerowany kod sterownika. Użyj funkcji EventWrite<zdarzeń> zdefiniowanych w pliku nagłówka, aby opublikować komunikaty śledzenia do ETW. Na przykład poniższy kod przedstawia makra dla zdarzeń zdefiniowanych w pliku evntdrvEvents.h dla przykładu Eventdrv.

    Makra do zapisu tych zdarzeń są nazywane: EventWriteStartEvent, EventWriteSampleEventAi EventWriteUnloadEvent. Jak widać w definicji tych makr, definicja makr automatycznie zawiera makro zdarzenia> EventEnabled<, które sprawdza, czy zdarzenie jest włączone. Sprawdzanie eliminuje konieczność skompilowania ładunku, jeśli zdarzenie nie jest włączone.

    
///
// This is the generated header file envtdrvEvents.h
//
//  ...
//
// Enablement check macro for StartEvent
//

#define EventEnabledStartEvent() ((Sample_DriverEnableBits[0] & 0x00000001) != 0)

//
// Event Macro for StartEvent
//
#define EventWriteStartEvent(Activity, DeviceNameLength, name, Status)\
        EventEnabledStartEvent() ?\
        Template_hzq(Sample_DriverHandle, &StartEvent, Activity, DeviceNameLength, name, Status)\
        : STATUS_SUCCESS\

//
// Enablement check macro for SampleEventA
//

#define EventEnabledSampleEventA() ((Sample_DriverEnableBits[0] & 0x00000001) != 0)

//
// Event Macro for SampleEventA
//
#define EventWriteSampleEventA(Activity)\
        EventEnabledSampleEventA() ?\
        TemplateEventDescriptor(Sample_DriverHandle, &SampleEventA, Activity)\
        : STATUS_SUCCESS\

//
// Enablement check macro for UnloadEvent
//

#define EventEnabledUnloadEvent() ((Sample_DriverEnableBits[0] & 0x00000001) != 0)

//
// Event Macro for UnloadEvent
//
#define EventWriteUnloadEvent(Activity, DeviceObjPtr)\
        EventEnabledUnloadEvent() ?\
        Template_p(Sample_DriverHandle, &UnloadEvent, Activity, DeviceObjPtr)\
        : STATUS_SUCCESS\

    Dodaj makra EventWrite<zdarzeń> do kodu źródłowego dla zgłaszanych zdarzeń. Na przykład poniższy fragment kodu przedstawia procedurę DriverEntry z przykładu Eventdrv. DriverEntry zawiera makra do zarejestrowania sterownika za pomocą funkcji ETW (EventRegisterSample_Driver) i makra w celu zapisania zdarzenia sterownika do ETW (EventWriteStartEvent).

    NTSTATUS
DriverEntry(
    IN PDRIVER_OBJECT DriverObject,
    IN PUNICODE_STRING RegistryPath
    )
/*++

Routine Description:

    Installable driver initialization entry point.
    This entry point is called directly by the I/O system.

Arguments:

    DriverObject - pointer to the driver object

    RegistryPath - pointer to a unicode string representing the path
        to driver-specific key in the registry

Return Value:

   STATUS_SUCCESS if successful
   STATUS_UNSUCCESSFUL  otherwise

--*/
{
    NTSTATUS Status = STATUS_SUCCESS;
    UNICODE_STRING DeviceName;
    UNICODE_STRING LinkName;
    PDEVICE_OBJECT EventDrvDeviceObject;
    WCHAR DeviceNameString[128];
    ULONG LengthToCopy = 128 * sizeof(WCHAR);
    UNREFERENCED_PARAMETER (RegistryPath);

    KdPrint(("EventDrv: DriverEntry\n"));

    //
    // Create Dispatch Entry Points.  
    //
    DriverObject->DriverUnload = EventDrvDriverUnload;
    DriverObject->MajorFunction[ IRP_MJ_CREATE ] = EventDrvDispatchOpenClose;
    DriverObject->MajorFunction[ IRP_MJ_CLOSE ] = EventDrvDispatchOpenClose;
    DriverObject->MajorFunction[ IRP_MJ_DEVICE_CONTROL ] = EventDrvDispatchDeviceControl;

    RtlInitUnicodeString( &DeviceName, EventDrv_NT_DEVICE_NAME );

    //
    // Create the Device object
    //
    Status = IoCreateDevice(
                           DriverObject,
                           0,
                           &DeviceName,
                           FILE_DEVICE_UNKNOWN,
                           0,
                           FALSE,
                           &EventDrvDeviceObject);

    if (!NT_SUCCESS(Status)) {
        return Status;
    }

    RtlInitUnicodeString( &LinkName, EventDrv_WIN32_DEVICE_NAME );
    Status = IoCreateSymbolicLink( &LinkName, &DeviceName );

    if ( !NT_SUCCESS( Status )) {
        IoDeleteDevice( EventDrvDeviceObject );
        return Status;
    }

 //
 // Choose a buffering mechanism
 //
 EventDrvDeviceObject->Flags |= DO_BUFFERED_IO;

 //
 // Register with ETW
 //
 EventRegisterSample_Driver();

 //
 // Log an Event with :  DeviceNameLength
 //                      DeviceName
 //                      Status
 //

 // Copy the device name into the WCHAR local buffer in order
 // to place a NULL character at the end, since this field is
 // defined in the manifest as a NULL-terminated string

 if (DeviceName.Length <= 128 * sizeof(WCHAR)) {

     LengthToCopy = DeviceName.Length;

 }

 RtlCopyMemory(DeviceNameString,
               DeviceName.Buffer,
               LengthToCopy);

 DeviceNameString[LengthToCopy/sizeof(WCHAR)] = L'\0';

 EventWriteStartEvent(NULL, DeviceName.Length, DeviceNameString, Status);

 return STATUS_SUCCESS;
}

Dodaj wszystkie makra EventWrite<zdarzeń> do Twojego kodu źródłowego dla zgłaszanych zdarzeń. Możesz zbadać przykład Eventdrv , aby zobaczyć, jak dwa pozostałe makra są wywoływane dla zdarzeń w kodzie źródłowym sterownika.

  1. Wyrejestruj sterownik jako dostawcę zdarzeń przy użyciu makra EventUnregister<dostawcy> z wygenerowanego pliku nagłówkowego.

    Umieść to wywołanie funkcji w procedurze zwalniania sterownika. Nie należy wykonywać wywołań śledzenia po wywołaniu makra EventUnregister<dostawcy>. Niezarejestrowanie dostawcy zdarzeń może spowodować błędy podczas wyładowywania procesu, ponieważ jakiekolwiek funkcje wywołania zwrotnego skojarzone z procesem nie są już prawidłowe.

        // DriverUnload function
    // ...
    //

    //  Unregister the driver as an ETW provider
    //
    EventUnregisterSample_Driver();

5. Skompiluj sterownik

Jeśli do projektu dodano manifest instrumentu i skonfigurowano właściwości kompilatora komunikatów (MC.exe), możesz skompilować projekt sterownika lub rozwiązanie przy użyciu programów Visual Studio i MSBuild.

  1. Otwórz rozwiązanie sterownika w programie Visual Studio.

  2. Skompiluj przykład z menu Kompilacja, wybierając pozycję Kompiluj rozwiązanie. Aby uzyskać więcej informacji na temat tworzenia rozwiązań, zobacz Tworzenie sterownika.

6. Instalowanie manifestu

Należy zainstalować manifest w systemie docelowym, aby użytkownicy zdarzeń (na przykład dziennik zdarzeń) mogli znaleźć lokalizację pliku binarnego zawierającego metadane zdarzenia. Jeśli zadanie kompilatora komunikatów zostało dodane do projektu sterownika w kroku 3, manifest instrumentacji został skompilowany, a pliki zasobów zostały wygenerowane podczas kompilowania sterownika. Aby zainstalować manifest, użyj narzędzia wiersza polecenia zdarzeń systemu Windows (Wevtutil.exe). Składnia instalowania manifestu jest następująca:

wevtutil.exe imdrivermanifest

Aby na przykład zainstalować manifest dla przykładowego sterownika Evntdrv.sys, otwórz okna wiersza polecenia z podwyższonym poziomem uprawnień (Uruchom jako administrator) przejdź do katalogu, w którym znajduje się plik evntdrv.xml i wprowadź następujące polecenie:

Wevtutil.exe im evntdrv.xml

Po zakończeniu sesji śledzenia odinstaluj manifest przy użyciu następującej składni.

wevtutil.exe umdrivermanifest

Aby na przykład odinstalować manifest dla przykładu Eventdrv:

Wevtutil.exe um evntdrv.xml

7. Przetestuj sterownik, aby zweryfikować obsługę funkcji ETW

Zainstaluj sterownik. Przetestuj sterownik, aby wygenerować aktywność śledzenia. Wyświetl wyniki w Podglądzie zdarzeń. Można również uruchomić tracelog, a następnie uruchomić Tracerpt, narzędzie do przetwarzania dzienników śledzenia zdarzeń, aby kontrolować, zbierać i wyświetlać dzienniki śledzenia zdarzeń.

  • Last updated on