Verifica dell'applicazione - Codici di arresto - Nozioni di base

I codici di arresto seguenti sono contenuti nel set di nozioni di base dei test.

Dettagli arresto eccezioni

Tentare di eseguire il codice nella memoria non eseguibile (prima probabilità).

probabile causa

Questo arresto viene generato se l'applicazione sta tentando di eseguire codice da un indirizzo non eseguibile o gratuito. Per eseguire il debug dell'arresto:

u <parameter2> : annullare ilassemble del codice colpevole
Parametro .exr3><: visualizzare le informazioni sull'eccezione
Parametro .cxr4 <> : visualizzare le informazioni sul contesto dell'eccezione
kb : consente di visualizzare l'analisi dello stack per il momento in cui è stata generata l'eccezione.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo a cui si accede.
Parametro 2 - Codice che esegue l'accesso non valido.
Parametro 3 - Record eccezione. Usare .exr per visualizzarlo.
Parametro 4 - Record di contesto. Usare .cxr per visualizzarlo.

Informazioni aggiuntive

Livello di test: Eccezioni
ID di arresto: FIRST_CHANCE_ACCESS_VIOLATION_CODE
Codice di arresto: 650
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Gestisce i dettagli di arresto

Eccezione di handle non valida per l'analisi dello stack corrente.

probabile causa

Questo arresto viene generato se la funzione nella parte superiore dello stack ha passato un handle non valido alle routine di sistema. In genere un semplice comando "kb" rivelerà il valore dell'handle passato (deve essere uno dei parametri, in genere il primo). Se il valore è Null, questo è chiaramente errato. Se il valore ha un aspetto corretto, è necessario usare l'estensione del debugger '!htrace' per ottenere una cronologia delle operazioni relative a questo valore di handle. Nella maggior parte dei casi, il valore dell'handle viene usato dopo la chiusura.

Informazioni visualizzate da Application Verifier

Parametro 1 : Non usato.
Parametro 2 : Non usato.
Parametro 3 : Non usato.
Parametro 4 : Non usato.

Informazioni aggiuntive

Livello di test: Manici
ID di arresto: INVALID_HANDLE
Codice di arresto: 300
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Indice TLS non valido usato per l'analisi dello stack corrente.

probabile causa

Questo arresto viene generato se la funzione nella parte superiore dello stack ha passato un indice TLS non valido alle routine di sistema TLS. In genere, un semplice comando "kb" rivelerà cosa c'è di sbagliato. Il bug tipico è quello di presupporre un determinato valore per un indice TLS anziché chiamare "TlsAlloc". Ciò può verificarsi presupponendo che si ottenga sempre il valore N e pertanto non è necessario chiamare 'TlsAlloc'. Più frequentemente è dovuto a una variabile non inizializzata.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indice TLS non valido.
Parametro 2 - Prevista parte inferiore dell'indice.
Parametro 3 : Non usato.
Parametro 4 : Non usato.

Informazioni aggiuntive

Livello di test: Manici
ID di arresto: INVALID_TLS_VALUE
Codice di arresto: 301
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Parametri non validi per la chiamata WaitForMultipleObjects.

probabile causa

Questo arresto viene generato se la funzione nella parte superiore dello stack denominata 'WaitForMultipleObjects' con NULL come indirizzo della matrice di handle di attesa o con zero come numero di handle. Un semplice comando "kb" rivelerà la funzione che chiama questa API in modo non corretto.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo dell'oggetto gestisce il vettore.
Parametro 2 - Numero di handle.
Parametro 3 : Non usato.
Parametro 4 : Non usato.

Informazioni aggiuntive

Livello di test: Manici
ID di arresto: INCORRECT_WAIT_CALL
Codice di arresto: 302
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Handle NULL passato come parametro. È necessario utilizzare un handle valido.

probabile causa

Questo arresto viene generato se la funzione nella parte superiore dello stack ha passato un handle NULL alle routine di sistema. In genere un semplice comando "kb" rivelerà il valore dell'handle passato (deve essere uno dei parametri, in genere il primo).

Informazioni visualizzate da Application Verifier

Parametro 1 - Uso dell'handle NULL
Parametro 2 - Non usato
Parametro 3 - Non usato
Parametro 4 - Non usato

Informazioni aggiuntive

Livello di test: Manici
ID di arresto: NULL_HANDLE
Codice di arresto: 303
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

In attesa di un handle di thread in DllMain.

probabile causa

Questo arresto viene generato se il thread corrente è attualmente in esecuzione codice all'interno della funzione 'DllMain' di una delle DLL caricate nel processo corrente e chiama 'WaitForSingleObject' o 'WaitForMultipleObjects' per attendere un handle di thread nello stesso processo. È molto probabile che si verifichi un deadlock perché l'handle del thread non verrà segnalato a meno che il secondo thread non venga chiuso. Quando il secondo thread chiama "ExitThread" tenta di acquisire il blocco del caricatore DLL e quindi chiamare "DllMain" (DLL_THREAD_DETACH) per tutte le DLL nel processo corrente. Poiché il blocco del caricatore è di proprietà del primo thread (quello in attesa sull'handle del thread), i due thread verranno deadlock.

Informazioni visualizzate da Application Verifier

Parametro 1 - Handle thread.
Parametro 2 : Non usato.
Parametro 3 : Non usato.
Parametro 4 : Non usato.

Informazioni aggiuntive

Livello di test: Manici
ID di arresto: WAIT_IN_DLLMAIN
Codice di arresto: 304
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Tipo di oggetto non corretto per handle.

probabile causa

Questo arresto viene generato se il thread corrente chiama un'API con un handle a un oggetto con un tipo di oggetto non corretto. Ad esempio, la chiamata a 'SetEvent' con un handle semaforo come parametro genera questa interruzione. Per eseguire il debug dell'arresto:

kb : per visualizzare l'analisi dello stack corrente. Il colpevole è probabilmente la DLL che sta chiamando in verifier.dll
du <parameter2> : per visualizzare il tipo effettivo dell'handle. Il valore dell'handle è parameter1. Nell'esempio precedente viene visualizzato "Semaforo".
du <parameter3> : per visualizzare il tipo di oggetto previsto dall'API. Nell'esempio precedente questo nome è "Event".
!htrace <parameter1> - potrebbe essere utile perché visualizza l'analisi dello stack per le operazioni di apertura/chiusura recenti su questo handle.

Informazioni visualizzate da Application Verifier

Parametro 1 - Handle value .
Parametro 2 - Nome del tipo di oggetto. Usare du per visualizzarlo
Parametro 3 - Nome del tipo di oggetto previsto. Usare du per visualizzarlo
Parametro 4 : Non usato.

Informazioni aggiuntive

Livello di test: Manici
ID di arresto: INCORRECT_OBJECT_TYPE
Codice di arresto: 305
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Dettagli arresto heap

Errore sconosciuto.

probabile causa

Questo messaggio può verificarsi se l'errore rilevato non può essere classificato in altro modo. Non usato in questo momento.

Informazioni visualizzate da Application Verifier

Parametro 1 - Non usato
Parametro 2 - Non usato
Parametro 3 - Non usato
Parametro 4 - Non usato

Informazioni aggiuntive

Livello di test: Cumuli
ID di arresto: UNKNOWN_ERROR
Codice di arresto: 0x1
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Eccezione di violazione di accesso.

probabile causa

Si tratta dell'arresto più comune dell'applicazione. In genere è causato da un errore di sovraccarico del buffer. Il verificatore heap inserisce una pagina non accessibile alla fine di un'allocazione dell'heap e un sovraccarico del buffer causerà un'eccezione toccando questa pagina. Per eseguire il debug di questo arresto, identificare l'indirizzo di accesso che ha causato l'eccezione e quindi usare il comando debugger seguente:

!heap -p -a ACCESS_ADDRESS : questo comando fornisce informazioni dettagliate sulla natura dell'errore e sul blocco heap di cui è stato eseguito l'overrun. Fornisce anche l'analisi dello stack per l'allocazione dei blocchi. Esistono altre cause per questo arresto, ad esempio l'accesso a un blocco heap dopo essere stato liberato. Lo stesso comando del debugger è utile per questo caso.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo non valido che causa l'eccezione
Parametro 2 - Indirizzo di codice che esegue l'accesso non valido
Parametro 3 - Record eccezione
Parametro 4 - Record di contesto

Informazioni aggiuntive

Livello di test: Cumuli
ID di arresto: ACCESS_VIOLATION
Codice di arresto: 0x2
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Accesso multithreading in un heap creato con HEAP_NO_SERIALIZE flag.

probabile causa

Un heap creato con HEAP_NO_SERIALIZE flag non dovrebbe essere accessibile contemporaneamente da due thread. Se viene rilevata una situazione di questo tipo, verrà visualizzato questo messaggio. Il modo tipico in cui questa situazione si intrufola in un programma consiste nel collegare una versione a thread singolo del runtime C. Visual C++, ad esempio, può collegare in modo statico tale libreria quando vengono usati flag appropriati. Gli sviluppatori dimenticano quindi questo dettaglio e usano più thread. Il bug è molto difficile eseguire il debug in vita reale perché apparirà come misterioso danneggiamento dei dati.

Informazioni visualizzate da Application Verifier

Parametro 1 - Heap in cui si verifica l'operazione.
Parametro 2 - ID thread per il proprietario corrente della sezione critica dell'heap.
Parametro 3 - ID thread del thread corrente che tenta di immettere l'heap.
Parametro 4 - Non usato

Informazioni aggiuntive

Livello di test: Cumuli
ID di arresto: UNSYNCHRONIZED_ACCESS
Codice di arresto: 0x3
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Richiesta di dimensioni estreme.

probabile causa

Questo messaggio verrà generato se, in un'operazione "HeapAlloc" o "HeapReAlloc", la dimensione del blocco è superiore a qualsiasi valore ragionevole. In genere questo valore è 0x80000000 su piattaforme a 32 bit e notevolmente più grande su piattaforme a 64 bit.

Informazioni visualizzate da Application Verifier

Parametro 1 - Heap in cui si verifica l'operazione.
Parametro 2 - Dimensioni richieste
Parametro 3 - Non usato
Parametro 4 - Non usato

Informazioni aggiuntive

Livello di test: Cumuli
ID di arresto: EXTREME_SIZE_REQUEST
Codice di arresto: 0x4
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Handle heap con firma non corretta.

probabile causa

Le strutture dell'heap sono contrassegnate con un valore magic. Se l'handle heap usato nella chiamata a un'interfaccia heap non dispone di questo modello, verrà generato questo arresto. Questo bug può verificarsi se in qualche modo la struttura dell'heap interna è danneggiata (danneggiamento casuale) o semplicemente un valore fittizio viene usato come handle dell'heap. Per ottenere un elenco di valori di handle dell'heap validi, usare il comando debugger seguente:

!heap -p

Si noti che se si cambia semplicemente un handle heap valido con un altro handle valido in un'operazione heap non si otterrà questa interruzione (l'handle è valido dopo tutto). Tuttavia, il verificatore heap rileva questa situazione e lo segnala con SWITCHED_HEAP_HANDLE arresto.

Informazioni visualizzate da Application Verifier

Parametro 1 Handle - Heap usato nella chiamata a un'interfaccia heap
Parametro 2 - Non usato
Parametro 3 - Non usato
Parametro 4 - Non usato

Informazioni aggiuntive

Livello di test: Cumuli
ID di arresto: BAD_HEAP_HANDLE
Codice di arresto: 0x5
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Puntatore dell'heap danneggiato o uso dell'heap errato.

probabile causa

In genere questo accade se un blocco viene allocato in un heap e liberato in un altro. Usare il comando debugger '!heap -p' per ottenere un elenco di tutti i valori di handle dell'heap validi. L'esempio più comune è un'allocazione msvcrt che usa 'malloc' abbinata a una deallocazione kernel32 con 'HeapFree'.

Informazioni visualizzate da Application Verifier

Parametro 1 Handle - Heap usato nella chiamata.
Parametro 2 Blocco - Heap coinvolto nell'operazione.
Parametro 3 - Dimensioni del blocco heap.
Parametro 4 - Heap in cui il blocco è stato originariamente allocato.

Informazioni aggiuntive

Livello di test: Cumuli
ID di arresto: SWITCHED_HEAP_HANDLE
Codice di arresto: 0x6
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Blocco heap già liberato.

probabile causa

Questa situazione si verifica se il blocco viene liberato due volte. I blocchi liberati sono contrassegnati in modo speciale e vengono mantenuti intorno per un po 'in una coda libera ritardata. Se un programma buggy tenta di liberare nuovamente il blocco, verrà intercettato, presupponendo che il blocco non sia stato dequeued dalla coda libera ritardata e la relativa memoria riutilizzata per altre allocazioni. La profondità della coda di ritardo libero è nell'ordine di migliaia di blocchi, quindi ci sono buone probabilità che la maggior parte dei doppi liberi verrà intercettata.

Informazioni visualizzate da Application Verifier

Parametro 1 - Heap handle per l'heap proprietario del blocco.
Parametro 2 - Blocco heap che viene nuovamente liberato.
Parametro 3 - Dimensioni del blocco heap.
Parametro 4 - Non usato

Informazioni aggiuntive

Livello di test: Cumuli
ID di arresto: DOUBLE_FREE
Codice di arresto: 0x7
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Blocco heap danneggiato.

probabile causa

Si tratta di un errore generico generato se il danneggiamento nel blocco heap non può essere inserito in una categoria più specifica.

Informazioni visualizzate da Application Verifier

Parametro 1 Handle - Heap usato nella chiamata.
Parametro 2 Blocco - Heap coinvolto nell'operazione.
Parametro 3 - Dimensioni del blocco heap.
Parametro 4 - Riservato

Informazioni aggiuntive

Livello di test: Cumuli
ID di arresto: CORRUPTED_HEAP_BLOCK
Codice di arresto: 0x8
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Tentare di distruggere l'heap del processo.

probabile causa

Si tratta di un errore per tentare di eliminare definitivamente l'heap del processo predefinito (quello restituito dall'interfaccia 'GetProcessHeap()'.

Informazioni visualizzate da Application Verifier

Parametro 1 Handle - Heap usato con HeapDestroy.
Parametro 2 - Non usato
Parametro 3 - Non usato
Parametro 4 - Non usato

Informazioni aggiuntive

Livello di test: Cumuli
ID di arresto: DESTROY_PROCESS_HEAP
Codice di arresto: 0x9
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Eccezione imprevista generata nel codice heap.

probabile causa

Questo arresto viene generato se, durante l'esecuzione del codice di gestione dell'heap, viene generata una violazione di accesso in situazioni non corrispondenti. In alcune situazioni, ad esempio, quando si chiama "HeapValidate()" o "HeapSize()". Le informazioni sui record di eccezione (terzo parametro) possono essere usate per trovare il contesto esatto dell'eccezione. Usare i comandi del debugger seguenti per questa operazione:

dd parameter2 L2
.exr first_dword
.cxr second_dword

In genere questo arresto si verifica se si verifica un danneggiamento casuale nelle strutture heap interne.

Informazioni visualizzate da Application Verifier

Parametro 1 - Heap coinvolto nell'operazione.
Parametro 2 - Record eccezione.
Parametro 3 - Record di contesto.
Parametro 4 - Codice eccezione (C0000005 - violazione di accesso)

Informazioni aggiuntive

Livello di test: Cumuli
ID di arresto: UNEXPECTED_EXCEPTION
Codice di arresto: 0xA
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Eccezione generata durante la verifica dell'intestazione del blocco heap.

probabile causa

Questa situazione si verifica se in realtà non è possibile determinare alcun particolare tipo di danneggiamento per il blocco. Ad esempio, quando l'indirizzo del blocco heap passato a un'operazione libera heap punta a un'area di memoria non accessibile (puntatore danneggiato, puntatore non inizializzato e così via).

Informazioni visualizzate da Application Verifier

Parametro 1 - Heap handle per l'heap proprietario del blocco.
Parametro 2 - Blocco heap danneggiato.
Parametro 3 - Dimensioni del blocco o zero se non è possibile determinare le dimensioni.
Parametro 4 : Non usato.

Informazioni aggiuntive

Livello di test: Cumuli
ID di arresto: CORRUPTED_HEAP_BLOCK_EXCEPTION_RAISED_FOR_HEADER
Codice di arresto: 0xB
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Eccezione generata durante la verifica del blocco heap.

probabile causa

Questa situazione si verifica se in realtà non è possibile determinare alcun particolare tipo di danneggiamento per il blocco. Ad esempio, si otterrà questo valore se durante un'operazione senza heap si passa un indirizzo che punta a un'area di memoria non accessibile. Questo può verificarsi anche per situazioni doppie gratuite se non troviamo il blocco tra blocchi heap di pagine completi e lo probe come blocco heap di pagina leggero.

Informazioni visualizzate da Application Verifier

Parametro 1 Handle - Heap usato nella chiamata.
Parametro 2 Blocco - Heap coinvolto nell'operazione.
Parametro 3 - Dimensioni del blocco heap.
Parametro 4 - Riservato.

Informazioni aggiuntive

Livello di test: Cumuli
ID di arresto: CORRUPTED_HEAP_BLOCK_EXCEPTION_RAISED_FOR_PROBING
Codice di arresto: 0xC
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Blocco heap danneggiato dopo essere stato liberato.

probabile causa

Questa situazione si verifica se un blocco di memoria viene scritto in dopo essere stato liberato.

Informazioni visualizzate da Application Verifier

Parametro 1 - Heap handle per l'heap proprietario del blocco.
Parametro 2 - Blocco heap danneggiato.
Parametro 3 - Dimensioni del blocco o zero se non è possibile determinare le dimensioni.
Parametro 4 : Non usato.

Informazioni aggiuntive

Livello di test: Cumuli
ID di arresto: CORRUPTED_HEAP_BLOCK_HEADER
Codice di arresto: 0xD
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Modello di prefisso danneggiato per il blocco heap liberato.

probabile causa

I blocchi liberati sono talvolta contrassegnati come non accessibili e un programma che li tocca violerà (arresto del verificatore diverso). In altri casi ,ad esempio un heap di pagina chiaro, il blocco è contrassegnato con un motivo magico e verrà mantenuto per un po '. Alla fine in un FIFO i blocchi vengono davvero liberati. In questo momento viene controllato il modello di prefisso e, se è stato modificato, si otterrà questa interruzione. Lo stack al momento dell'interruzione non è rilevante. È necessario scoprire la natura del blocco e del codice esaminare il codice che potrebbe essere errato.

Informazioni visualizzate da Application Verifier

Parametro 1 - Heap handle per l'heap proprietario del blocco.
Parametro 2 - Blocco heap liberato.
Parametro 3 - Dimensioni del blocco heap.
Parametro 4 - Riservato.

Informazioni aggiuntive

Livello di test: Cumuli
ID di arresto: CORRUPTED_FREED_HEAP_BLOCK
Codice di arresto: 0xE
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Modello di suffisso danneggiato per il blocco heap.

probabile causa

In genere ciò si verifica per gli errori di overrun del buffer. A volte il verificatore dell'applicazione inserisce pagine non accessibili alla fine dell'allocazione e il sovraccarico del buffer causerà una violazione di accesso e talvolta il blocco heap è seguito da un modello magic. Se questo modello viene modificato quando il blocco viene liberato, si otterrà questa interruzione. Queste interruzioni possono essere piuttosto difficili da eseguire per il debug perché non si ha il momento effettivo in cui si è verificato il danneggiamento. È sufficiente accedere al momento gratuito (ad esempio, "stop happened here") e l'analisi dello stack di allocazione ('!heap -p -a HEAP_ADDRESS')

Informazioni visualizzate da Application Verifier

Parametro 1 Handle - Heap usato nella chiamata.
Parametro 2 Blocco - Heap coinvolto nell'operazione.
Parametro 3 - Dimensioni del blocco heap.
Parametro 4 - Riservato.

Informazioni aggiuntive

Livello di test: Cumuli
ID di arresto: CORRUPTED_HEAP_BLOCK_SUFFIX
Codice di arresto: 0xF
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Stamp di inizio danneggiato per il blocco heap.

probabile causa

Questo problema si verifica per le sottorune del buffer.

Informazioni visualizzate da Application Verifier

Parametro 1 Handle - Heap usato nella chiamata.
Parametro 2 Blocco - Heap coinvolto nell'operazione.
Parametro 3 - Dimensioni del blocco heap.
Parametro 4 - Valore stamp danneggiato.

Informazioni aggiuntive

Livello di test: Cumuli
ID di arresto: CORRUPTED_HEAP_BLOCK_START_STAMP
Codice di arresto: 0x10
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Stamp finale danneggiato per il blocco heap.

probabile causa

Questo problema si verifica per le sottorune del buffer.

Informazioni visualizzate da Application Verifier

Parametro 1 Handle - Heap usato nella chiamata.
Parametro 2 Blocco - Heap coinvolto nell'operazione.
Parametro 3 - Dimensioni del blocco heap.
Parametro 4 - Valore stamp danneggiato.

Informazioni aggiuntive

Livello di test: Cumuli
ID di arresto: CORRUPTED_HEAP_BLOCK_END_STAMP
Codice di arresto: 0x11
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Modello di prefisso danneggiato per il blocco heap.

probabile causa

Questo problema si verifica per le sottorune del buffer.

Informazioni visualizzate da Application Verifier

Parametro 1 Handle - Heap usato nella chiamata.
Parametro 2 Blocco - Heap coinvolto nell'operazione.
Parametro 3 - Dimensioni del blocco heap.
Parametro 4 - Riservato.

Informazioni aggiuntive

Livello di test: Cumuli
ID di arresto: CORRUPTED_HEAP_BLOCK_PREFIX
Codice di arresto: 0x12
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Prima violazione dell'accesso casuale per l'analisi dello stack corrente.

probabile causa

!heap -p -a ACCESS_ADDRESS

Questo comando fornirà informazioni dettagliate sulla natura dell'errore e sul blocco heap che viene sovraccaricato. Fornirà anche l'analisi dello stack per l'allocazione del blocco. Esistono diverse altre cause per questo arresto, ad esempio l'accesso a un blocco heap dopo essere stato liberato. Lo stesso comando del debugger sarà utile per questo caso.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo non valido che causa l'eccezione.
Parametro 2 - Indirizzo del codice che esegue l'accesso non valido.
Parametro 3 - Record eccezione.
Parametro 4 - Record di contesto.

Informazioni aggiuntive

Livello di test: Cumuli
ID di arresto: FIRST_CHANCE_ACCESS_VIOLATION
Codice di arresto: 0x13
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Conteggio elenco heap processo non valido.

probabile causa

Questo messaggio può verificarsi se, durante la chiamata a GetProcessHeaps, il gestore dell'heap di pagina rileva alcune incoerenze interne. Ciò può essere causato da un danneggiamento casuale nello spazio del processo.

Informazioni visualizzate da Application Verifier

Parametro 1 - Conteggio effettivo dell'heap.
Parametro 2 - Conteggio heap di pagine.
Parametro 3 - Non usato
Parametro 4 - Non usato

Informazioni aggiuntive

Livello di test: Cumuli
ID di arresto: CORRUPTED_HEAP_LIST
Codice di arresto: 0x14
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Dettagli interruzione perdita

È stata persa un'allocazione dell'heap.

probabile causa

Questo arresto viene generato se la DLL proprietario dell'allocazione è stata scaricata dinamicamente durante il proprietario delle risorse.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo dell'allocazione persa. Eseguire !heap -p -a <indirizzo> per ottenere informazioni aggiuntive sull'allocazione.
Parametro 2 - Indirizzo all'analisi dello stack di allocazione. Eseguire l'indirizzo< dps >per visualizzare lo stack di allocazione.
Parametro 3 - Indirizzo del nome dll del proprietario. Eseguire du <address> per leggere il nome della dll.
Parametro 4 - Base della DLL del proprietario. Eseguire .reload <dll_name> = <address> per ricaricare la DLL del proprietario. Usare 'lm' per ottenere altre informazioni sui moduli caricati e scaricati.

Informazioni aggiuntive

Livello di test: Fessura
ID di arresto: ALLOCAZIONE
Codice di arresto: 0x900
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

È stata persa un HANDLE.

probabile causa

Questo arresto viene generato se la DLL proprietario dell'handle è stata scaricata dinamicamente durante il proprietario delle risorse. Per eseguire il debug dell'arresto: eseguire !htrace parameter1 per ottenere informazioni aggiuntive sull'handle.

Informazioni visualizzate da Application Verifier

Parametro 1 - Valore dell'handle trapelato. Eseguire !htrace <handle> per ottenere informazioni aggiuntive sull'handle se la traccia handle è abilitata.
Parametro 2 - Indirizzo all'analisi dello stack di allocazione. Eseguire l'indirizzo< dps >per visualizzare lo stack di allocazione.
Parametro 3 - Indirizzo del nome dll del proprietario. Eseguire du <address> per leggere il nome della dll.
Parametro 4 - Base della DLL del proprietario. Eseguire .reload <dll_name> = <address> per ricaricare la DLL del proprietario. Usare 'lm' per ottenere altre informazioni sui moduli caricati e scaricati.

Informazioni aggiuntive

Livello di test: Fessura
ID di arresto: MANEGGIARE
Codice di arresto: 0x901
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Un HKEY è stato trapelato.

probabile causa

Questo arresto viene generato se la DLL del proprietario della chiave del Registro di sistema è stata scaricata dinamicamente durante la proprietà delle risorse.

Informazioni visualizzate da Application Verifier

Parametro 1 - Valore dell'HKEY persa.
Parametro 2 - Indirizzo all'analisi dello stack di allocazione. Eseguire l'indirizzo< dps >per visualizzare lo stack di allocazione.
Parametro 3 - Indirizzo del nome dll del proprietario. Eseguire du <address> per leggere il nome della dll.
Parametro 4 - Base della DLL del proprietario. Eseguire .reload <dll_name> = <address> per ricaricare la DLL del proprietario. Usare 'lm' per ottenere altre informazioni sui moduli caricati e scaricati.

Informazioni aggiuntive

Livello di test: Fessura
ID di arresto: REGISTRO
Codice di arresto: 0x902
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Una prenotazione virtuale è stata persa.

probabile causa

Questo arresto viene generato se la DLL proprietario della prenotazione virtuale è stata scaricata dinamicamente durante il proprietario delle risorse.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo di prenotazione persa.
Parametro 2 - Indirizzo all'analisi dello stack di allocazione. Eseguire l'indirizzo< dps >per visualizzare lo stack di allocazione.
Parametro 3 - Indirizzo del nome dll del proprietario. Eseguire du <address> per leggere il nome della dll.
Parametro 4 - Base della DLL del proprietario. Eseguire .reload <dll_name> = <address> per ricaricare la DLL del proprietario. Usare 'lm' per ottenere altre informazioni sui moduli caricati e scaricati.

Informazioni aggiuntive

Livello di test: Fessura
ID di arresto: VIRTUAL_RESERVATION
Codice di arresto: 0x903
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Una BSTR è stata persa.

probabile causa

Questo arresto viene generato se la DLL proprietario di SysString è stata scaricata dinamicamente durante il proprietario delle risorse.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo della stringa BSTR persa. Eseguire !heap -p -a <indirizzo> per ottenere informazioni aggiuntive sull'allocazione.
Parametro 2 - Indirizzo all'analisi dello stack di allocazione. Eseguire l'indirizzo< dps >per visualizzare lo stack di allocazione.
Parametro 3 - Indirizzo del nome dll del proprietario. Eseguire du <address> per leggere il nome della dll.
Parametro 4 - Base della DLL del proprietario. Eseguire .reload <dll_name> = <address> per ricaricare la DLL del proprietario. Usare 'lm' per ottenere altre informazioni sui moduli caricati e scaricati.

Informazioni aggiuntive

Livello di test: Fessura
ID di arresto: SYSSTRING
Codice di arresto: 0x904
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Non è stata annullata la registrazione di una notifica di alimentazione.

probabile causa

Questo arresto viene generato se la DLL registrata per la notifica di alimentazione e è stata scaricata dinamicamente senza annullare la registrazione.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo della registrazione della notifica di alimentazione.
Parametro 2 - Indirizzo all'analisi dello stack di registrazione. Eseguire l'indirizzo< dps >per visualizzare lo stack di allocazione.
Parametro 3 - Indirizzo del nome dll del proprietario. Eseguire du <address> per leggere il nome della dll.
Parametro 4 - Base della DLL del proprietario. Eseguire .reload <dll_name> = <address> per ricaricare la DLL del proprietario. Usare 'lm' per ottenere altre informazioni sui moduli caricati e scaricati.

Informazioni aggiuntive

Livello di test: Fessura
ID di arresto: POWER_NOTIFICATION
Codice di arresto: 0x905
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Dettagli arresto blocchi

Il thread non può essere proprietario di una sezione critica.

probabile causa

Questo arresto viene generato se un thread (ID thread è parametro1) viene terminato, sospeso o in uno stato (thread di lavoro completato un elemento di lavoro) in cui non può contenere una sezione critica. Il thread corrente è il colpevole. Per eseguire il debug di questa interruzione, usare i comandi del debugger seguenti:

kb : per ottenere l'analisi dello stack corrente. Se il thread corrente è il proprietario della sezione critica, è probabile che chiami ExitThread. Il thread corrente deve aver rilasciato la sezione critica prima di uscire. Se il thread corrente chiama TerminateThread o SuspendThread, non deve eseguire questa operazione per un thread che contiene una sezione critica.
!cs -s <parameter2> : informazioni sul dump su questa sezione critica.
ln <parameter2> : per visualizzare i simboli vicino all'indirizzo della sezione critica. Questo dovrebbe aiutare a identificare la sezione critica persa.
dps <parameter4> : per eseguire il dump dell'analisi dello stack per questa inizializzazione critica della sezione.

Informazioni visualizzate da Application Verifier

Parametro 1 - ID thread.
Parametro 2 - Indirizzo della sezione Critica.
Parametro 3 - Critical section debug information address.
Parametro 4 -Critical section initialization stack trace.- Critical section initialization stack trace.

Informazioni aggiuntive

Livello di test: Serrature
ID di arresto: EXIT_THREAD_OWNS_LOCK
Codice di arresto: 0x200
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Scaricamento della DLL contenente una sezione critica attiva.

probabile causa

Questo arresto viene generato se una DLL contiene una variabile globale contenente una sezione critica e la DLL viene scaricata ma la sezione critica non è stata eliminata. Per eseguire il debug di questa interruzione, usare i comandi del debugger seguenti:

du <parameter3> : per eseguire il dump del nome della DLL colpevole.
.reload dllname o .reload dllname = <parameter4> : per ricaricare i simboli per tale DLL.
!cs -s <parameter1> : informazioni sul dump su questa sezione critica.
ln <parameter1> : per visualizzare i simboli vicino all'indirizzo della sezione critica. Questo dovrebbe aiutare a identificare la sezione critica persa.
dps <parameter2> : per eseguire il dump dell'analisi dello stack per l'inizializzazione di questa sezione critica.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo della sezione Critica.
Parametro 2 -Critical section initialization stack trace.- Critical section initialization stack trace.
Parametro 3 - INDIRIZZO del nome DLL.
Parametro 4 - INDIRIZZO di base DELLA DLL.

Informazioni aggiuntive

Livello di test: Serrature
ID di arresto: LOCK_IN_UNLOADED_DLL
Codice di arresto: 0x201
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Liberare un blocco heap contenente una sezione critica attiva.

probabile causa

Questo arresto viene generato se un'allocazione heap contiene una sezione critica, l'allocazione viene liberata e la sezione critica non è stata eliminata. Per eseguire il debug di questa interruzione, usare i comandi del debugger seguenti:

!cs -s <(parametro1):> informazioni sul dump su questa sezione critica.
ln <parameter1> : per visualizzare i simboli vicino all'indirizzo della sezione critica. Questo dovrebbe aiutare a identificare la sezione critica persa.
dps <parameter2> : per eseguire il dump dell'analisi dello stack per l'inizializzazione di questa sezione critica.
< parameter3> e <parameter4> possono essere utili per comprendere dove è stato allocato questo blocco heap (la dimensione dell'allocazione è probabilmente significativa).

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo della sezione Critica.
Parametro 2 -Critical section initialization stack trace.- Critical section initialization stack trace.
Parametro 3 - Indirizzo blocco heap.
Parametro 4 - Dimensioni blocco heap.

Informazioni aggiuntive

Livello di test: Serrature
ID di arresto: LOCK_IN_FREED_HEAP
Codice di arresto: 0x202
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Doppia sezione critica inizializzata o danneggiata.

probabile causa

In genere, questo arresto viene generato se una sezione critica è stata inizializzata più volte. In questo caso parameter3 e parameter4 sono gli indirizzi di analisi dello stack per due di queste inizializzazioni. Altre volte è possibile ottenere questa interruzione se la sezione critica o la relativa struttura di informazioni di debug è stata danneggiata. In questo secondo caso è possibile che il parametro3 e il parametro4 non siano validi e inutili. Per eseguire il debug dell'arresto:

!cs -s -d <parameter2> : informazioni sul dump su questa sezione critica.
ln <parameter1> : per visualizzare i simboli vicino all'indirizzo della sezione critica. Ciò potrebbe aiutare a identificare la sezione critica se si tratta di una variabile globale.
dps <parameter3> e dps <parameter4> : per identificare i due percorsi di codice per l'inizializzazione di questa sezione critica.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo della sezione Critica.
Parametro 2 - Indirizzo della struttura delle informazioni di debug presente nell'elenco attivo.
Parametro 3 - Prima analisi dello stack di inizializzazione.
Parametro 4 - Seconda analisi dello stack di inizializzazione.

Informazioni aggiuntive

Livello di test: Serrature
ID di arresto: LOCK_DOUBLE_INITIALIZE
Codice di arresto: 0x203
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Memoria libera contenente una sezione critica attiva.

probabile causa

Questo arresto viene generato se la memoria contenente una sezione critica è stata liberata, ma la sezione critica non è stata eliminata tramite DeleteCriticalSection. Per eseguire il debug di questa interruzione, usare i comandi del debugger seguenti:</p.>

!cs -s -d <parameter2> : informazioni sul dump su questa sezione critica.
dps <parameter3> : per identificare il percorso del codice per l'inizializzazione di questa sezione critica.

Nella maggior parte dei casi, il verificatore di blocco rileva sezioni critiche immediatamente perse contenute in un'allocazione heap, un intervallo di DLL, un'allocazione di memoria virtuale o un intervallo di memoria mappato mapViewOfFile e genera arresti diversi in questi casi. Quindi ci sono pochissimi casi lasciati per questa fermata del verificatore. Il blocco deve trovarsi in un intervallo di memoria liberato dal codice in modalità kernel o liberato da API come VirtualFreeEx. In genere, questa interruzione verrà rilevata se un arresto precedente (ad esempio, LOCK_IN_FREED_HEAP o LOCK_IN_UNLOADED_DLL) è stato continuato premendo "g" nella console del debugger.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo della sezione Critica.
Parametro 2 - Critical section debug information address.
Parametro 3 -Critical section initialization stack trace.- Critical section initialization stack trace.
Parametro 4 : Non usato.

Informazioni aggiuntive

Livello di test: Serrature
ID di arresto: LOCK_IN_FREED_MEMORY
Codice di arresto: 0x204
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Sezione critica danneggiata.

probabile causa

Questo arresto viene generato se il campo DebugInfo della sezione critica punta alla memoria liberata. In genere un'altra struttura DebugInfo valida si trova nell'elenco delle sezioni critiche attive. Senza danneggiamento, i due puntatori devono essere identici. Per eseguire il debug di questa interruzione, usare i comandi del debugger seguenti:

!cs -s -d <parameter3> : informazioni di dump su questa sezione critica in base al contenuto corrente della struttura delle informazioni di debug presenti nell'elenco attivo (questa struttura è raramente danneggiata, in genere queste informazioni sono attendibili).
!cs -s <parameter1> : informazioni di dump su questa sezione critica in base al contenuto corrente della struttura di sezione critica (la struttura è già danneggiata, a volte queste informazioni non sono attendibili).
dps <parameter4> : per identificare il percorso del codice per l'inizializzazione di questa sezione critica.

Eseguire il dump della sezione critica in address <parameter1> e cercare il modello di danneggiamento. Con i simboli validi per ntdll.dl è possibile usare i comandi seguenti:

dt ntdll!_RTL_CRITICAL_SECTION LOCK_ADDRESS
dt ntdll!_RTL_CRITICAL_SECTION_DEBUG DEBUG_ADDRESS

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo della sezione Critica.
Parametro 2 - Indirizzo delle informazioni di debug non valido di questa sezione critica.
Parametro 3 - Indirizzo delle informazioni di debug trovate nell'elenco attivo.
Parametro 4 - Analisi dello stack di inizializzazione.

Informazioni aggiuntive

Livello di test: Serrature
ID di arresto: LOCK_CORRUPTED
Codice di arresto: 0x205
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Thread proprietario della sezione critica non valido.

probabile causa

Questo arresto viene generato se l'ID del thread proprietario non è valido nel contesto corrente. Per eseguire il debug dell'arresto:

!cs -s <parameter1> : informazioni sul dump su questa sezione critica.
ln <parameter1> : per visualizzare i simboli vicino all'indirizzo della sezione critica. Questo dovrebbe aiutare a identificare la sezione critica.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo della sezione Critica.
Parametro 2 - Proprietario del thread.
Parametro 3 - Previsto thread proprietario.
Parametro 4 - Critical section debug info address.

Informazioni aggiuntive

Livello di test: Serrature
ID di arresto: LOCK_INVALID_OWNER
Codice di arresto: 0x206
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Conteggio ricorsione sezione critica non valido.

probabile causa

Questo arresto viene generato se il campo conteggio ricorsione della struttura di sezione critica non è valido nel contesto corrente. Per eseguire il debug dell'arresto:

!cs -s <parameter1> : informazioni sul dump su questa sezione critica.
ln <parameter1> : per visualizzare i simboli vicino all'indirizzo della sezione critica. Questo dovrebbe aiutare a identificare la sezione critica.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo della sezione Critica.
Parametro 2 - Conteggio ricorsione.
Parametro 3 - Previsto conteggio ricorsione.
Parametro 4 - Critical section debug info address.

Informazioni aggiuntive

Livello di test: Serrature
ID di arresto: LOCK_INVALID_RECURSION_COUNT
Codice di arresto: 0x207
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Eliminazione della sezione critica con numero di blocchi non validi.

probabile causa

Questo arresto viene generato se una sezione critica è di proprietà di un thread se viene eliminata o se la sezione critica non è inizializzata. Per eseguire il debug dell'arresto:

!cs -s <parameter1> : informazioni sul dump su questa sezione critica. Se il thread proprietario è 0, la sezione critica non è stata inizializzata.
ln <parameter1> : per visualizzare i simboli vicino all'indirizzo della sezione critica. Questo dovrebbe aiutare a identificare la sezione critica.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo della sezione Critica.
Parametro 2 - Conteggio blocchi.
Parametro 3 - Previsto conteggio dei blocchi.
Parametro 4 - Proprietario del thread.

Informazioni aggiuntive

Livello di test: Serrature
ID di arresto: LOCK_INVALID_LOCK_COUNT
Codice di arresto: 0x208
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Sezione critica non rilasciata o danneggiata.

probabile causa

Questo arresto viene generato se una sezione critica viene rilasciata più volte rispetto al thread corrente acquisito. Per eseguire il debug dell'arresto:

!cs -s <parameter1> : informazioni sul dump su questa sezione critica.
!cs -s -d <parameter4> : informazioni sul dump su questa sezione critica.
ln <parameter1> : per visualizzare i simboli vicino all'indirizzo della sezione critica. Questo dovrebbe aiutare a identificare la sezione critica.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo della sezione Critica.
Parametro 2 - Conteggio blocchi.
Parametro 3 - Previsto conteggio dei blocchi.
Parametro 4 - Critical section debug info address.

Informazioni aggiuntive

Livello di test: Serrature
ID di arresto: LOCK_OVER_RELEASED
Codice di arresto: 0x209
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Sezione critica non inizializzata.

probabile causa

Questo arresto viene generato se viene utilizzata una sezione critica senza essere inizializzata o dopo l'eliminazione. Per eseguire il debug dell'arresto:

ln <parameter1> : per visualizzare i simboli vicino all'indirizzo della sezione critica. Questo dovrebbe aiutare a identificare la sezione critica.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo della sezione Critica.
Parametro 2 - Critical section debug info address.
Parametro 3 : Non usato.
Parametro 4 : Non usato.

Informazioni aggiuntive

Livello di test: Serrature
ID di arresto: LOCK_NOT_INITIALIZED
Codice di arresto: 0x210
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

La sezione critica è già inizializzata.

probabile causa

Questo arresto viene generato se una sezione critica viene reinizializzata dal thread corrente. Per eseguire il debug dell'arresto:

!cs -s <parameter1> o !cs -s -d <parameter2> : informazioni sul dump su questa sezione critica.
ln <parameter1> : per visualizzare i simboli vicino all'indirizzo della sezione critica. Ciò potrebbe aiutare a identificare la sezione critica se si tratta di una variabile globale.
dps <parameter3> : per identificare il percorso del codice per la prima inizializzazione di questa sezione critica.
kb : per visualizzare l'analisi dello stack corrente, che sta reinizializzando questa sezione critica.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo della sezione Critica.
Parametro 2 - Critical section debug info address.
Parametro 3 - Prima analisi dello stack di inizializzazione. Usare dps per eseguire il dump se non NULL
Parametro 4 : Non usato.

Informazioni aggiuntive

Livello di test: Serrature
ID di arresto: LOCK_ALREADY_INITIALIZED
Codice di arresto: 0x211
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Liberare memoria virtuale contenente una sezione critica attiva.

probabile causa

Questo arresto viene generato se il thread corrente chiama VirtualFree in un blocco di memoria che contiene una sezione critica attiva. L'applicazione deve chiamare DeleteCriticalSection in questa sezione critica prima di liberare questa memoria.

kb : per visualizzare l'analisi dello stack corrente, che chiama VirtualFree. Il probabile colpevole è la DLL che chiama VirtualFree.
!cs -s <parameter1> : informazioni sul dump su questa sezione critica.
dps <parameter2> : per identificare il percorso del codice per l'inizializzazione di questa sezione critica.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo della sezione Critica.
Parametro 2 -Critical section initialization stack trace.- Critical section initialization stack trace.
Parametro 3 - Indirizzo blocco di memoria.
Parametro 4 - Dimensioni del blocco di memoria.

Informazioni aggiuntive

Livello di test: Serrature
ID di arresto: LOCK_IN_FREED_VMEM
Codice di arresto: 0x212
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Annullare il mapping dell'area di memoria contenente una sezione critica attiva.

probabile causa

Questo arresto viene generato se il thread corrente chiama UnmapViewOfFile in un blocco di memoria che contiene una sezione critica attiva. L'applicazione deve chiamare DeleteCriticalSection in questa sezione critica prima di rimuovere il mapping di questa memoria.

kb : per visualizzare l'analisi dello stack corrente, che chiama UnmapViewOfFile . Il probabile colpevole è la DLL che chiama UnmapViewOfFile.
!cs -s <parameter1> : informazioni sul dump su questa sezione critica.
dps <parameter2> : per identificare il percorso del codice per l'inizializzazione di questa sezione critica.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo della sezione Critica.
Parametro 2 -Critical section initialization stack trace.- Critical section initialization stack trace.
Parametro 3 - Indirizzo blocco di memoria.
Parametro 4 - Dimensioni del blocco di memoria.

Informazioni aggiuntive

Livello di test: Serrature
ID di arresto: LOCK_IN_UNMAPPED_MEM
Codice di arresto: 0x213
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Il thread corrente non possiede sezioni critiche.

probabile causa

Questo arresto viene generato se il thread corrente chiama LeaveCriticalSection, ma, in base alla contabilità del verificatore interno, non possiede alcuna sezione critica. Se \<parameter2\> è zero, probabilmente si tratta di un bug nel thread corrente. Prova a lasciare una sezione critica che non è stata immessa o forse chiama LeaveCriticalSection più volte di quanto chiami EnterCriticalSection per la stessa sezione critica. Se \<parameter2\> non è zero (è un numero intero negativo) le strutture dei dati del verificatore interno sono probabilmente danneggiate.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo della sezione Critica.
Parametro 2 - Numero di sezioni critiche di proprietà del thread corrente.
Parametro 3 - Non usato
Parametro 4 - Non usato

Informazioni aggiuntive

Livello di test: Serrature
ID di arresto: THREAD_NOT_LOCK_OWNER
Codice di arresto: 0x214
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Uso della sezione critica privata per un'altra DLL.

probabile causa

Questo arresto viene generato se il thread corrente tenta di usare un blocco privato che si trova all'interno di un'altra DLL. Ad esempio, a.dll tenta di immettere una sezione critica definita all'interno di ntdll.dll. Non è possibile usare blocchi privati tra DLL.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo della sezione Critica.
Parametro 2 : Non usato.
Parametro 3 - Non usato
Parametro 4 - Non usato

Informazioni aggiuntive

Livello di test: Serrature
ID di arresto: LOCK_PRIVATE
Codice di arresto: 0x215
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Dettagli arresto SRWLock

Il blocco SRW non viene inizializzato.

probabile causa

Questo arresto viene generato se un thread sta tentando di usare il blocco SRW (Param1) non inizializzato. Per eseguire il debug di questo arresto, usare "kb" per ottenere l'analisi dello stack corrente. In questo caso viene usato il blocco SRW. Il blocco SRW deve essere inizializzato usando 'InitializeSRWLock' prima di poterlo usare.

Informazioni visualizzate da Application Verifier

Parametro 1 Blocco - SRW
Parametro 2 - Non usato
Parametro 3 - Non usato
Parametro 4 - Non usato

Informazioni aggiuntive

Livello di test: SRWLock
ID di arresto: NOT_INITIALIZED
Codice di arresto: 0x250
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Il blocco SRW è già inizializzato.

probabile causa

Questo arresto viene generato se il blocco SRW (Param1) viene nuovamente inizializzato. Se il blocco SRW viene usato attivamente da altri thread, la reinizializzazione del blocco comporterà un comportamento imprevedibile da parte dell'applicazione, inclusi blocchi e arresti anomali. L'analisi dello stack di inizializzazione può mostrare un'acquisizione se il blocco SRW è stato inizializzato in modo statico. Per eseguire il debug dell'arresto:

kb : per ottenere l'analisi dello stack corrente. In questo caso, il blocco SRW viene nuovamente inizializzato.
dps <parameter3> : per ottenere l'analisi dello stack di inizializzazione del blocco SRW. Questa analisi dello stack può mostrare un'acquisizione se il blocco è stato inizializzato in modo statico.

Informazioni visualizzate da Application Verifier

Parametro 1 Blocco - SRW
Parametro 2 - ThreadId del thread che ha inizializzato il blocco SRW.
Parametro 3 - Indirizzo dell'analisi dello stack di inizializzazione. Usare l'indirizzo< dps >per vedere dove è stato inizializzato il blocco SRW.
Parametro 4 - Non usato

Informazioni aggiuntive

Livello di test: SRWLock
ID di arresto: ALREADY_INITIALIZED
Codice di arresto: 0x251
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Acquire-Release non corrispondenti nel blocco SRW.

probabile causa

Questo arresto viene generato se il blocco SRW (Param1) viene rilasciato con un'API di rilascio errata. Se il blocco SRW è stato acquisito per l'accesso condiviso e viene rilasciato usando l'API di rilascio esclusiva o il blocco SRW è stato acquisito per l'accesso esclusivo e viene rilasciato usando l'API di versione condivisa. Ciò può causare un comportamento imprevedibile da parte dell'applicazione, inclusi blocchi e arresti anomali. Per eseguire il debug dell'arresto:

kb : per ottenere l'analisi dello stack corrente. In questo caso il blocco SRW viene rilasciato usando l'API errata.
dps <parameter3> : per ottenere l'analisi dello stack di acquisizione del blocco SRW.

Informazioni visualizzate da Application Verifier

Parametro 1 Blocco - SRW
Parametro 2 - ThreadId del thread che ha acquisito il blocco SRW.
Parametro 3 - Indirizzo dell'analisi dello stack di acquisizione. Usare l'indirizzo< dps >per vedere dove è stato acquisito il blocco SRW.
Parametro 4 - Non usato

Informazioni aggiuntive

Livello di test: SRWLock
ID di arresto: MISMATCHED_ACQUIRE_RELEASE
Codice di arresto: 0x252
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Il blocco SRW viene acquisito in modo ricorsivo dallo stesso thread.

probabile causa

Questo arresto viene generato se il blocco SRW (Param1) viene acquisito in modo ricorsivo dallo stesso thread. In questo modo si verifica un deadlock e il thread si blocca a tempo indeterminato. L'acquisizione ricorsiva di un blocco SRW in modalità esclusiva causerà un deadlock. L'acquisizione ricorsiva di un blocco SRW in modalità condivisa causerà un deadlock quando è presente un thread in attesa di accesso esclusivo. Si consideri l'esempio seguente: - Il thread A acquisisce il blocco SRW in modalità condivisa- Il thread B tenta di acquisire il blocco SRW in modalità esclusiva e attese- Il thread A tenta di acquisire il blocco SRW in modalità condivisa in modo ricorsivo. Questa operazione avrà esito positivo finché non è presente un cameriere esclusivo (in questo caso B). Poiché i blocchi SRW non hanno fame di writer, il thread A attende dietro il thread B. A questo punto, il thread B è in attesa del thread A, che a sua volta è in attesa del thread B che causa un'attesa circolare e quindi un deadlock. Per eseguire il debug dell'arresto:

kb : per ottenere l'analisi dello stack corrente. È qui che il blocco SRW viene acquisito in modo ricorsivo.
dps <parameter2> : per ottenere l'analisi dello stack per la prima acquisizione.

Informazioni visualizzate da Application Verifier

Parametro 1 Blocco - SRW
Parametro 2 - Indirizzo della prima analisi dello stack di acquisizione. Usare l'indirizzo< dps >per vedere dove è stato acquisito il blocco SRW.
Parametro 3 - Non usato
Parametro 4 - Non usato

Informazioni aggiuntive

Livello di test: SRWLock
ID di arresto: RECURSIVE_ACQUIRE
Codice di arresto: 0x253
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Il thread che sta per uscire o terminare è proprietario di un blocco SRW.

probabile causa

Questo arresto viene generato se il thread (Param2) proprietario del blocco SRW (Param1) viene chiuso o terminato. In questo modo si verifica un blocco SRW orfano e i thread che tentano di acquisire questo blocco bloccano per un periodo illimitato. Per eseguire il debug dell'arresto:

kb : per ottenere l'analisi dello stack corrente. Questo è il percorso in cui il thread viene chiuso o viene terminato.
dps <parameter3> : per ottenere l'analisi dello stack di acquisizione del blocco SRW.

Informazioni visualizzate da Application Verifier

Parametro 1 Blocco - SRW
Parametro 2 - ThreadId del thread che sta per uscire o terminare.
Parametro 3 - Indirizzo dell'analisi dello stack di acquisizione. Usare l'indirizzo< dps >per vedere dove è stato acquisito il blocco SRW.
Parametro 4 - Non usato

Informazioni aggiuntive

Livello di test: SRWLock
ID di arresto: EXIT_THREAD_OWNS_LOCK
Codice di arresto: 0x254
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Il blocco SRW rilasciato non è stato acquisito da questo thread.

probabile causa

Questo arresto viene generato se il blocco SRW (Param1) viene rilasciato dal thread (Param2) che non ha acquisito il blocco. Ciò rappresenta una pratica di programmazione non valida che è difficile da ottenere correttamente e può causare un comportamento imprevedibile da parte dell'applicazione. Per eseguire il debug dell'arresto:

kb : per ottenere l'analisi dello stack corrente. In questo caso, il thread rilascia il blocco SRW che non è stato acquisito.
dps <parameter4> : per ottenere l'analisi dello stack di acquisizione del blocco SRW.

Informazioni visualizzate da Application Verifier

Parametro 1 Blocco - SRW
Parametro 2 - ThreadId corrente.
Parametro 3 - ThreadId del thread che ha acquisito il blocco SRW.
Parametro 4 - Indirizzo dell'analisi dello stack di acquisizione. Usare l'indirizzo< dps >per vedere dove è stato acquisito il blocco SRW.

Informazioni aggiuntive

Livello di test: SRWLock
ID di arresto: INVALID_OWNER
Codice di arresto: 0x255
gravità : avviso
errore monouso:
Segnalazione errori: Nessuno
log nel file: sì
Crea backtrace: sì

La memoria liberata contiene un blocco SRW attivo.

probabile causa

Questo arresto viene generato se l'indirizzo di memoria (Param1) liberato contiene un blocco SRW attivo ancora in uso. Ciò può comportare un comportamento imprevedibile da parte dell'applicazione, inclusi arresti anomali e blocchi. Per eseguire il debug dell'arresto:

kb : per ottenere l'analisi dello stack corrente. In questo caso la memoria viene liberata che contiene un blocco SRW attivo.
dps <parameter4> : per ottenere l'analisi dello stack di acquisizione del blocco SRW.

Informazioni visualizzate da Application Verifier

Parametro 1 Blocco - SRW
Parametro 2 - Indirizzo della memoria liberata.
Parametro 3 - ThreadId del thread che ha acquisito il blocco SRW.
Parametro 4 - Indirizzo dell'analisi dello stack di acquisizione. Usare l'indirizzo< dps >per vedere dove è stato acquisito il blocco SRW.

Informazioni aggiuntive

Livello di test: SRWLock
ID di arresto: IN_FREED_MEMORY
Codice di arresto: 0x256
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

La DLL da scaricare contiene un blocco SRW attivo.

probabile causa

Questo arresto viene generato se la DLL scaricata (Param2) contiene un blocco SRW attivo (Param1) ancora in uso. Ciò può comportare un comportamento imprevedibile da parte dell'applicazione, inclusi arresti anomali e blocchi. Per eseguire il debug dell'arresto:

kb : per ottenere l'analisi dello stack corrente. Questa è la posizione in cui la DLL viene scaricata che contiene un blocco SRW attivo.
du <parameter2> : per trovare il nome della DLL da scaricare.
dps <parameter4> : per ottenere l'analisi dello stack di acquisizione del blocco SRW.

Informazioni visualizzate da Application Verifier

Parametro 1 Blocco - SRW
Parametro 2 - Indirizzo del nome della DLL da scaricare. Usare du <address> per visualizzare il nome.
Parametro 3 - ThreadId del thread che ha acquisito il blocco SRW.
Parametro 4 - Indirizzo dell'analisi dello stack di acquisizione. Usare l'indirizzo< dps >per vedere dove è stato acquisito il blocco SRW.

Informazioni aggiuntive

Livello di test: SRWLock
ID di arresto: IN_UNLOADED_DLL
Codice di arresto: 0x257
gravità : avviso
errore monouso:
Segnalazione errori: Nessuno
log nel file: sì
Crea backtrace: sì

Dettagli arresto memoria

Liberare un blocco di memoria virtuale con dimensioni o indirizzi iniziali non validi.

probabile causa

Questo arresto viene generato se il verificatore dell'app rileva un virtualfree o una DLL scaricata con un indirizzo di avvio o una dimensione non validi dell'allocazione di memoria. Nel caso di scaricamento della DLL, questo probabilmente significa un danneggiamento della memoria all'interno dell'elenco di DLL caricato. Per eseguire il debug di questa interruzione, esaminare l'analisi dello stack corrente e l'indirizzo di memoria e le dimensioni che stanno per essere liberati e provare a determinare il motivo per cui non sono validi.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo di base di allocazione.
Parametro 2 - Dimensioni dell'area di memoria.
Parametro 3 : Non usato.
Parametro 4 : Non usato.

Informazioni aggiuntive

Livello di test: Memoria
ID di arresto: INVALID_FREEMEM
Codice di arresto: 0x600
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Chiamata alloca virtuale non corretta.

probabile causa

Questo arresto viene generato se il verificatore dell'app rileva una chiamata VirtualAlloc con un indirizzo iniziale o una dimensione non validi dell'allocazione di memoria. Per eseguire il debug di questa interruzione, esaminare l'analisi dello stack corrente (kb) e l'indirizzo di memoria e le dimensioni che stanno per essere allocati e provare a determinare il motivo per cui non sono validi.

Informazioni visualizzate da Application Verifier

Parametro 1 - Puntatore all'indirizzo di base di allocazione.
Parametro 2 - Puntatore alle dimensioni dell'area di memoria.
Parametro 3 - Non usato
Parametro 4 - Non usato

Informazioni aggiuntive

Livello di test: Memoria
ID di arresto: INVALID_ALLOCMEM
Codice di arresto: 0x601
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Chiamata di visualizzazione mappa non corretta.

probabile causa

Questo arresto viene generato se il verificatore dell'app rileva una chiamata MapViewOfFile con un indirizzo di base o una dimensione non validi del mapping. Per eseguire il debug di questa interruzione, esaminare l'analisi dello stack corrente (kb) e l'indirizzo di memoria e le dimensioni di cui si sta per eseguire il mapping e provare a determinare il motivo per cui non sono validi.

Informazioni visualizzate da Application Verifier

Parametro 1 - Puntatore al mapping dell'indirizzo di base.
Parametro 2 - Puntatore alle dimensioni della visualizzazione.
Parametro 3 : Non usato.
Parametro 4 : Non usato.

Informazioni aggiuntive

Livello di test: Memoria
ID di arresto: INVALID_MAPVIEW
Codice di arresto: 0x602
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Probe dell'indirizzo non valido.

probabile causa

Questo arresto viene generato se il verificatore dell'app rileva una chiamata IsBadXXXPtr con un indirizzo non valido (ad esempio, un indirizzo in modalità kernel, anziché un normale indirizzo in modalità utente) per il buffer di memoria da probe. Per eseguire il debug di questa interruzione, esaminare l'analisi dello stack corrente (kb) e cercare di determinare il motivo per cui il chiamante della funzione IsBadXXXPtr è finito con un indirizzo non valido. Molte volte, l'indirizzo è semplice fasullo, ad esempio un puntatore non inizializzato. MSDN Library elenca alcuni motivi per cui le applicazioni non devono usare le API IsBadXXXPtr: in un ambiente multitasking preemptive, è possibile che altri thread modifichino l'accesso al processo alla memoria sottoposta a test. Il dereferenziamento dei puntatori potenzialmente non validi può disabilitare l'espansione dello stack in altri thread. Un thread che esaurisce lo stack, quando l'espansione dello stack è stata disabilitata, comporta la chiusura immediata del processo padre, senza alcuna finestra di errore popup o informazioni di diagnostica. I thread in un processo dovrebbero cooperare in modo tale che uno non libera memoria che l'altro ha bisogno. L'uso di questa funzione non nega la necessità di eseguire questa operazione. In caso contrario, l'applicazione potrebbe non riuscire in modo imprevedibile. Per tutti questi motivi, è consigliabile non usare mai queste API.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo iniziale.
Parametro 2 - Dimensioni del blocco di memoria.
Parametro 3 - Indirizzo non valido.
Parametro 4 : Non usato.

Informazioni aggiuntive

Livello di test: Memoria
ID di arresto: PROBE_INVALID_ADDRESS
Codice di arresto: 0x603
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Probe della memoria libera.

probabile causa

Questo arresto viene generato se il verificatore dell'app rileva una chiamata IsBadXXXPtr per un'allocazione di memoria libera. Questo problema è molto negativo perché è possibile che, in altri casi, questa memoria sia già stata riutilizzata per un'altra allocazione. Poiché il percorso del codice corrente (kb) non possiede tale memoria, potrebbe finire per danneggiare la memoria di qualcun altro, con effetti disastrosi. Per eseguire il debug di questa interruzione, esaminare l'analisi dello stack corrente (kb) e provare a determinare il motivo per cui il chiamante della funzione IsBadXXXPtr ha terminato il probe della memoria libera. L'indirizzo potrebbe essere fittizio (ad esempio un puntatore non inizializzato) o forse già liberato memoria. Se la memoria è già stata liberata da una delle API VirtualFree o UnmapViewOfFile, '!avrf -vs -a parameter3' cercherà un log di analisi dello stack dei percorsi di codice che hanno allocato/liberato tale indirizzo e visualizzeranno queste tracce dello stack, se disponibili. Ciò potrebbe mostrare l'analisi dello stack che ha liberato questa memoria. Più spesso, la memoria è un'allocazione dell'heap già liberata. Per verificare tale possibilità, '!avrf -hp -a parameter3' cercherà un log di analisi dello stack dei percorsi di codice allocati/liberati dall'heap e visualizzerà queste tracce dello stack, se disponibili. MSDN Library elenca alcuni motivi per cui le applicazioni non devono usare le API IsBadXXXPtr: in un ambiente multitasking preemptive, è possibile che altri thread modifichino l'accesso al processo alla memoria sottoposta a test. Il dereferenziamento dei puntatori potenzialmente non validi può disabilitare l'espansione dello stack in altri thread. Un thread che esaurisce lo stack, quando l'espansione dello stack è stata disabilitata, comporta la chiusura immediata del processo padre, senza alcuna finestra di errore popup o informazioni di diagnostica. I thread in un processo dovrebbero cooperare in modo tale che uno non libera memoria che l'altro ha bisogno. L'uso di questa funzione non nega la necessità di eseguire questa operazione. In caso contrario, l'applicazione potrebbe non riuscire in modo imprevedibile. Per tutti questi motivi, è consigliabile non usare mai queste API.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo iniziale.
Parametro 2 - Dimensioni del blocco di memoria.
Parametro 3 - Indirizzo della pagina di memoria libera.
Parametro 4 : Non usato.

Informazioni aggiuntive

Livello di test: Memoria
ID di arresto: PROBE_FREE_MEM
Codice di arresto: 0x604
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Probing di una pagina di protezione.

probabile causa

Questo arresto viene generato se il verificatore dell'app rileva una chiamata IsBadXXXPtr per un'allocazione di memoria contenente almeno un GUARD_PAGE. Questa situazione è molto negativa perché è molto possibile che questa GUARD_PAGE sia la fine dello stack corrente di un thread. Come documentato in MSDN Library: il dereferenziamento dei puntatori potenzialmente non validi può disabilitare l'espansione dello stack in altri thread. Un thread che esaurisce lo stack, quando l'espansione dello stack è stata disabilitata, comporta la chiusura immediata del processo padre, senza alcuna finestra di errore popup o informazioni di diagnostica. Per eseguire il debug di questa interruzione, esaminare l'analisi dello stack corrente (kb) e provare a determinare il motivo per cui il chiamante della funzione IsBadXXXPtr ha terminato il probe di un GUARD_PAGE. MSDN Library elenca alcuni motivi per cui le applicazioni non devono usare le API IsBadXXXPtr: in un ambiente multitasking preemptive, è possibile che altri thread modifichino l'accesso al processo alla memoria sottoposta a test. Il dereferenziamento dei puntatori potenzialmente non validi può disabilitare l'espansione dello stack in altri thread. Un thread che esaurisce lo stack, quando l'espansione dello stack è stata disabilitata, comporta la chiusura immediata del processo padre, senza alcuna finestra di errore popup o informazioni di diagnostica. I thread in un processo dovrebbero cooperare in modo tale che uno non libera memoria che l'altro ha bisogno. L'uso di questa funzione non nega la necessità di eseguire questa operazione. In caso contrario, l'applicazione potrebbe non riuscire in modo imprevedibile. Per tutti questi motivi, è consigliabile non usare mai queste API.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo iniziale.
Parametro 2 - Dimensioni del blocco di memoria.
Parametro 3 - Indirizzo della pagina di protezione.
Parametro 4 : Non usato.

Informazioni aggiuntive

Livello di test: Memoria
ID di arresto: PROBE_GUARD_PAGE
Codice di arresto: 0x605
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Probe dell'indirizzo NULL.

probabile causa

Questo arresto viene generato se il verificatore dell'app rileva una chiamata IsBadXXXPtr con un indirizzo NULL. Per eseguire il debug di questa interruzione, esaminare l'analisi dello stack corrente (kb) e provare a determinare il motivo per cui il chiamante della funzione IsBadXXXPtr è finito con l'indirizzo NULL. Questo è in genere il segno di un utente che non controlla il valore restituito di una delle funzioni di allocazione della memoria. Ad esempio, il codice seguente non è corretto:

void Use(PVOID p);

int main(void) {
    PVOID p;
    p = malloc(1024);
    Use(p);
    return 0;
}

void Use(PVOID p) {
    if (IsBadReadPtr(p)) {
        return;
    }
    // p is safe to be used here.
}

Questo codice deve essere riscritto come segue:

int main (void) 
{ 
    PVOID p; 
    
    p = malloc (1024); 
    if (NULL == p)) { 
        return -1;
     } 

    Use (p); 

    return 0; 
} 

void Use (PVOID p) 
{
    // 
    // p is safe to be used here. 
    // 
}

MSDN Library elenca alcuni motivi per cui le applicazioni non devono usare le API IsBadXXXPtr: in un ambiente multitasking preemptive, è possibile che altri thread modifichino l'accesso al processo alla memoria sottoposta a test. Il dereferenziamento dei puntatori potenzialmente non validi può disabilitare l'espansione dello stack in altri thread. Un thread che esaurisce lo stack, quando l'espansione dello stack è stata disabilitata, comporta la chiusura immediata del processo padre, senza alcuna finestra di errore popup o informazioni di diagnostica. I thread in un processo dovrebbero cooperare in modo tale che uno non libera memoria che l'altro ha bisogno. L'uso di questa funzione non nega la necessità di eseguire questa operazione. In caso contrario, l'applicazione potrebbe non riuscire in modo imprevedibile. Per tutti questi motivi, è consigliabile non usare mai queste API.

Informazioni visualizzate da Application Verifier

Parametro 1 : Non usato.
Parametro 2 : Non usato.
Parametro 3 : Non usato.
Parametro 4 : Non usato.

Informazioni aggiuntive

Livello di test: Memoria
ID di arresto: PROBE_NULL
Codice di arresto: 0x606
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Probe del blocco di memoria con indirizzo iniziale o dimensioni non valide.

probabile causa

Questo arresto viene generato se il verificatore dell'app rileva una chiamata IsBadXXXPtr con un indirizzo iniziale non valido (ad esempio, un indirizzo in modalità kernel, anziché un normale indirizzo in modalità utente) o dimensioni non valide per il buffer di memoria da eseguire tramite probe. Per eseguire il debug di questa interruzione, esaminare l'analisi dello stack corrente (kb) e provare a determinare il motivo per cui il chiamante della funzione IsBadXXXPtr ha terminato con un indirizzo o una dimensione non validi. Molte volte, l'indirizzo o le dimensioni sono semplici, ad esempio variabili non inizializzate. MSDN Library elenca alcuni motivi per cui le applicazioni non devono usare le API IsBadXXXPtr: in un ambiente multitasking preemptive, è possibile che altri thread modifichino l'accesso al processo alla memoria sottoposta a test. Il dereferenziamento dei puntatori potenzialmente non validi può disabilitare l'espansione dello stack in altri thread. Un thread che esaurisce lo stack, quando l'espansione dello stack è stata disabilitata, comporta la chiusura immediata del processo padre, senza alcuna finestra di errore popup o informazioni di diagnostica. I thread in un processo dovrebbero cooperare in modo tale che uno non libera memoria che l'altro ha bisogno. L'uso di questa funzione non nega la necessità di eseguire questa operazione. In caso contrario, l'applicazione potrebbe non riuscire in modo imprevedibile. Per tutti questi motivi, è consigliabile non usare mai queste API.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo iniziale.
Parametro 2 - Dimensioni del blocco di memoria.
Parametro 3 : Non usato.
Parametro 4 : Non usato.

Informazioni aggiuntive

Livello di test: Memoria
ID di arresto: PROBE_INVALID_START_OR_SIZE
Codice di arresto: 0x607
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Scaricamento della DLL con dimensioni o indirizzo iniziale non validi.

probabile causa

Questo arresto viene generato se il verificatore dell'app rileva lo scaricamento di una DLL con un indirizzo iniziale o una dimensione non valida dell'intervallo di memoria DLL. Questo significa probabilmente un danneggiamento della memoria all'interno dell'elenco interno ntdll.dll DLL caricato.

Informazioni visualizzate da Application Verifier

Parametro 1 - INDIRIZZO di base della memoria DLL.
Parametro 2 Dimensioni dell'intervallo di memoria DLL .
Parametro 3 - INDIRIZZO del nome DLL. Usare du per eseguire il dump.
Parametro 4 : Non usato.

Informazioni aggiuntive

Livello di test: Memoria
ID di arresto: INVALID_DLL_RANGE
Codice di arresto: 0x608
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Liberare un blocco di memoria all'interno dell'intervallo di indirizzi dello stack del thread corrente.

probabile causa

Questo arresto viene generato se il verificatore dell'app rileva un virtualfree per un blocco di memoria che fa effettivamente parte dello stack del thread corrente (!). Per eseguire il debug di questa interruzione, esaminare l'analisi dello stack corrente (kb) e cercare di capire perché la funzione che ha chiamato VirtualFree pensava che il blocco di memoria fosse allocato o mappato in modo dinamico, ma che era effettivamente memoria allocata dallo stack.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo di base di allocazione.
Parametro 2 - Dimensioni dell'area di memoria.
Parametro 3 -Stack low limit address .- Stack low limit address.
Parametro 4 - Stack high limit address (Stack high limit address).

Informazioni aggiuntive

Livello di test: Memoria
ID di arresto: FREE_THREAD_STACK_MEMORY
Codice di arresto: 0x609
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Parametro FreeType errato per l'operazione VirtualFree.

probabile causa

Questo arresto viene generato se il verificatore dell'app rileva un oggetto VirtualFree con un valore non corretto per il parametro FreeType. Gli unici due valori accettabili per questo parametro sono MEM_DECOMMIT e MEM_RELEASE. Se VirtualFree viene chiamato con qualsiasi altro valore tranne questi due, VirtualFree non riuscirà a liberare la memoria. Per eseguire il debug di questa interruzione, esaminare l'analisi dello stack corrente (kb): il chiamante di VirtualFree è probabilmente il colpevole.

Informazioni visualizzate da Application Verifier

Parametro 1 - Valore non corretto usato dall'applicazione.
Parametro 2 - Previsto valore corretto 1.
Parametro 3 - Previsto valore corretto 2.
Parametro 4 : Non usato.

Informazioni aggiuntive

Livello di test: Memoria
ID di arresto: INVALID_FREE_TYPE
Codice di arresto: 0x60A
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Tentativo di liberare un blocco di memoria virtuale già disponibile.

probabile causa

Questo arresto viene generato se il verificatore dell'app rileva un oggetto VirtualFree per un indirizzo già gratuito. Per eseguire il debug di questa interruzione, esaminare l'analisi dello stack corrente (kb) e provare a determinare il motivo per cui la memoria è già libera, ma l'applicazione sta tentando di liberarla nuovamente. '!avrf -vs -a parameter1' cercherà un log di analisi dello stack dei percorsi di codice allocati/liberati da tale indirizzo e visualizzerà queste tracce dello stack, se disponibili. Ciò potrebbe mostrare l'analisi dello stack che ha liberato questa memoria.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo blocco di memoria.
Parametro 2 : Non usato.
Parametro 3 : Non usato.
Parametro 4 : Non usato.

Informazioni aggiuntive

Livello di test: Memoria
ID di arresto: MEM_ALREADY_FREE
Codice di arresto: 0x60B
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Parametro Size non corretto per l'operazione VirtualFree (MEM_RELEASE).

probabile causa

Questo arresto viene generato se il verificatore dell'app rileva un virtualfree (MEM_RELEASE) con un valore diverso da zero per il parametro dwSize. Quando si usa MEM_RELEASE , l'unico valore accettabile per questo parametro è 0. Se VirtualFree viene chiamato con qualsiasi altro valore ad eccezione di 0, VirtualFree non riuscirà a liberare la memoria. Per eseguire il debug di questa interruzione, esaminare l'analisi dello stack corrente (kb): il chiamante di VirtualFree è probabilmente il colpevole.

Informazioni visualizzate da Application Verifier

Parametro 1 - Dimensioni non corrette usate dall'applicazione.
Parametro 2 - Previsto dimensione corretta (0).
Parametro 3 : Non usato.
Parametro 4 : Non usato.

Informazioni aggiuntive

Livello di test: Memoria
ID di arresto: INVALID_FREE_SIZE
Codice di arresto: 0x60C
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Eccezione imprevista generata nella routine del punto di ingresso della DLL.

probabile causa

Questo arresto viene generato se la funzione dll(DllMain) del punto di ingresso di una DLL genera un'eccezione. Un esempio è negativo: se DllMain(DLL_PROCESS_ATTACH) genera un'eccezione, il caricatore DLL di Windows: - Intercettare e nascondere l'eccezione; - Scaricare la DLL senza chiamare dllMain(DLL_PROCESS_DETACH). Quindi, in molti casi, la DLL ha già allocato alcune risorse, quindi ha generato l'eccezione e non avrà la possibilità di rilasciare queste risorse in DllMain (DLL_PROCESS_DETACH). Per eseguire il debug dell'arresto:

- **du \<*parameter1*\>** per visualizzare il nome della DLL. - **.exr \<*parameter2*\>** per visualizzare le informazioni sull'eccezione. - **.cxr \<*parameter3*\>** seguito da **kb** - per visualizzare le informazioni sul contesto dell'eccezione e l'analisi dello stack per il momento in cui è stata generata l'eccezione. - **\<*parameter4*\>** è l'indirizzo di una struttura di verifica interna e non ha alcun significato per la maggior parte degli utenti del verificatore.

Informazioni visualizzate da Application Verifier

Parametro 1 - DLL name (usare du per eseguire il dump).
Parametro 2 - Record eccezione. Usare .exr per visualizzarlo.
Parametro 3 - Record di contesto. Usare .cxr per visualizzarlo.
Parametro 4 Descrittore dll - Verifier

Informazioni aggiuntive

Livello di test: Memoria
ID di arresto: DLL_UNEXPECTED_EXCEPTION
Codice di arresto: 0x60D
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Eccezione imprevista generata nella funzione thread.

probabile causa

Questo arresto viene generato se una funzione thread genera un'eccezione. Questo è male perché l'intero processo verrà ucciso. Per eseguire il debug dell'arresto:

< parameter1> potrebbe essere significativo per il tipo di eccezione. Ad esempio, un codice di eccezione C0000005 indica violazione di accesso.
.exr <parameter2> : per visualizzare le informazioni sull'eccezione.
Parametro .cxr3 <> seguito da kb : per visualizzare le informazioni sul contesto dell'eccezione

Informazioni visualizzate da Application Verifier

Parametro 1 - Codice eccezione.
Parametro 2 - Record eccezione. Usare .exr per visualizzarlo.
Parametro 3 - Record di contesto. Usare .cxr per visualizzarlo.
Parametro 4 : Non usato.

Informazioni aggiuntive

Livello di test: Memoria
ID di arresto: THREAD_UNEXPECTED_EXCEPTION
Codice di arresto: 0x60E
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Eccezione imprevista generata durante il probe della memoria.

probabile causa

Questo arresto viene generato se viene generata un'eccezione durante una chiamata a IsBadXXXPtr. Ciò significa che il buffer di memoria che stiamo eseguendo il probe non ha effettivamente la protezione presunta dal chiamante, o che la memoria è già stata liberata, ecc. Vedere la discussione precedente su altri codici di arresto (PROBE_INVALID_ADDRESS, PROBE_FREE_MEM, PROBE_GUARD_PAGE, PROBE_NULL, PROBE_INVALID_START_OR_SIZE) per altri esempi del motivo per cui non è consigliabile usare le API IsBadXXXPtr. Per eseguire il debug dell'arresto:

< parameter1> in genere sarà C0000005, una violazione di accesso
Parametro .exr2><: per visualizzare le informazioni sull'eccezione
.cxr <parameter3> seguito da kb : per visualizzare le informazioni sul contesto dell'eccezione e l'analisi dello stack al momento in cui è stata generata l'eccezione

Informazioni visualizzate da Application Verifier

Parametro 1 - Codice eccezione.
Parametro 2 - Record eccezione. Usare .exr per visualizzarlo.
Parametro 3 - Record di contesto. Usare .cxr per visualizzarlo.
Parametro 4 - Non usato

Informazioni aggiuntive

Livello di test: Memoria
ID di arresto: PROBE_UNEXPECTED_EXCEPTION
Codice di arresto: 0x60F
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Tentativo di reimpostare l'indirizzo NULL.

probabile causa

Questo arresto viene generato se il verificatore dell'app rileva una chiamata VirtualFree (MEM_RESET) con un primo parametro NULL. MEM_RESET deve essere usato solo per la memoria già allocata, quindi NULL non è un primo parametro valido in questo caso.

Informazioni visualizzate da Application Verifier

Parametro 1 : Non usato.
Parametro 2 : Non usato.
Parametro 3 : Non usato.
Parametro 4 : Non usato.

Informazioni aggiuntive

Livello di test: Memoria
ID di arresto: INVALID_MEM_RESET
Codice di arresto: 0x610
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Liberando il blocco di memoria heap all'interno dell'intervallo di indirizzi dello stack del thread corrente.

probabile causa

Questo arresto viene generato se il verificatore dell'app rileva un heapFree, per un blocco di memoria che fa effettivamente parte dello stack del thread corrente (!). Per eseguire il debug di questo arresto, esaminare l'analisi dello stack corrente (kb) e cercare di capire perché la funzione che ha chiamato HeapFree pensava che il blocco di memoria fosse allocato o mappato in modo dinamico, ma che in realtà era memoria allocata dallo stack.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo di base di allocazione.
Parametro 2 - Dimensioni dell'area di memoria.
Parametro 3 -Stack low limit address .- Stack low limit address.
Parametro 4 - Stack high limit address (Stack high limit address).

Informazioni aggiuntive

Livello di test: Memoria
ID di arresto: FREE_THREAD_STACK_MEMORY_AS_HEAP
Codice di arresto: 0x612
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Annullamento del mapping dell'area di memoria all'interno dell'intervallo di indirizzi dello stack del thread corrente.

probabile causa

Questo arresto viene generato se il verificatore dell'app rileva un oggetto UnmapViewOfFile, per un blocco di memoria che fa effettivamente parte dello stack del thread corrente (!). Per eseguire il debug di questo arresto, esaminare l'analisi dello stack corrente (kb) e cercare di capire perché la funzione che ha chiamato UnmapViewOfFile pensava che il blocco di memoria fosse allocato o mappato in modo dinamico, ma che in realtà era memoria allocata dallo stack.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo di base di allocazione.
Parametro 2 - Dimensioni dell'area di memoria.
Parametro 3 -Stack low limit address .- Stack low limit address.
Parametro 4 - Stack high limit address (Stack high limit address).

Informazioni aggiuntive

Livello di test: Memoria
ID di arresto: FREE_THREAD_STACK_MEMORY_AS_MAP
Codice di arresto: 0x613
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Indirizzo di RTL_RESOURCE non corretto.

probabile causa

Questo arresto viene generato se l'applicazione sta tentando di usare NULL o un altro indirizzo non corretto ,ad esempio un indirizzo in modalità kernel, come indirizzo di un oggetto valido. RtlInitializeResource (NULL) è una chiamata API non corretta che attiverà questo tipo di arresto del verificatore. *Parameter1* è l'indirizzo non corretto usato e il colpevole si trova nell'analisi dello stack (visualizzarlo con kb).

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo.
Parametro 2 : Non usato.
Parametro 3 : Non usato.
Parametro 4 : Non usato.

Informazioni aggiuntive

Livello di test: Memoria
ID di arresto: INVALID_RESOURCE_ADDRESS
Codice di arresto: 0x614
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Indirizzo della sezione critica non valido.

probabile causa

Questo arresto viene generato se l'applicazione sta tentando di usare NULL o un altro indirizzo non corretto ,ad esempio un indirizzo in modalità kernel, come indirizzo di un oggetto valido. EnterCriticalSection(NULL) è una chiamata API non corretta che attiverà questo tipo di arresto del verificatore. *Parameter1* è l'indirizzo non corretto usato e il colpevole si trova nell'analisi dello stack (visualizzarlo con kb).

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo.
Parametro 2 : Non usato.
Parametro 3 : Non usato.
Parametro 4 : Non usato.

Informazioni aggiuntive

Livello di test: Memoria
ID di arresto: INVALID_CRITSECT_ADDRESS
Codice di arresto: 0x615
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Tentare di eseguire il codice nella memoria non eseguibile.

probabile causa

Questo arresto viene generato se l'applicazione sta tentando di eseguire codice da un indirizzo non eseguibile o gratuito. Per eseguire il debug dell'arresto:

u <parameter2> : per rimuovere il codice colpevole
Parametro .exr3><: per visualizzare le informazioni sull'eccezione
.cxr <parameter4> seguito da kb : per visualizzare le informazioni sul contesto dell'eccezione e l'analisi dello stack per il momento in cui è stata generata l'eccezione.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo a cui si accede.
Parametro 2 - Codice che esegue l'accesso non valido.
Parametro 3 - Record eccezione. Usare .exr per visualizzarlo.
Parametro 4 - Record di contesto. Usare .cxr per visualizzarlo.

Informazioni aggiuntive

Livello di test: Memoria
ID di arresto: THREAD_UNEXPECTED_EXCEPTION_CODE
Codice di arresto: 0x616
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Eccezione imprevista generata durante l'inizializzazione del buffer di output.

probabile causa

Questo arresto viene generato se si ottiene un'eccezione durante l'inizializzazione di un buffer specificato come parametro di output per un'API Win32 o CRT. Ciò significa in genere che le dimensioni del buffer di output specificate non sono corrette. Per eseguire il debug dell'arresto:

Parametro .exr3><: per visualizzare le informazioni sull'eccezione.
.cxr <parameter4> seguito da kb : per visualizzare le informazioni sul contesto dell'eccezione e l'analisi dello stack al momento in cui è stata generata l'eccezione.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo iniziale del buffer.
Parametro 2 - Dimensioni del buffer.
Parametro 3 - Record eccezione. Usare .exr per visualizzarlo.
Parametro 4 - Record di contesto. Usare .cxr per visualizzarlo.

Informazioni aggiuntive

Livello di test: Memoria
ID di arresto: OUTBUFF_UNEXPECTED_EXCEPTION
Codice di arresto: 0x617
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Eccezione imprevista quando si tenta di trovare le dimensioni del blocco heap.

probabile causa

Questo arresto viene generato se viene generata un'eccezione durante la chiamata di HeapSize per un blocco heap che viene liberato. Ciò significa in genere che l'indirizzo del blocco heap specificato non è corretto o che l'heap è danneggiato. Per eseguire il debug dell'arresto:

Parametro .exr3><: per visualizzare il record di eccezione.
.cxr <parameter4> seguito da kb : per visualizzare le informazioni sul contesto dell'eccezione e l'analisi dello stack al momento in cui è stata generata l'eccezione.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo del blocco heap liberato.
Parametro 2 Handle - Heap.
Parametro 3 - Record eccezione. Usare .exr per visualizzarlo.
Parametro 4 - Record di contesto. Usare .cxr per visualizzarlo.

Informazioni aggiuntive

Livello di test: Memoria
ID di arresto: SIZE_HEAP_UNEXPECTED_EXCEPTION
Codice di arresto: 0x618
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Liberare un blocco di memoria con indirizzo iniziale non valido.

probabile causa

Questo arresto viene generato se il programma chiama VirtualFree (MEM_RELEASE) con un parametro lpAddress che non è l'indirizzo di base restituito dalla funzione VirtualAlloc o VirtualAllocEx quando è stata riservata l'area delle pagine; Per eseguire il debug dell'arresto:

kb : per visualizzare l'analisi dello stack corrente, che chiama VirtualFree. Il probabile colpevole è la DLL che chiama VirtualFree.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo del blocco di memoria liberato.
Parametro 2 - Previsto indirizzo del blocco di memoria corretto.
Parametro 3 : Non usato.
Parametro 4 : Non usato.

Informazioni aggiuntive

Livello di test: Memoria
ID di arresto: INVALID_FREEMEM_START_ADDRESS
Codice di arresto: 0x619
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Annullamento del mapping del blocco di memoria con indirizzo iniziale non valido.

probabile causa

Questo arresto viene generato se il programma chiama UnmapViewOfFile con un parametro lpBaseAddress non identico al valore restituito da una chiamata precedente alla funzione MapViewOfFile o MapViewOfFileEx. Per eseguire il debug dell'arresto:

kb : per visualizzare l'analisi dello stack corrente, che chiama UnmapViewOfFile. Il probabile colpevole è la DLL che chiama UnmapViewOfFile.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo del blocco di memoria non mappato.
Parametro 2 - Previsto indirizzo del blocco di memoria corretto.
Parametro 3 : Non usato.
Parametro 4 : Non usato.

Informazioni aggiuntive

Livello di test: Memoria
ID di arresto: INVALID_UNMAPVIEW_START_ADDRESS
Codice di arresto: 0x619
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

eccezione imprevista generata nella funzione di callback del pool di thread.

probabile causa

Questo arresto viene generato se una funzione di callback nel thread threadpool genera un'eccezione. Per eseguire il debug dell'arresto:

< parameter1> potrebbe essere significativo per il tipo di eccezione. Ad esempio, un codice di eccezione C0000005 indica violazione di accesso.
.exr <parameter2> : per visualizzare le informazioni sull'eccezione.
.cxr <parameter3> seguito da kb : per visualizzare le informazioni sul contesto dell'eccezione.

Informazioni visualizzate da Application Verifier

Parametro 1 - Codice eccezione
Parametro 2 - Record eccezione. Usare .exr per visualizzarlo
Parametro 3 - Record di contesto. Usare .cxr per visualizzarlo
Parametro 4 - Non usato

Informazioni aggiuntive

Livello di test: Memoria
ID di arresto: THREADPOOL_UNEXPECTED_EXCEPTION
Codice di arresto: 0x61B
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

codice in memoria non eseguibile

probabile causa

Questo arresto viene generato se l'applicazione sta tentando di eseguire codice da un indirizzo non eseguibile o gratuito. Per eseguire il debug dell'arresto:

u <parameter2> : per rimuovere il codice colpevole
Parametro .exr3><: per visualizzare le informazioni sull'eccezione
.cxr <parameter4> seguito da kb : per visualizzare le informazioni sul contesto dell'eccezione e l'analisi dello stack per il momento in cui è stata generata l'eccezione.

Informazioni visualizzate da Application Verifier

Parametro 1 - Indirizzo a cui si accede
Parametro 2 - Codice che esegue l'accesso non valido
Parametro 3 - Record eccezione. Usare .exr per visualizzarlo.
Parametro 4 - Record di contesto. Usare .cxr per visualizzarlo.

Informazioni aggiuntive

Livello di test: Memoria
ID di arresto: THREADPOOL_UNEXPECTED_EXCEPTION_CODE
Codice di arresto: 0x61C
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Creazione dell'heap eseguibile.

probabile causa

Questo arresto viene generato se l'applicazione sta creando un heap eseguibile. Può trattarsi di un rischio per la sicurezza.

Informazioni visualizzate da Application Verifier

Parametro 1 : Non usato.
Parametro 2 : Non usato.
Parametro 3 : Non usato.
Parametro 4 : Non usato.

Informazioni aggiuntive

Livello di test: Memoria
ID di arresto: EXECUTABLE_HEAP
Codice di arresto: 0x1D
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Allocazione della memoria eseguibile.

probabile causa

Questo arresto viene generato se l'applicazione sta allocando memoria eseguibile. Può trattarsi di un rischio per la sicurezza.

Informazioni visualizzate da Application Verifier

Parametro 1 - Protezione della pagina specificata dal chiamante.
Parametro 2 : Non usato.
Parametro 3 : Non usato.
Parametro 4 : Non usato.

Informazioni aggiuntive

Livello di test: Memoria
ID di arresto: EXECUTABLE_MEMORY
Codice di arresto: 0x1E
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Dettagli arresto TLS

Scaricamento della DLL che ha allocato l'indice TLS non liberato.

probabile causa

Questo arresto viene generato se una DLL allocata un indice TLS viene scaricata prima di liberare l'indice TLS. Per eseguire il debug dell'arresto:

du <parameter3> : visualizzare il nome della DLL colpevole
.reload xxx.dll=<parameter4> : ricaricare i simboli per la DLL colpevole (se necessario). xxx.dll è il nome della DLL visualizzata nel passaggio precedente.
u <parameter2> : disassemblare il codice allocato a TLS. Questo dovrebbe puntare alla funzione che ha allocato TLS, ma ha dimenticato di liberarlo prima che la DLL sia stata scaricata.

Informazioni visualizzate da Application Verifier

Parametro 1 - INDICE TLS
Parametro 2 - Indirizzo del codice che ha allocato questo indice TLS.
Parametro 3 - INDIRIZZO del nome DLL. Usare du per eseguire il dump.
Parametro 4 - INDIRIZZO di base DELLA DLL.

Informazioni aggiuntive

Livello di test: TLS
ID di arresto: TLS_LEAK
Codice di arresto: 0x350
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Struttura TLS del verificatore danneggiata.

probabile causa

Questo arresto viene generato se le strutture di verifica interne usate per archiviare lo stato degli slot TLS per il thread sono danneggiate. Molto probabilmente questo è dovuto a un certo danneggiamento casuale nel processo.

Informazioni visualizzate da Application Verifier

Parametro 1 Indirizzo - TEB.
Parametro 2 - Previsto indirizzo TEB.
Parametro 3 - ID thread.
Parametro 4 - ID thread previsto.

Informazioni aggiuntive

Livello di test: TLS
ID di arresto: CORRUPTED_TLS
Codice di arresto: 0x351
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Uso di un indice TLS non valido.

probabile causa

Questo arresto viene generato se viene usato un indice TLS non valido. Nella maggior parte dei casi, il codice usa ancora questo indice quando viene chiamato TlsFree. Di seguito è riportato un esempio per il thread del pool di thread.

T1: Caricamento dll e TlsAlloc
T1: callback della coda
T1: callback ignorato/annullato
T1: TlsFree
T2: Callback esegue e chiama TlsSetValue
T1: Scaricamento dll

Informazioni visualizzate da Application Verifier

Parametro 1 - INDICE TLS
Parametro 2 - Non usato.
Parametro 3 - Non usato.
Parametro 4 - Non usato.

Informazioni aggiuntive

Livello di test: TLS
ID di arresto: INVALID_TLS_INDEX
Codice di arresto: 0x352
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Dettagli arresto threadpool

La priorità di questo thread di threadpool è stata modificata.

probabile causa

Questo arresto viene generato se la priorità del thread viene modificata quando viene restituita al pool di thread.

Informazioni visualizzate da Application Verifier

Formato: - Threadpool thread (%x) dopo l'esecuzione del callback (%p) ha una priorità di thread modificata (%i -> %i)
Parametro 1 - Funzione callback.
Parametro 2 - Contesto.
Parametro 3 - Threadpool Analisi dello stack di allocazione degli oggetti, usare dps per eseguire il dump.
Parametro 4 - Priorità corrente.

Informazioni aggiuntive

Livello di test: Pool di thread
ID di arresto: INCONSISTENT_PRIORITY
Codice di arresto: 0x700
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

L'affinità di questo thread del pool di thread è stata modificata.

probabile causa

Questo arresto viene generato se l'affinità thread viene modificata quando viene restituita al pool di thread.

Informazioni visualizzate da Application Verifier

Formato: - threadpool thread (%x) dopo l'esecuzione del callback (%p) ha una maschera di affinità di thread modificata (%p -> %p)
Parametro 1 - Funzione callback.
Parametro 2 - Contesto.
Parametro 3 - Threadpool Analisi dello stack di allocazione degli oggetti, usare dps per eseguire il dump.
Parametro 4 - Affinità corrente.

Informazioni aggiuntive

Livello di test: Pool di thread
ID di arresto: INCONSISTENT_AFFINITY_MASK
Codice di arresto: 0x701
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Msg non elaborato nel pool msg del thread corrente.

probabile causa

Questo arresto viene generato se un messaggio lasciato come non elaborato quando questo thread del pool di thread viene restituito al pool. È pericoloso perché verrà elaborato in un contesto completamente diverso. Usare !avrf -tp <Param4> per visualizzare i messaggi inviati a questo thread.

Informazioni visualizzate da Application Verifier

Formato: - threadpool thread (%x) dopo l'esecuzione del callback (%p) ha un messaggio di finestra in sospeso (%x: %x)
Parametro 1 - Funzione callback.
Parametro 2 - Contesto.
Parametro 3 - Threadpool Analisi dello stack di allocazione degli oggetti, usare dps per eseguire il dump.
Parametro 4 - Id threadpool. Usare !avrf -tp <threadid> per visualizzare i messaggi inviati a questo thread.

Informazioni aggiuntive

Livello di test: Pool di thread
ID di arresto: ORPHANED_THREAD_MESSAGE
Codice di arresto: 0x702
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

La finestra non chiuso appartiene al thread corrente.

probabile causa

Questo arresto viene generato se una finestra viene mantenuta attiva quando questo thread del pool di thread viene restituito al pool.

Informazioni visualizzate da Application Verifier

Formato: - threadpool thread (%x) dopo l'esecuzione del callback (%p) ha hwnd valido (%x: %s) che potrebbe ricevere messaggi
Parametro 1 - Funzione callback.
Parametro 2 - Contesto.
Parametro 3 - Threadpool Analisi dello stack di allocazione degli oggetti, usare dps per eseguire il dump.
Parametro 4 - Id threadpool.

Informazioni aggiuntive

Livello di test: Pool di thread
ID di arresto: ORPHANED_THREAD_WINDOW
Codice di arresto: 0x703
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

ExitThread() o TerminateThread() in un thread del pool di thread.

probabile causa

Questo arresto viene generato se ExitThread viene chiamato in un thread del pool di thread. È vietato perché renderà instabile il sistema. Causerà una perdita di risorse, un blocco o av.

Informazioni visualizzate da Application Verifier

Parametro 1 - Funzione callback.
Parametro 2 - Contesto.
Parametro 3 - Threadpool Analisi dello stack di allocazione degli oggetti, usare dps per eseguire il dump.
Parametro 4 - Non usato.

Informazioni aggiuntive

Livello di test: Pool di thread
ID di arresto: ILLEGAL_THREAD_TERMINATION
Codice di arresto: 0x704
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Il thread è in stato di rappresentazione quando viene restituito a un thread del pool di thread.

probabile causa

Questo arresto viene generato se la funzione di callback modifica il token del thread per rappresentare un altro utente e ha dimenticato di reimpostarlo prima di restituirlo al pool di thread.

Informazioni visualizzate da Application Verifier

Parametro 1 - Funzione callback.
Parametro 2 - Contesto.
Parametro 3 - Threadpool Analisi dello stack di allocazione degli oggetti, usare dps per eseguire il dump.
Parametro 4 - Non usato.

Informazioni aggiuntive

Livello di test: Pool di thread
ID di arresto: THREAD_IN_IMPERSONATION
Codice di arresto: 0x705
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Viene chiamata una funzione che richiede un thread permanente.

probabile causa

Alcune API di Microsoft Windows devono essere chiamate all'interno di un thread dedicato o permanente. Nel pool di thread è in genere consigliabile evitare di usare l'archiviazione locale del thread e l'accodamento di chiamate asincrone che richiedono un thread permanente, ad esempio la funzione RegNotifyChangeKeyValue. Tuttavia, tali funzioni possono essere accodate a un thread di lavoro persistente usando QueueUserWorkItem con l'opzione WT_EXECUTEINPERSISTENTTHREAD. Un kb nel debugger rivelerà il chiamante.

Informazioni visualizzate da Application Verifier

Parametro 1 - Funzione callback.
Parametro 2 - Contesto.
Parametro 3 - Threadpool Analisi dello stack di allocazione degli oggetti, usare dps per eseguire il dump.
Parametro 4 - Non usato.

Informazioni aggiuntive

Livello di test: Pool di thread
ID di arresto: PERSISTED_THREAD_NEEDED
Codice di arresto: 0x706
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Il thread è in stato di transazione dirty.

probabile causa

Questo arresto viene generato se la funzione di callback ha dimenticato di chiudere o reimpostare l'handle di transazione corrente.

Informazioni visualizzate da Application Verifier

Parametro 1 - Funzione callback.
Parametro 2 - Contesto.
Parametro 3 - Threadpool Analisi dello stack di allocazione degli oggetti, usare dps per eseguire il dump.
Parametro 4 - Transaction Handle.

Informazioni aggiuntive

Livello di test: Pool di thread
ID di arresto: DIRTY_TRANSACTION_CONTEXT
Codice di arresto: 0x707
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Questo stato del pool di thread ha chiamate CoInit e CoUnInit non bilanciate.

probabile causa

Questo arresto viene generato se la funzione callback chiama CoInit e CoUnInit non bilanciato.

Informazioni visualizzate da Application Verifier

Parametro 1 - Funzione callback.
Parametro 2 - Contesto.
Parametro 3 - Threadpool Analisi dello stack di allocazione degli oggetti, usare dps per eseguire il dump.
Parametro 4 - Bilanciato Numero di chiamate.

Informazioni aggiuntive

Livello di test: Pool di thread
ID di arresto: DIRTY_COM_STATE
Codice di arresto: 0x708
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

I parametri per l'oggetto timer non sono coerenti. Il periodo deve essere 0 quando si specifica WT_EXECUTEONLYONCE durante la creazione del timer

probabile causa

Questo arresto viene generato se il periodo per segnalare il timer non è zero quando il timer è impostato per segnalare solo una volta con il flag WT_EXECUTEONLYONCE

Informazioni visualizzate da Application Verifier

Parametro 1 - Periodo specificato.
Parametro 2 - Flag specificati.
Parametro 3 - Non usato.
Parametro 4 - Non usato.

Informazioni aggiuntive

Livello di test: Pool di thread
ID di arresto: INCONSISTENT_TIMER_PARAMS
Codice di arresto: 0x709
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Il blocco del caricatore è stato mantenuto dal threadpool del thread all'interno del callback.

probabile causa

Questo arresto viene generato se il blocco del caricatore viene mantenuto all'interno del callback e non viene rilasciato quando il thread viene restituito al pool di thread.

Informazioni visualizzate da Application Verifier

Parametro 1 - Funzione callback.
Parametro 2 - Contesto.
Parametro 3 - Threadpool Analisi dello stack di allocazione degli oggetti, usare dps per eseguire il dump.
Parametro 4 - Non usato.

Informazioni aggiuntive

Livello di test: Pool di thread
ID di arresto: LOADER_LOCK_HELD
Codice di arresto: 0x7A
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

La lingua preferita viene impostata dal thread del pool di thread all'interno del callback.

probabile causa

Questo arresto viene generato se la lingua preferita viene impostata all'interno del callback e non viene cancellata quando il thread viene restituito al pool di thread.

Informazioni visualizzate da Application Verifier

Parametro 1 - Funzione callback.
Parametro 2 - Contesto.
Parametro 3 - Threadpool Analisi dello stack di allocazione degli oggetti, usare dps per eseguire il dump.
Parametro 4 - Non usato.

Informazioni aggiuntive

Livello di test: Pool di thread
ID di arresto: PREFERRED_LANGUAGES_SET
Codice di arresto: 0x7B
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

La priorità in background viene impostata dal thread del pool di thread all'interno del callback.

probabile causa

Questo arresto viene generato se la priorità in background viene impostata all'interno del callback e non viene disabilitata quando il thread viene restituito al pool di thread.

Informazioni visualizzate da Application Verifier

Parametro 1 - Funzione callback.
Parametro 2 - Contesto.
Parametro 3 - Threadpool Analisi dello stack di allocazione degli oggetti, usare dps per eseguire il dump.
Parametro 4 - Non usato.

Informazioni aggiuntive

Livello di test: Pool di thread
ID di arresto: BACKGROUND_PRIORITY_SET
Codice di arresto: 0x7C
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

TerminateThread() in un thread del pool di thread.

probabile causa

Questo arresto viene generato se TerminateThread viene chiamato in un thread del pool di thread. È vietato perché renderà instabile il sistema. Causerà una perdita di risorse, un blocco o av.

Informazioni visualizzate da Application Verifier

Parametro 1 - Non usato.
Parametro 2 - Non usato.
Parametro 3 - Non usato.
Parametro 4 - Non usato.

Informazioni aggiuntive

Livello di test: Pool di thread
ID di arresto: ILLEGAL_THREAD_TERMINATION
Codice di arresto: 0x7D
gravità : errore di
errore monouso:
Segnalazione errori: interruzione
log nel file: sì
Crea backtrace: sì

Vedere anche

Application Verifier - Codici di arresto e definizioni

Application Verifier - Panoramica

Application Verifier - Funzionalità

Application Verifier - Testing Applications

Application Verifier - Test in Application Verifier

Application Verifier - Debug application Verifier arresta

Application Verifier - Domande frequenti

Valutazione

Questa pagina ti è stata utile?

Last updated on 2025-11-01

Condividi tramite

Verifica dell'applicazione - Codici di arresto - Nozioni di base

Dettagli arresto eccezioni

Tentare di eseguire il codice nella memoria non eseguibile (prima probabilità).

Gestisce i dettagli di arresto

Eccezione di handle non valida per l'analisi dello stack corrente.

Indice TLS non valido usato per l'analisi dello stack corrente.

Parametri non validi per la chiamata WaitForMultipleObjects.

Handle NULL passato come parametro. È necessario utilizzare un handle valido.

In attesa di un handle di thread in DllMain.

Tipo di oggetto non corretto per handle.

Dettagli arresto heap

Errore sconosciuto.

Eccezione di violazione di accesso.

Accesso multithreading in un heap creato con HEAP_NO_SERIALIZE flag.

Richiesta di dimensioni estreme.

Handle heap con firma non corretta.

Puntatore dell'heap danneggiato o uso dell'heap errato.

Blocco heap già liberato.

Blocco heap danneggiato.

Tentare di distruggere l'heap del processo.

Eccezione imprevista generata nel codice heap.

Eccezione generata durante la verifica dell'intestazione del blocco heap.

Eccezione generata durante la verifica del blocco heap.

Blocco heap danneggiato dopo essere stato liberato.

Modello di prefisso danneggiato per il blocco heap liberato.

Modello di suffisso danneggiato per il blocco heap.

Stamp di inizio danneggiato per il blocco heap.

Stamp finale danneggiato per il blocco heap.

Modello di prefisso danneggiato per il blocco heap.

Prima violazione dell'accesso casuale per l'analisi dello stack corrente.

Conteggio elenco heap processo non valido.

Dettagli interruzione perdita

È stata persa un'allocazione dell'heap.

È stata persa un HANDLE.

Un HKEY è stato trapelato.

Una prenotazione virtuale è stata persa.

Una BSTR è stata persa.

Non è stata annullata la registrazione di una notifica di alimentazione.

Dettagli arresto blocchi

Il thread non può essere proprietario di una sezione critica.

Scaricamento della DLL contenente una sezione critica attiva.

Liberare un blocco heap contenente una sezione critica attiva.

Doppia sezione critica inizializzata o danneggiata.

Memoria libera contenente una sezione critica attiva.

Sezione critica danneggiata.

Thread proprietario della sezione critica non valido.

Conteggio ricorsione sezione critica non valido.

Eliminazione della sezione critica con numero di blocchi non validi.

Sezione critica non rilasciata o danneggiata.

Sezione critica non inizializzata.

La sezione critica è già inizializzata.

Liberare memoria virtuale contenente una sezione critica attiva.

Annullare il mapping dell'area di memoria contenente una sezione critica attiva.

Il thread corrente non possiede sezioni critiche.

Uso della sezione critica privata per un'altra DLL.

Dettagli arresto SRWLock

Il blocco SRW non viene inizializzato.

Il blocco SRW è già inizializzato.

Acquire-Release non corrispondenti nel blocco SRW.

Il blocco SRW viene acquisito in modo ricorsivo dallo stesso thread.

Il thread che sta per uscire o terminare è proprietario di un blocco SRW.

Il blocco SRW rilasciato non è stato acquisito da questo thread.

La memoria liberata contiene un blocco SRW attivo.

La DLL da scaricare contiene un blocco SRW attivo.

Dettagli arresto memoria

Liberare un blocco di memoria virtuale con dimensioni o indirizzi iniziali non validi.

Chiamata alloca virtuale non corretta.

Chiamata di visualizzazione mappa non corretta.

Probe dell'indirizzo non valido.

Probe della memoria libera.

Probing di una pagina di protezione.

Probe dell'indirizzo NULL.

Probe del blocco di memoria con indirizzo iniziale o dimensioni non valide.

Scaricamento della DLL con dimensioni o indirizzo iniziale non validi.

Liberare un blocco di memoria all'interno dell'intervallo di indirizzi dello stack del thread corrente.

Parametro FreeType errato per l'operazione VirtualFree.

Tentativo di liberare un blocco di memoria virtuale già disponibile.

Parametro Size non corretto per l'operazione VirtualFree (MEM_RELEASE).

Eccezione imprevista generata nella routine del punto di ingresso della DLL.