Uso di Driver Verifier per identificare i problemi con i driver di Windows per gli utenti avanzati

Lo strumento Driver Verifier è incluso in ogni versione di Windows a partire da Windows 2000. Viene usato per rilevare e risolvere molti problemi di driver noti per causare danneggiamento del sistema, errori o altri comportamenti imprevedibili. Questo articolo descrive come usare Driver Verifier per isolare e risolvere i problemi relativi a un driver nel sistema.

Si applica a: Windows Server 2016, Windows Server 2019, Windows Server 2022, Windows Server 2025
Numero KB originale: 244617

Funzionalità del driver Verifier

Per usare Driver Verifier, eseguire Verifier.exe e quindi riavviare il computer. Non è necessario apportare altre modifiche per iniziare ad analizzare i driver nel sistema. L'account utente richiede privilegi di amministratore per eseguire Verifier.exe.

Driver Verifier può controllare molti aspetti diversi del comportamento di un driver. Queste funzionalità sono raggruppate in opzioni o impostazioni abilitate dall'uso di flag. I termini opzioni, impostazioni e flag sono in genere intercambiabili nella documentazione di Driver Verifier. Rappresentano concetti simili.

Per informazioni dettagliate su ogni flag, vedere Opzioni del driver Verifier e classi di regole.

Opzioni standard

Le opzioni seguenti rappresentano insieme le regole che tutti i driver nel sistema non devono violare. Queste opzioni vengono abilitate quando si sceglie di abilitare le impostazioni standard nell'interfaccia utente grafica del driver verifier oppure si specifica l'opzione /standard quando si configura Driver Verifier usando la riga di comando.

Controlli automatici

Questi controlli vengono sempre eseguiti su un driver verificato, indipendentemente da quali opzioni sono state selezionate.

Esempi di controlli automatici:

• Controlli IRQL
  • IrQL generato (ovvero l'IRQL corrente è minore dell'IRQL di destinazione).
  • IrQL inferiore (ovvero l'IRQL corrente è più che irQL di destinazione).
• SpinLocks:
  • Rilascio doppio di un blocco spin.
  • Le acquisizioni/versioni di spin lock vengono eseguite nel runtime di integrazione appropriato.
• Allocazioni di memoria:
  • Le allocazioni/valori gratuiti del pool di paging vengono effettuate nel runtime di integrazione corretto (APC_LEVEL o inferiore).
  • Le allocazioni/valori gratuiti del pool non di paging vengono effettuate nel runtime di integrazione corretto (DISPATCH_LEVEL o inferiore).
  • Non vengono specificati valori casuali (non inizializzati) per queste API (Application Programming Interface).
  • Le allocazioni liberate non puntano agli oggetti timer attivi.
• Controllo di scaricamento del driver:
  • Verifica che il driver non disponga di operazioni in sospeso durante lo scaricamento, ad esempio controller di dominio in sospeso o thread di lavoro.
• Altri comportamenti del driver:
  • Cambio improprio di stack di thread.
  • Tentativo di chiamare KeWaitXxx in IRQL >= DISPATCH_LEVEL.
  • Dereferenziare un oggetto che dispone già di un conteggio dei riferimenti pari a 0.

Pool speciale

Quando questa opzione è attiva, Driver Verifier alloca la maggior parte delle richieste di memoria del driver da un pool speciale. Questo pool speciale viene monitorato per il sovraccarico della memoria, le sottorune di memoria e la memoria a cui si accede dopo che è stato liberato.

Forzare il controllo IRQL

Quando questa opzione è attiva, Driver Verifier applica un'estrema pressione di memoria al driver invalidando il codice pageable. Se il driver tenta di accedere alla memoria impaginata in irQL non corretta o mentre tiene premuto un blocco di selezione, Driver Verifier rileva questo comportamento.

Monitoraggio pool

Quando questa opzione è attiva, Driver Verifier verifica se il driver ha liberato tutte le allocazioni di memoria quando viene scaricato. Rivela perdite di memoria.

Verifica di I/O

Quando questa opzione è attiva, Driver Verifier alloca i runtime di integrazione del driver da un pool speciale e monitora la gestione di I/O del driver. Rileva l'uso illegale o incoerente delle routine di I/O.

Quando l'opzione Verifica I/O è abilitata:

• Tutti i runtime di integrazione allocati tramite IoAllocateIrp vengono allocati da un pool speciale, se disponibile.
• I controlli vengono eseguiti in IoCallDriver, IoCompleteRequest e IoFreeIrp per intercettare i messaggi di errore del driver.
• Tutti i bug degli errori di I/O Verifier verificano con il codice DRIVER_VERIFIER_IOMANAGER_VIOLATION (0xC9).

Nota

In Windows 7 e versioni successive del sistema operativo Windows, tutte le funzionalità della verifica di I/O avanzata sono incluse come parte della verifica di I/O e non è più disponibile né è più necessario selezionare l'opzione Verifica I/O avanzata in Gestione verifica driver o dalla riga di comando.

Rilevamento di deadlock

Quando questa opzione è attiva, Driver Verifier monitora l'uso dei blocchi di rotazione, dei mutex e dei mutex veloci del driver. Rileva se il codice del driver può causare un deadlock a un certo punto.

Verifica di I/O avanzata

Quando questa opzione è attiva, Driver Verifier monitora le chiamate di diverse routine di I/O Manager ed esegue test di stress di PnP IRP, power IRP e WMI IRP.

Nota

In Windows 7 e versioni successive, tutte le funzionalità della verifica di I/O avanzata sono incluse come parte della verifica di I/O. Questa opzione non è più disponibile o obbligatoria in Gestione driver verifier o da una riga di comando.

Verifica DMA

Quando questa opzione è attiva, Driver Verifier monitora l'uso delle routine DMA del driver. Rileva l'uso improprio di buffer, adattatori e registri mappa DMA.

Controlli di sicurezza

Quando questa opzione è attiva, Driver Verifier cerca errori comuni che possono causare vulnerabilità di sicurezza, ad esempio un riferimento agli indirizzi in modalità utente da routine in modalità kernel.

Controlli vari

Quando questa opzione è attiva, Driver Verifier cerca cause comuni di arresti anomali del driver, ad esempio la gestione errata della memoria liberata.

Controllo della conformità DDI

Quando questa opzione è attiva, Driver Verifier applica un set di regole DDI (Device Driver Interface) che controllano l'interazione corretta tra un driver e l'interfaccia kernel del sistema operativo.

L'opzione di controllo della conformità DDI viene implementata usando una libreria in modalità kernel, denominata VerifierExt.sys. Se viene rilevata una violazione di una delle regole di controllo della conformità DDI, VerifierExt.sys sarà il modulo che ha chiamato il controllo dei bug di sistema.

Opzioni aggiuntive

Queste opzioni sono progettate per test di scenari specifici o sono opzioni che iniettano errori o ritardi in determinate routine DDI per simulare condizioni di stress estreme.

Requisiti di Driver Verifier

L'unico requisito è che è necessario installare Windows Server 2012. È possibile abilitare Driver Verifier in entrambe le versioni retail e controllate di Windows. Se l'antivirus Norton è installato, non abilitare il rilevamento dei deadlock del driver.

Abilitare Driver Verifier

È possibile abilitare Driver Verifier usando Verifier.exe. Verifier.exe è incluso in ogni copia di Windows. Viene installato automaticamente nella cartella System32. Verifier.exe dispone sia di interfacce della riga di comando che dell'interfaccia utente grafica (GUI), in modo da poter specificare i driver e i livelli appropriati di verifica. È anche possibile visualizzare le statistiche del driver Verifier in tempo reale. Per altre informazioni, vedere la sezione Driver Verifier Manager (Verifier.exe).

Violazioni del driver di debug

Se Driver Verifier rileva una violazione, il comportamento standard consiste nel controllare il sistema in modo da fornire la maggior parte delle informazioni possibili sul debug del problema. Un sistema connesso a un debugger si arresterà dopo che si è verificato un controllo di bug.

Tutte le violazioni del driver Verifier comportano controlli di bug, quelli più comuni (anche se non necessariamente tutti) sono:

• 0xC1: SPECIAL_POOL_DETECTED_MEMORY_CORRUPTION
• 0xC4: DRIVER_VERIFIER_DETECTED_VIOLATION
• 0xC6: DRIVER_CAUGHT_MODIFYING_FREED_POOL
• 0xC9: DRIVER_VERIFIER_IOMANAGER_VIOLATION
• 0xD6: DRIVER_PAGE_FAULT_BEYOND_END_OF_ALLOCATION
• 0xE6: DRIVER_VERIFIER_DMA_VIOLATION

!analyze -v è il comando migliore da usare quando si avvia una nuova sessione di debug. Questo comando restituirà informazioni utili e tenterà di individuare il driver di errore.

Estensioni del debugger specifiche di Driver Verifier:

• !verifier eseguirà il dump delle statistiche di Verifica driver acquisite. !verifier -? mostrerà tutte le opzioni disponibili.
• !deadlock esegue il dump delle informazioni relative a blocchi o oggetti rilevati dal rilevamento deadlock. !deadlock -? mostrerà tutte le opzioni disponibili.
• !iovirp [address] eseguirà il dump delle informazioni correlate a un IRP rilevato da I/O Verifier.
• !ruleinfo [RuleID] eseguirà il dump delle informazioni correlate alla regola di controllo della conformità DDI violata (RuleID è sempre il primo argomento del controllo dei bug, tutti gli ID delle regole di controllo della conformità DDI sono nel formato 0x200nn).

Driver Verifier e driver grafici

I driver grafici in modalità kernel di Windows, ad esempio dll del driver di visualizzazione e stampante, non possono chiamare direttamente il punto di ingresso del pool. Le allocazioni del pool vengono eseguite indirettamente usando callback DDI (Graphics Device Driver Interface) per Win32k.sys. Ad esempio, EngAllocMem è il callback che un driver grafico chiama per allocare in modo esplicito la memoria del pool. Altri callback specializzati, ad esempio EngCreatePalette ed EngCreateBitmap, restituiscono anche la memoria del pool.

Per fornire lo stesso test automatizzato per i driver di grafica, il supporto per alcune funzioni di Driver Verifier viene incorporato in Win32k.sys. Poiché i driver grafici sono più limitati rispetto ad altri driver in modalità kernel, richiedono solo un subset della funzionalità Driver Verifier. In particolare, il controllo IRQL e la verifica di I/O non sono necessari. Le altre funzionalità, vale a dire l'uso di pool speciali, errori casuali delle allocazioni del pool e rilevamento del pool, sono supportate per variare i gradi nei diversi callback DDI grafici.

Gli errori casuali sono supportati per le funzioni di callback DDI grafiche seguenti:

• EngAllocMem
• EngAllocUserMem
• EngCreateBitmap
• EngCreateDeviceSurface
• EngCreateDeviceBitmap
• EngCreatePalette
• EngCreateClip
• EngCreatePath
• EngCreateWnd
• EngCreateDriverObj
• BRUSHOBJ_pvAllocRbrush
• CLIPOBJ_ppoGetPath

Inoltre, l'uso di pool e rilevamento pool speciali è supportato per EngAllocMem.

L'abilitazione di Driver Verifier per i driver grafici è identica agli altri driver. Per altre informazioni, vedere la sezione Enable Driver Verifier .For more information, see the Enable Driver Verifier section. I flag non supportati, ad esempio il controllo IRQL, vengono ignorati. Inoltre, è possibile usare il !gdikdx.verifier comando kernel-debugger per esaminare lo stato corrente del driver verifier e le tracce del pool per i driver grafici.

Nota

È consigliabile usare solo l'impostazione di errore di allocazione casuale per i test di affidabilità. L'uso di questa impostazione può causare il rendering dei messaggi di errore, pertanto non è consigliabile usare questa impostazione con i test di verifica per verificare la correttezza dell'implementazione del driver grafico, ad esempio confrontando l'output del driver grafico con un'immagine di riferimento.

Gestione verifica driver (Verifier.exe)

Lo strumento Gestione verifica driver (Verifier.exe) è il modo preferito per creare e modificare le impostazioni di Driver Verifier e per raccogliere statistiche da Driver Verifier. Verifier.exe si trova nella cartella %WinDir%\System32 per ogni installazione di Windows.

Driver Verifier Manager è l'interfaccia utente grafica inclusa in Windows per configurare Driver Verifier. Avviare Gestione verifica driver usando verifier.exe senza altre opzioni della riga di comando. Ogni volta che vengono incluse opzioni, viene usata la versione basata sulla riga di comando dell'utilità.

Per informazioni sulla configurazione di Driver Verifier, eseguire verifier.exe /? da una finestra CMD amministratore.

Stato del driver

La pagina delle proprietà Stato driver fornisce un'immagine dello stato corrente di Driver Verifier. È possibile visualizzare i driver rilevati dal verificatore. Lo stato può essere uno dei valori seguenti:

• Caricato: il driver è attualmente caricato e verificato.
• Scaricato: il driver non è attualmente caricato, ma è stato caricato almeno una volta dopo il riavvio del computer.
• Mai caricato: il driver non è mai stato caricato. Questo stato può indicare che il file di immagine del driver è danneggiato o che è stato specificato un nome di driver mancante nel sistema.

Selezionare l'intestazione dell'elenco per ordinare l'elenco in base ai nomi o allo stato dei driver. Nell'area superiore destra della finestra di dialogo è possibile visualizzare i tipi correnti della verifica attivati. Lo stato dei driver viene aggiornato automaticamente se non si passa alla modalità di aggiornamento manuale. È possibile modificare la frequenza di aggiornamento usando i pulsanti di opzione nell'area inferiore sinistra della finestra di dialogo. Per forzare un aggiornamento dello stato, selezionare Aggiorna ora.

Se si abilita il flag Pool speciale e il 95% delle allocazioni del pool è andato al pool speciale, in questa pagina viene visualizzato un messaggio di avviso. Ciò significa che è necessario selezionare un set più piccolo di driver da verificare o aggiungere più memoria fisica al computer per ottenere una migliore copertura della verifica delle allocazioni del pool.

Contatori globali

Questa pagina delle proprietà mostra il valore corrente di alcuni contatori gestiti da Driver Verifier. Un valore zero per un contatore può indicare che il flag Driver Verifier associato non è abilitato. Ad esempio, un valore pari a 0 per il contatore Other/Faults indica che il flag di simulazione delle risorse basso non è abilitato. È possibile monitorare l'attività del verificatore perché i valori dei contatori vengono aggiornati automaticamente per impostazione predefinita. È possibile modificare la frequenza di aggiornamento, passare all'aggiornamento manuale o forzare un aggiornamento usando il gruppo di controlli nell'area inferiore sinistra della finestra di dialogo.

Monitoraggio pool

Questa pagina delle proprietà mostra altre statistiche raccolte da Driver Verifier. Tutti i contatori visualizzati in questa pagina sono correlati al flag di rilevamento pool del verificatore. La maggior parte di essi sono contatori per driver, ad esempio allocazioni correnti, byte allocati correnti e così via. È necessario selezionare un nome del driver nella casella di combinazione superiore per visualizzare i contatori per quel driver specifico.

Impostazioni

È possibile usare questa pagina per creare e modificare le impostazioni di Driver Verifier. Le impostazioni vengono salvate nel Registro di sistema ed è necessario riavviare il computer per rendere effettive le impostazioni. È possibile usare l'elenco per visualizzare i driver attualmente installati. Ogni driver può trovarsi in uno degli stati seguenti:

• Verifica abilitata: il driver è attualmente verificato.
• Verifica disabilitata: il driver non è attualmente verificato.
• Verifica abilitata (riavvio necessario): il driver viene verificato solo dopo il riavvio successivo.
• Verifica disabilitata (riavvio necessario): il driver è attualmente verificato ma non viene verificato dopo il riavvio successivo.

È possibile selezionare uno o più driver dall'elenco e cambiare lo stato usando i due pulsanti sotto l'elenco. È anche possibile fare clic con il pulsante destro del mouse sul nome di un driver per visualizzare il menu di scelta rapida, che consente di attivare o disattivare lo stato.

Nella parte inferiore della finestra di dialogo è possibile specificare più driver (separati da spazi) da verificare dopo il riavvio successivo. Questo controllo di modifica viene in genere usato quando si desidera installare un nuovo driver non già caricato.

Se il gruppo di pulsanti di opzione nella parte superiore dell'elenco è impostato su Verifica tutti i driver, l'elenco e i pulsanti Verifica e Non verificare e il controllo di modifica non sono disponibili. Ciò significa che dopo il riavvio successivo vengono verificati tutti i driver nel sistema.

È possibile impostare il tipo di verifica usando le caselle di controllo nell'area superiore destra della finestra di dialogo. È possibile abilitare la verifica di I/O al livello 1 o al livello 2. La verifica di livello 2 è più forte del livello 1.

Salvare le modifiche apportate alle impostazioni selezionando Applica. In questa pagina sono presenti altri due pulsanti:

• Impostazioni preferite: seleziona alcune impostazioni di uso comune (con tutti i driver verificati).
• Reimposta tutto: cancella tutte le impostazioni di Driver Verifier in modo che non vengano verificati driver.

Dopo aver selezionato Applica, è necessario riavviare il computer per rendere effettive le modifiche.

Impostazioni volatili

È possibile usare questa pagina delle proprietà per modificare immediatamente i flag di Driver Verifier. È possibile attivare o disattivare lo stato di alcuni flag di driver verifier. E non è possibile modificare l'elenco dei driver verificati. Dopo aver modificato lo stato di alcune caselle di controllo, selezionare Applica per rendere effettive le modifiche. Le modifiche avranno effetto immediatamente. E durano fino a quando non si apportano modifiche aggiuntive o fino al riavvio del computer.

Interfaccia della riga di comando

È anche possibile eseguire Verifier.exe da una riga di comando (per altre informazioni, digitare verifier.exe /? al prompt dei comandi). È possibile usare più opzioni nella riga di comando, ad esempio:

Verifier.exe /flags 0x209BB /driver MyDriver1.sys MyFilterDriver1.sys

L'elenco seguente mostra i flag della riga di comando più comunemente usati:

Opzioni di configurazione (flag)

• verifier.exe valore /flags

  Value è un numero esadecimale (è necessario un prefisso 0x ) che rappresenta il valore collettivo dei flag da abilitare. Il valore per ogni flag viene visualizzato nell'output verifier /? .

  Flag standard:

  0x00000000: controlli automatici
  0x00000001: pool speciale
  0x00000002: Forza controllo IRQL
  0x00000008: Rilevamento pool
  0x00000010: verifica di I/O
  0x00000020: rilevamento deadlock
  0x00000080: controllo DMA
  0x00000100: Controlli di sicurezza
  0x00000800: controlli vari
  0x00020000: controllo della conformità DDI

  Altri flag:

  0x00000004: simulazione di risorse basse casuali
  0x00000040: verifica di I/O avanzata (solo Vista)
  0x00000200: Forzare le richieste di I/O in sospeso
  0x00000400: Registrazione IRP
  0x00002000: controllo MDL invariante per lo stack
  0x00004000: Controllo MDL invariante per driver0x00008000: ritardo della fuzzing del framework di alimentazione

  Ad esempio, per abilitare solo i controlli Speciali Pool, Verifica I/O e Varie:

  verifier.exe /flags 0x811
  

  Per abilitare tutte le impostazioni standard (ad esempio funziona):

  verifier.exe /standard
  

  verifier.exe /flags 0x209BB
  

• Configurare i driver per la verifica

  verifier.exe /driver driver1.sys [driver2.sys driver3.sys ...]
  

  Questo comando specifica il driver o i driver specifici da verificare. Fornire driver aggiuntivi in un elenco separato da spazi.

  verifier.exe /all
  

  Questo comando verifica tutti i driver nel sistema.

• Configurare usando la modalità volatile

  verifier.exe /volatile /flags *value /adddriver MyDriver1.sys*
  

  Questo comando modifica immediatamente i flag di verifica e aggiunge MyDriver1.sys per la verifica.

• Eseguire query sulle statistiche di verifica correnti

  verifier /query
  

  Eseguire il dump dello stato corrente del driver Verifier e dei contatori nell'output standard.

• Eseguire query nelle impostazioni correnti del verificatore

  verifier /querysettings
  

  Eseguire il dump delle impostazioni correnti del driver Verifier nell'output standard.

• Cancellare le impostazioni del verificatore

  verifier.exe /reset
  

  Questo comando cancella tutte le impostazioni correnti di Driver Verifier.

Informazioni aggiuntive per gli sviluppatori di driver

Le sezioni seguenti descrivono altri dettagli sulle impostazioni del driver di verifica che potrebbero essere interessanti per gli sviluppatori di driver. Queste impostazioni non sono in genere richieste dai professionisti IT.

Importante

In questa sezione, metodo o attività viene illustrata la procedura per modificare il Registro di sistema. Poiché l'errata modifica del Registro di sistema può causare seri problemi, Pertanto, assicurarsi di osservare attentamente la procedura seguente. Per una maggiore protezione, eseguire il backup del Registro di sistema prima di modificarlo. Successivamente, è possibile ripristinare il Registro di sistema se si verifica un problema. Per ulteriori informazioni su come eseguire backup e ripristino del Registro di sistema, vedere Backup e ripristino del Registro di sistema in Windows.

Per abilitare Driver Verifier modificando il Registro di sistema, seguire questa procedura:

1. Avviare l'editor del Registro di sistema (Regedt32).

2. Individuare la seguente chiave del Registro di sistema:

   HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\Memory Management\VerifyDrivers

3. Modificare la REG_SZ chiave.

Impostare la REG_SZ chiave sui nomi senza distinzione tra maiuscole e minuscole dei driver da testare. È possibile specificare più driver, ma usare un solo driver. In questo modo, è possibile assicurarsi che le risorse di sistema disponibili non vengano esaurite prematuramente. L'esaurimento prematuro delle risorse non causa problemi di affidabilità del sistema, ma può causare il bypass di alcuni driver.

L'elenco seguente mostra esempi di valori per la REG_SZ chiave:

• Ntfs.sys
• Win32k.sys ftdisk.sys
• *.sys

È possibile specificare il livello di verifica del driver nella chiave del Registro di sistema seguente:

HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\Memory Management\VerifyDriverLevel

Il valore della chiave è un valore DWORD che rappresenta la raccolta di tutti i flag abilitati.