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 di questa interruzione: $ u parameter2 - per rimuovere il codice colpevole $ .exr parameter3 - 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 a cui si accede con indirizzo 1  .
• Parametro 2 -  Codice che esegue l'accesso non valido.
• Record di eccezione 3   del parametro. Usare .exr per visualizzarlo.
• Parametro 4-Context   record. Usare .cxr per visualizzarlo.

Informazioni aggiuntive

• Livello di test: Eccezioni
• Stop ID: FIRST_CHANCE_ACCESS_VIOLATION_CODE
• Codice di arresto: 650NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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à qual è il valore dell'handle passato (deve essere uno dei parametri, in genere il primo). Se il valore è Null, questo è chiaramente errato. Se il valore sembra ok, è necessario usare l'estensione del debugger !htrace per ottenere una cronologia delle operazioni relative a questo valore di handle. Nella maggior parte dei casi deve essere necessario che il valore dell'handle venga usato dopo la chiusura.

Informazioni visualizzate da Application Verifier

• Codice di eccezione del parametro 1  .
• Record di eccezione del parametro 2  . Usare .exr per visualizzarlo.
• Parametro 3-Context   record. Usare .cxr per visualizzarlo.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Handle
• Stop ID: INVALID_HANDLE
• Codice di arresto: 300NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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à ciò che è sbagliato. Il bug tipico è quello di presupporre un determinato valore per un indice TLS anziché chiamare TlsAlloc. Ciò può verificarsi pensando che si ottiene sempre il valore N, pertanto non è necessario chiamare TlsAlloc o più frequentemente a causa di una variabile non inizializzata.

Informazioni visualizzate da Application Verifier

• Parametro 1-Indice   TLS non valido.
• Parametro 2-Previsto   parte inferiore dell'indice.
• Parametro 3-Non   utilizzato.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Handle
• Stop ID: INVALID_TLS_VALUE
• Codice di arresto: 300NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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   utilizzato.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Handle
• Stop ID: INCORRECT_WAIT_CALL
• Codice di arresto: 300NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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.

Informazioni visualizzate da Application Verifier

• Parametro 1-Non   utilizzato.
• Parametro 2-Non   utilizzato.
• Parametro 3-Non   utilizzato.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Handle
• Stop ID: NULL_HANDLE
• Codice di arresto: 300NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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. Ciò potrebbe causare probabilmente un deadlock perché l'handle del thread non verrà segnalato a meno che il secondo thread non esegua l'uscita. Quando il secondo thread chiamerà ExitThread, tenterà di acquisire il blocco del caricatore DLL e quindi chiamare DllMain (DLL_THREAD_DETACH) per tutte le DLL nel processo corrente. Ma il blocco del caricatore è di proprietà del primo thread (quello in attesa dell'handle del thread) in modo che i due thread vengano deadlock.

Informazioni visualizzate da Application Verifier

• Handle del parametro 1-Thread  .
• Parametro 2-Non   utilizzato.
• Parametro 3-Non   utilizzato.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Handle
• ID di arresto: WAIT_IN_DLLMAIN
• Codice di arresto: 300NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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 genererà questa interruzione. Per eseguire il debug di questa interruzione: $ 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 verrà visualizzato: Semaforo. $ du parameter3: per visualizzare il tipo di oggetto previsto dall'API. Nell'esempio precedente questo nome sarà: Event. $ !htrace parameter1 potrebbe essere utile perché visualizzerà l'analisi dello stack per le operazioni di apertura/chiusura recenti su questo handle.

Informazioni visualizzate da Application Verifier

• Parametro 1-Handle   value.
• Nome del tipo di oggetto 2   del parametro. Usare du per visualizzarlo
• Parametro 3-Previsto   nome del tipo di oggetto. Usare du per visualizzarlo
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Handle
• Stop ID: INCORRECT_OBJECT_TYPE
• Codice di arresto: 300NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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: Heaps
• ID di arresto: UNKNOWN_ERROR
• Codice di arresto: 0NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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 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. Ci sono diverse altre cause per questa fermata. Ad esempio, l'accesso a un blocco heap dopo essere stato liberato. Lo stesso comando del debugger sarà utile anche 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
• Record 3  eccezioni  parametro
• Parametro 4-Context   record

Informazioni aggiuntive

• Livello di test: Heaps
• Stop ID: ACCESS_VIOLATION
• Codice di arresto: 0NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare backtrace: sì

Accesso multithreading in un heap creato con flag HEAP_NO_edizione Standard RIALIZE.

Probabile causa

Un heap creato con il flag HEAP_NO_edizione Standard RIALIZE non dovrebbe essere accessibile contemporaneamente da due thread. Se viene rilevata una situazione di questo tipo, si riceverà 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++ può essere collegato in modo statico a tale libreria quando vengono usati flag appropriati. Poi le persone dimenticano 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: Heaps
• ID di arresto: UNSYNCHRONIZED_ACCESS
• Codice di arresto: 0NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare backtrace: sì

Richiesta di dimensioni estreme.

Probabile causa

Questo messaggio verrà generato se in un'operazione HeapAlloc() o HeapReAlloc() le dimensioni del blocco sono superiori 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-Size   richiesto
• Parametro 3-Non   usato
• Parametro 4-Non   usato

Informazioni aggiuntive

• Livello di test: Heaps
• Stop ID: EXTREME_SIZE_REQUEST
• Codice di arresto: 0NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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 i comandi del debugger seguenti: !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à questo arresto (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

• Handle del parametro 1-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: Heaps
• Stop ID: BAD_HEAP_HANDLE
• Codice di arresto: 0NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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 !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 tramite HeapFree().

Informazioni visualizzate da Application Verifier

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

Informazioni aggiuntive

• Livello di test: Heaps
• Stop ID: SWITCHED_HEAP_HANDLE
• Codice di arresto: 0NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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, questo 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

• Handle del parametro 1-Heap   per l'heap proprietario del blocco.
• Il blocco 2-Heap   del parametro viene nuovamente liberato.
• Parametro 3-Size   del blocco heap.
• Parametro 4-Non   usato

Informazioni aggiuntive

• Livello di test: Heaps
• Stop ID: DOUBLE_FR edizione Enterprise
• Codice di arresto: 0NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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

• Handle del parametro 1-Heap   usato nella chiamata.
• Blocco 2-Heap   del parametro coinvolto nell'operazione.
• Parametro 3-Size   del blocco heap.
• Parametro 4  riservato 

Informazioni aggiuntive

• Livello di test: Heaps
• ID di arresto: CORRUPTED_HEAP_BLOCK
• Codice di arresto: 0NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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

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

Informazioni aggiuntive

• Livello di test: Heaps
• ID di arresto: DESTROY_PROCESS_HEAP
• Codice di arresto: 0NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare backtrace: sì

Eccezione imprevista generata durante l'esecuzione del codice di gestione dell'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 legittima. Ci sono pochissime situazioni in cui questo è ok, 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: $ .exr STOP-PARAMETER-2 $ .cxr STOP-PARAMETER-3 In genere questa interruzione può verificarsi se si verifica un danneggiamento casuale nelle strutture heap interne.

Informazioni visualizzate da Application Verifier

• Parametro 1-Heap   coinvolto nell'operazione.
• Record di eccezione del parametro 2  .
• Parametro 3-Context   record.
• Codice di eccezione del parametro 4   (C0000005 - violazione di accesso)

Informazioni aggiuntive

• Livello di test: Heaps
• ID di arresto: UNEXPECTED_EXCEPTION
• Codice di arresto: 0NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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. È molto probabile che questo arresto si verifichi quando l'indirizzo del blocco heap passato a un heap punti liberi a un'area di memoria non accessibile (puntatore danneggiato, puntatore non inizializzato e così via).

Informazioni visualizzate da Application Verifier

• Handle del parametro 1-Heap   per l'heap proprietario del blocco.
• Blocco 2-Heap   del parametro danneggiato.
• Parametro 3-Size   del blocco o zero se non è possibile determinare le dimensioni.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Heaps
• Stop ID: CORRUPTED_HEAP_BLOCK_EXCEPTION_RAI edizione Standard D_FOR_HEADER
• Codice di arresto: 0NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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

• Handle del parametro 1-Heap   usato nella chiamata.
• Blocco 2-Heap   del parametro coinvolto nell'operazione.
• Parametro 3-Size   del blocco heap.
• Parametro 4  riservato .

Informazioni aggiuntive

• Livello di test: Heaps
• Stop ID: CORRUPTED_HEAP_BLOCK_EXCEPTION_RAI edizione Standard D_FOR_PROBING
• Codice di arresto: 0NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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

• Handle del parametro 1-Heap   per l'heap proprietario del blocco.
• Blocco 2-Heap   del parametro danneggiato.
• Parametro 3-Size   del blocco o zero se non è possibile determinare le dimensioni.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Heaps
• Stop ID: CORRUPTED_HEAP_BLOCK_HEADER
• Codice di arresto: 0NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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 (heap pagina leggera) 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

• Handle del parametro 1-Heap   per l'heap proprietario del blocco.
• Il blocco 2-Heap   del parametro viene liberato.
• Parametro 3-Size   del blocco heap.
• Parametro 4  riservato .

Informazioni aggiuntive

• Livello di test: Heaps
• Stop ID: CORRUPTED_FR edizione Enterprise D_HEAP_BLOCK
• Codice di arresto: 0NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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 libero (arresto qui) e all'analisi dello stack di allocazione (!heap -p -a HEAP_ADDRESS)

Informazioni visualizzate da Application Verifier

• Handle del parametro 1-Heap   usato nella chiamata.
• Blocco 2-Heap   del parametro coinvolto nell'operazione.
• Parametro 3-Size   del blocco heap.
• Parametro 4  riservato .

Informazioni aggiuntive

• Livello di test: Heaps
• Stop ID: CORRUPTED_HEAP_BLOCK_SUFFIX
• Codice di arresto: 0NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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

• Handle del parametro 1-Heap   usato nella chiamata.
• Blocco 2-Heap   del parametro coinvolto nell'operazione.
• Parametro 3-Size   del blocco heap.
• Parametro 4-Danneggiato   valore stamp.

Informazioni aggiuntive

• Livello di test: Heaps
• Stop ID: CORRUPTED_HEAP_BLOCK_START_STAMP
• Codice di arresto: 0NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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

• Handle del parametro 1-Heap   usato nella chiamata.
• Blocco 2-Heap   del parametro coinvolto nell'operazione.
• Parametro 3-Size   del blocco heap.
• Parametro 4-Danneggiato   valore stamp.

Informazioni aggiuntive

• Livello di test: Heaps
• ID di arresto: CORRUPTED_HEAP_BLOCK_END_STAMP
• Codice di arresto: 0NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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

• Handle del parametro 1-Heap   usato nella chiamata.
• Blocco 2-Heap   del parametro coinvolto nell'operazione.
• Parametro 3-Size   del blocco heap.
• Parametro 4  riservato .

Informazioni aggiuntive

• Livello di test: Heaps
• ID di arresto: CORRUPTED_HEAP_BLOCK_PREFIX
• Codice di arresto: 0NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare backtrace: sì

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

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 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. Ci sono diverse altre cause per questa fermata. Ad esempio, l'accesso a un blocco heap dopo essere stato liberato. Lo stesso comando del debugger sarà utile anche 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.
• Record di eccezione 3   del parametro.
• Parametro 4-Context   record.

Informazioni aggiuntive

• Livello di test: Heaps
• ID di arresto: FIRST_CHANCE_ACCESS_VIOLATION
• Codice di arresto: 0NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare backtrace: sì

Conteggio elenco heap processo non valido.

Probabile causa

Questo messaggio può verificarsi se durante la chiamata a GetProcessHeaps il gestore dell'heap della 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   heap effettivo.
• Conteggio dell'heap a 2   pagine.
• Parametro 3-Non   usato
• Parametro 4-Non   usato

Informazioni aggiuntive

• Livello di test: Heaps
• Stop ID: CORRUPTED_HEAP_LIST
• Codice di arresto: 0NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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-Address   per l'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: Perdita
• Stop ID: ALLOCATION
• Codice di arresto: 900NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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-Address   per l'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: Perdita
• Stop ID: HANDLE
• Codice di arresto: 900NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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   della chiave HKEY persa.
• Parametro 2-Address   per l'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: Perdita
• STOP ID: REGISTRY
• Codice di arresto: 900NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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-Address   per l'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: Perdita
• Stop ID: VIRTUAL_RE edizione Standard RVATION
• Codice di arresto: 900NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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-Address   per l'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: Perdita
• Stop ID: SYSSTRING
• Codice di arresto: 900NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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-Address   per l'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: Perdita
• Stop ID: POWER_NOTIFICATION
• Codice di arresto: 900NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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 di sezione critica.

Informazioni visualizzate da Application Verifier

• PARAMETRO 1-ID   thread.
• Indirizzo della sezione 2-Critical   del parametro.
• Indirizzo delle informazioni di debug della sezione 3-Critical  .
• Analisi dello stack di inizializzazione della  sezione critica 4. 

Informazioni aggiuntive

• Livello di test: Blocchi
• Stop ID: EXIT_THREAD_OWNS_LOCK
• Codice di arresto: 200NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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 questa inizializzazione di sezione critica.

Informazioni visualizzate da Application Verifier

• Indirizzo della sezione 1-Critico   del parametro.
• Analisi dello stack di inizializzazione della sezione critica 2  .
• Parametro 3-DLL   nome indirizzo.
• Parametro 4-DLL   indirizzo di base.

Informazioni aggiuntive

• Livello di test: Blocchi
• ID di arresto: LOCK_IN_UNLOADED_DLL
• Codice di arresto: 200NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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 parameter1 - informazioni di 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 questa inizializzazione di sezione critica. $ parameter3 e parameter4 potrebbero aiutare a capire dove è stato allocato questo blocco heap (la dimensione dell'allocazione è probabilmente significativa).

Informazioni visualizzate da Application Verifier

• Indirizzo della sezione 1-Critico   del parametro.
• Analisi dello stack di inizializzazione della sezione critica 2  .
• Parametro 3-Indirizzo   blocco heap.
• Dimensione del blocco a 4  heap  parametro.

Informazioni aggiuntive

• Livello di test: Blocchi
• Stop ID: LOCK_IN_FR edizione Enterprise D_HEAP
• Codice di arresto: 200NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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 di questa interruzione: $ !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

• Indirizzo della sezione 1-Critico   del parametro.
• Parametro 2-Indirizzo   della struttura delle informazioni di debug presente nell'elenco attivo.
• Analisi dello stack di inizializzazione del parametro 3-First  .
• Analisi dello stack di inizializzazione del parametro 4  secondi .

Informazioni aggiuntive

• Livello di test: Blocchi
• Stop ID: LOCK_DOUBLE_INITIALIZE
• Codice di arresto: 200NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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: $ !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. La maggior parte di queste interruzioni viene in genere rilevata se un arresto precedente (ad esempio, LOCK_IN_FR edizione Enterprise D_HEAP o LOCK_IN_UNLOADED_DLL) è stato continuato premendo "g" nella console del debugger.

Informazioni visualizzate da Application Verifier

• Indirizzo della sezione 1-Critico   del parametro.
• Indirizzo delle informazioni di debug della sezione Critica 2  .
• Analisi dello stack di inizializzazione della sezione 3-Critical  .
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Blocchi
• ID di arresto: LOCK_IN_FR edizione Enterprise D_MEMORY
• Codice di arresto: 200NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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 presente nell'elenco attivo (questa struttura è raramente danneggiata, quindi 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 buoni simboli per ntdll.dl è possibile usare i comandi seguenti: $ dt ntdll!_RTL_CRITICAL_edizione Standard CTION LOCK_ADDRESS $ dt ntdll!_RTL_CRITICAL_edizione Standard CTION_DEBUG DEBUG_ADDRESS

Informazioni visualizzate da Application Verifier

• Indirizzo della sezione 1-Critico   del parametro.
• Parametro 2-Indirizzo   di informazioni di debug non valido di questa sezione critica.
• Parametro 3-Indirizzo   delle informazioni di debug disponibili nell'elenco attivo.
• Analisi dello stack di inizializzazione del parametro 4  .

Informazioni aggiuntive

• Livello di test: Blocchi
• Stop ID: LOCK_CORRUPTED
• Codice di arresto: 200NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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 di questa interruzione: $ !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

• Indirizzo della sezione 1-Critico   del parametro.
• Thread proprietario del parametro 2  .
• Parametro 3-Previsto   thread proprietario.
• Parametro 4-Critical   sezione debug info address.

Informazioni aggiuntive

• Livello di test: Blocchi
• Stop ID: LOCK_INVALID_OWNER
• Codice di arresto: 200NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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 di questa interruzione: $ !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

• Indirizzo della sezione 1-Critico   del parametro.
• Conteggio della ricorsione del parametro 2  .
• Parametro 3-Previsto   conteggio ricorsione.
• Parametro 4-Critical   sezione debug info address.

Informazioni aggiuntive

• Livello di test: Blocchi
• Stop ID: LOCK_INVALID_RECURSION_COUNT
• Codice di arresto: 200NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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 di questa interruzione: $ !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

• Indirizzo della sezione 1-Critico   del parametro.
• Parametro 2-Lock   count.
• Parametro 3-Previsto   conteggio blocchi.
• Thread proprietario del parametro 4  .

Informazioni aggiuntive

• Livello di test: Blocchi
• Stop ID: LOCK_INVALID_LOCK_COUNT
• Codice di arresto: 200NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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 di questa interruzione: $ !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

• Indirizzo della sezione 1-Critico   del parametro.
• Parametro 2-Lock   count.
• Parametro 3-Previsto   conteggio blocchi.
• Parametro 4-Critical   sezione debug info address.

Informazioni aggiuntive

• Livello di test: Blocchi
• Stop ID: LOCK_OVER_RELEA edizione Standard D
• Codice di arresto: 200NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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 di questa interruzione: $ 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

• Indirizzo della sezione 1-Critico   del parametro.
• Parametro 2-Critical   sezione debug info address.
• Parametro 3-Non   utilizzato.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Blocchi
• Stop ID: LOCK_NOT_INITIALIZED
• Codice di arresto: 200NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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 di questa interruzione: $ !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

• Indirizzo della sezione 1-Critico   del parametro.
• Parametro 2-Critical   sezione debug info address.
• Analisi dello stack di inizializzazione del parametro 3-First  . Usare dps per eseguire il dump se non NULL
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Blocchi
• ID di arresto: LOCK_ALREADY_INITIALIZED
• Codice di arresto: 200NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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

• Indirizzo della sezione 1-Critico   del parametro.
• Analisi dello stack di inizializzazione della sezione critica 2  .
• Parametro 3-Indirizzo   blocco di memoria.
• Dimensione del blocco di 4  memoria  del parametro.

Informazioni aggiuntive

• Livello di test: Blocchi
• Stop ID: LOCK_IN_FR edizione Enterprise D_VMEM
• Codice di arresto: 200NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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

• Indirizzo della sezione 1-Critico   del parametro.
• Analisi dello stack di inizializzazione della sezione critica 2  .
• Parametro 3-Indirizzo   blocco di memoria.
• Dimensione del blocco di 4  memoria  del parametro.

Informazioni aggiuntive

• Livello di test: Blocchi
• Stop ID: LOCK_IN_UNMAPPED_MEM
• Codice di arresto: 200NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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

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

Informazioni aggiuntive

• Livello di test: Blocchi
• Stop ID: THREAD_NOT_LOCK_OWNER
• Codice di arresto: 200NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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

• Indirizzo della sezione 1-Critico   del parametro.
• Parametro 2-Non   utilizzato.
• Parametro 3-Non   usato
• Parametro 4-Non   usato

Informazioni aggiuntive

• Livello di test: Blocchi
• Stop ID: LOCK_PRIVATE
• Codice di arresto: 200NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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. $ 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

• Blocco 1-SRW   del parametro
• 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: 250NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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. $ kb : per ottenere l'analisi dello stack corrente. In questo caso, il blocco SRW viene nuovamente inizializzato. $ dps Param3: 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

• Blocco 1-SRW   del parametro
• Parametro 2-ThreadId   del thread che ha inizializzato il blocco SRW.
• Parametro 3-Address   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: 250NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare backtrace: sì

Rilascio acquisizione non corrispondente 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. $ kb : per ottenere l'analisi dello stack corrente. In questo caso il blocco SRW viene rilasciato usando l'API errata. $ dps Param3: per ottenere l'analisi dello stack di acquisizione del blocco SRW.

Informazioni visualizzate da Application Verifier

• Blocco 1-SRW   del parametro
• Parametro 2-ThreadId   del thread che ha acquisito il blocco SRW.
• Parametro 3-Address   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
• Stop ID: MISMATCHED_ACQUIRE_RELEA edizione Standard
• Codice di arresto: 250NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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. $ kb : per ottenere l'analisi dello stack corrente. È qui che il blocco SRW viene acquisito in modo ricorsivo. $ dps Param2 : per ottenere l'analisi dello stack per la prima acquisizione.

Informazioni visualizzate da Application Verifier

• Blocco 1-SRW   del parametro
• Parametro 2-Address   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
• Stop ID: RECURSIVE_ACQUIRE
• Codice di arresto: 250NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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. $ kb : per ottenere l'analisi dello stack corrente. Questo è il percorso in cui il thread viene chiuso o viene terminato. $ dps Param3: per ottenere l'analisi dello stack di acquisizione del blocco SRW.

Informazioni visualizzate da Application Verifier

• Blocco 1-SRW   del parametro
• Parametro 2-ThreadId   del thread che sta per uscire o terminare.
• Parametro 3-Address   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
• Stop ID: EXIT_THREAD_OWNS_LOCK
• Codice di arresto: 250NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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. $ kb : per ottenere l'analisi dello stack corrente. In questo caso, il thread rilascia il blocco SRW che non è stato acquisito. $ dps Param4 : per ottenere l'analisi dello stack di acquisizione del blocco SRW.

Informazioni visualizzate da Application Verifier

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

Informazioni aggiuntive

• Livello di test: SRWLock
• Stop ID: INVALID_OWNER
• Codice di arresto: 250NAN
• Gravità: Avviso
• Errore monouso: 
• Report degli errori:  Nessuno
• Log to file: yes
• Creare 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. $ kb : per ottenere l'analisi dello stack corrente. In questo caso la memoria viene liberata che contiene un blocco SRW attivo. $ dps Param4 : per ottenere l'analisi dello stack di acquisizione del blocco SRW.

Informazioni visualizzate da Application Verifier

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

Informazioni aggiuntive

• Livello di test: SRWLock
• Stop ID: IN_FR edizione Enterprise D_MEMORY
• Codice di arresto: 250NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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. $ kb : per ottenere l'analisi dello stack corrente. Questa è la posizione in cui la DLL viene scaricata che contiene un blocco SRW attivo. $ du Param2 : per trovare il nome della DLL da scaricare. $ dps Param4 : per ottenere l'analisi dello stack di acquisizione del blocco SRW.

Informazioni visualizzate da Application Verifier

• Blocco 1-SRW   del parametro
• 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-Address   dell'analisi dello stack di acquisizione. Usare l'indirizzo> dps <per vedere dove è stato acquisito il blocco SRW.

Informazioni aggiuntive

• Livello di test: SRWLock
• Stop ID: IN_UNLOADED_DLL
• Codice di arresto: 250NAN
• Gravità: Avviso
• Errore monouso: 
• Report degli errori:  Nessuno
• Log to file: yes
• Creare 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

• Indirizzo di base del parametro 1-Allocation  .
• Dimensione dell'area di 2   memoria del parametro.
• Parametro 3-Non   utilizzato.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Memoria
• Stop ID: INVALID_FR edizione Enterprise MEM
• Codice di arresto: 600NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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
• Stop ID: INVALID_ALLOCMEM
• Codice di arresto: 600NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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   per il mapping dell'indirizzo di base.
• Parametro 2-Puntatore   per visualizzare le dimensioni.
• Parametro 3-Non   utilizzato.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Memoria
• ID di arresto: INVALID_MAPVIEW
• Codice di arresto: 600NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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.
• Dimensione del blocco a 2  memoria .
• Parametro 3-Indirizzo   non valido.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Memoria
• Stop ID: PROBE_INVALID_ADDRESS
• Codice di arresto: 600NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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 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. 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 da/verso l'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.
• Dimensione del blocco a 2  memoria .
• Parametro 3-Indirizzo   della pagina di memoria libera.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Memoria
• Stop ID: PROBE_FR edizione Enterprise_MEM
• Codice di arresto: 600NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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.
• Dimensione del blocco a 2  memoria .
• Parametro 3-Indirizzo   della pagina di protezione.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Memoria
• Stop ID: PROBE_GUARD_PAGE
• Codice di arresto: 600NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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: int main (void) { PVOID p; p = malloc (1024); Usare (p); restituire 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); se (NULL == p)) { return -1; } Usare (p); restituire 0; } void Use (PVOID p) { // // p è sicuro da usare qui. } 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 del processo alla memoria testata. 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   utilizzato.
• Parametro 2-Non   utilizzato.
• Parametro 3-Non   utilizzato.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Memoria
• ID di arresto: PROBE_NULL
• Codice di arresto: 600NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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.
• Dimensione del blocco a 2  memoria .
• Parametro 3-Non   utilizzato.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Memoria
• ID di arresto: PROBE_INVALID_START_OR_SIZE
• Codice di arresto: 600NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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-DLL   indirizzo di base di memoria.
• Dimensione dell'intervallo di memoria 2  DLL  del parametro.
• Parametro 3-DLL   nome indirizzo. Usare du per eseguire il dump.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Memoria
• Stop ID: INVALID_DLL_RANGE
• Codice di arresto: 600NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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

• Indirizzo di base del parametro 1-Allocation  .
• Dimensione dell'area di 2   memoria del parametro.
• Parametro 3-Stack   low limit address.
• Parametro 4-Stack   high limit address.

Informazioni aggiuntive

• Livello di test: Memoria
• Stop ID: FR edizione Enterprise_THREAD_STACK_MEMORY
• Codice di arresto: 600NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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_RELEA edizione Standard. 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   utilizzato.

Informazioni aggiuntive

• Livello di test: Memoria
• Stop ID: INVALID_FR edizione Enterprise_TYPE
• Codice di arresto: 600NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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   utilizzato.
• Parametro 3-Non   utilizzato.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Memoria
• Stop ID: MEM_ALREADY_FR edizione Enterprise
• Codice di arresto: 600NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare backtrace: sì

Parametro Size non corretto per l'operazione VirtualFree (MEM_RELEA edizione Standard).

Probabile causa

Questo arresto viene generato se il verificatore dell'app rileva un virtualfree (MEM_RELEA edizione Standard) con un valore diverso da zero per il parametro dwSize. Quando si usa MEM_RELEA edizione Standard , 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

• Dimensione del parametro 1   non corretta usata dall'applicazione.
• Parametro 2-Previsto   dimensione corretta (0).
• Parametro 3-Non   utilizzato.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Memoria
• ID di arresto: INVALID_FR edizione Enterprise_SIZE
• Codice di arresto: 600NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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 di questa interruzione: $ 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

• Nome 1-DLL   del parametro (usare du per eseguire il dump).
• Record di eccezione del parametro 2  . Usare .exr per visualizzarlo.
• Parametro 3-Context   record. Usare .cxr per visualizzarlo.
• Descrittore dll del parametro 4-Verifier  

Informazioni aggiuntive

• Livello di test: Memoria
• ID di arresto: DLL_UNEXPECTED_EXCEPTION
• Codice di arresto: 600NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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 di questa interruzione: $ parameter1 potrebbe essere significativo per il tipo di eccezione. Ad esempio, un codice di eccezione C0000005 significa 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

• Codice di eccezione del parametro 1  .
• Record di eccezione del parametro 2  . Usare .exr per visualizzarlo.
• Parametro 3-Context   record. Usare .cxr per visualizzarlo.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Memoria
• Stop ID: THREAD_UNEXPECTED_EXCEPTION
• Codice di arresto: 600NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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_FR edizione Enterprise_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 di questa interruzione: $ parameter1 in genere sarà C0000005 e ciò significa Violazione di accesso; $ .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 al momento in cui è stata generata l'eccezione;

Informazioni visualizzate da Application Verifier

• Codice di eccezione del parametro 1  .
• Record di eccezione del parametro 2  . Usare .exr per visualizzarlo.
• Parametro 3-Context   record. Usare .cxr per visualizzarlo.
• Parametro 4-Non   usato

Informazioni aggiuntive

• Livello di test: Memoria
• Stop ID: PROBE_UNEXPECTED_EXCEPTION
• Codice di arresto: 600NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare backtrace: sì

Tentativo di reimpostare l'indirizzo NULL.

Probabile causa

Questo arresto viene generato se il verificatore dell'app rileva una chiamata VirtualFree (MEM_RE edizione Standard T) con un primo parametro NULL. MEM_RE edizione Standard T 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   utilizzato.
• Parametro 2-Non   utilizzato.
• Parametro 3-Non   utilizzato.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Memoria
• Stop ID: INVALID_MEM_RE edizione Standard T
• Codice di arresto: 600NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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 questa interruzione, 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 era effettivamente memoria allocata dallo stack.

Informazioni visualizzate da Application Verifier

• Indirizzo di base del parametro 1-Allocation  .
• Dimensione dell'area di 2   memoria del parametro.
• Parametro 3-Stack   low limit address.
• Parametro 4-Stack   high limit address.

Informazioni aggiuntive

• Livello di test: Memoria
• Stop ID: FR edizione Enterprise_THREAD_STACK_MEMORY_AS_HEAP
• Codice di arresto: 600NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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 questa interruzione, esaminare l'analisi dello stack corrente (kb) e cercare di capire perché la funzione denominata 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

• Indirizzo di base del parametro 1-Allocation  .
• Dimensione dell'area di 2   memoria del parametro.
• Parametro 3-Stack   low limit address.
• Parametro 4-Stack   high limit address.

Informazioni aggiuntive

• Livello di test: Memoria
• Stop ID: FR edizione Enterprise_THREAD_STACK_MEMORY_AS_MAP
• Codice di arresto: 600NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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. param1 è l'indirizzo non corretto usato e il colpevole si trova nell'analisi dello stack (visualizzarlo con kb).

Informazioni visualizzate da Application Verifier

• Parametro 1-Address  .
• Parametro 2-Non   utilizzato.
• Parametro 3-Non   utilizzato.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Memoria
• ID di arresto: INVALID_RESOURCE_ADDRESS
• Codice di arresto: 600NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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. param1 è l'indirizzo non corretto usato e il colpevole si trova nell'analisi dello stack (visualizzarlo con kb).

Informazioni visualizzate da Application Verifier

• Parametro 1-Address  .
• Parametro 2-Non   utilizzato.
• Parametro 3-Non   utilizzato.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Memoria
• Stop ID: INVALID_CRIT edizione Standard CT_ADDRESS
• Codice di arresto: 600NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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 di questa interruzione: $ u parameter2 - per rimuovere il codice colpevole $ .exr parameter3 - 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 a cui si accede con indirizzo 1  .
• Parametro 2 -  Codice che esegue l'accesso non valido.
• Record di eccezione 3   del parametro. Usare .exr per visualizzarlo.
• Parametro 4-Context   record. Usare .cxr per visualizzarlo.

Informazioni aggiuntive

• Livello di test: Memoria
• Stop ID: THREAD_UNEXPECTED_EXCEPTION_CODE
• Codice di arresto: 600NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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 di questa interruzione: $ .exr parameter3 - 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

• Indirizzo iniziale del parametro 1-Buffer  .
• Dimensione del buffer del parametro 2  .
• Record di eccezione 3   del parametro. Usare .exr per visualizzarlo.
• Parametro 4-Context   record. Usare .cxr per visualizzarlo.

Informazioni aggiuntive

• Livello di test: Memoria
• Stop ID: OUTBUFF_UNEXPECTED_EXCEPTION
• Codice di arresto: 600NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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 di questa interruzione: $ .exr parameter3 - 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.
• Handle del parametro 2-Heap  .
• Record di eccezione 3   del parametro. Usare .exr per visualizzarlo.
• Parametro 4-Context   record. Usare .cxr per visualizzarlo.

Informazioni aggiuntive

• Livello di test: Memoria
• Stop ID: SIZE_HEAP_UNEXPECTED_EXCEPTION
• Codice di arresto: 600NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare backtrace: sì

Liberare un blocco di memoria con indirizzo iniziale non valido.

Probabile causa

Questo arresto viene generato se il programma chiama VirtualFree (MEM_RELEA edizione Standard) 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 di questo 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   utilizzato.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Memoria
• ID di arresto: INVALID_FR edizione Enterprise MEM_START_ADDRESS
• Codice di arresto: 600NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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 di questo 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   utilizzato.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Memoria
• Stop ID: INVALID_UNMAPVIEW_START_ADDRESS
• Codice di arresto: 600NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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 di questa interruzione: $ 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

• Codice di eccezione del parametro 1  
• Record di eccezione del parametro 2  . Usare .exr per visualizzarlo
• Parametro 3-Context   record. Usare .cxr per visualizzarlo
• Parametro 4-Non   usato

Informazioni aggiuntive

• Livello di test: Memoria
• Stop ID: THREADPOOL_UNEXPECTED_EXCEPTION
• Codice di arresto: 600NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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 di questo arresto: $ u parameter2 - per annullare ilassembling del codice colpevole $ .exr parameter3 - 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 a cui si accede con indirizzo 1  
• Parametro 2 -  Codice che esegue l'accesso non valido
• Record di eccezione 3   del parametro. Usare .exr per visualizzarlo.
• Parametro 4-Context   record. Usare .cxr per visualizzarlo.

Informazioni aggiuntive

• Livello di test: Memoria
• Stop ID: THREADPOOL_UNEXPECTED_EXCEPTION_CODE
• Codice di arresto: 600NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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   utilizzato.
• Parametro 2-Non   utilizzato.
• Parametro 3-Non   utilizzato.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Memoria
• Stop ID: EXECUTABLE_HEAP
• Codice di arresto: 600NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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

• Protezione da 1   pagina del parametro specificata dal chiamante.
• Parametro 2-Non   utilizzato.
• Parametro 3-Non   utilizzato.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Memoria
• ID di arresto: EXECUTABLE_MEMORY
• Codice di arresto: 600NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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 di questa interruzione: $ 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

• Indice 1-TLS   del parametro
• Parametro 2-Address   del codice che ha allocato questo indice TLS.
• Parametro 3-DLL   nome indirizzo. Usare du per eseguire il dump.
• Parametro 4-DLL   indirizzo di base.

Informazioni aggiuntive

• Livello di test: TLS
• Stop ID: TLS_LEAK
• Codice di arresto: 350NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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

• Indirizzo 1-TEB   del parametro.
• Parametro 2-Previsto   indirizzo TEB.
• Parametro 3-ID   thread.
• Parametro 4-Expected thread ID.Parameter 4-Expected   thread ID.

Informazioni aggiuntive

• Livello di test: TLS
• ID di arresto: CORRUPTED_TLS
• Codice di arresto: 350NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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 coda T1: callback in coda ignorato/annullato T1: TlsFree T2: Esecuzioni di callback e chiamate TlsSetValue T1: scaricamento dll

Informazioni visualizzate da Application Verifier

• Indice 1-TLS   del parametro
• Parametro 2-Non   utilizzato.
• Parametro 3-Non   utilizzato.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: TLS
• Stop ID: INVALID_TLS_INDEX
• Codice di arresto: 350NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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

• Format: -  Threadpool thread (%x) in cui è stato eseguito callback (%p) ha una priorità di thread modificata (%i -> %i)
• Parametro 1-Funzione   di callback.
• Parametro 2-Context  .
• 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: Threadpool
• ID di arresto: INCONSISTENT_PRIORITY
• Codice di arresto: 700NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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

• Format: - threadpool thread (%x) in cui è stato eseguito il callback (%p) ha una maschera di affinità thread modificata (%p -> %p)
• Parametro 1-Funzione   di callback.
• Parametro 2-Context  .
• Parametro 3-Threadpool   Analisi dello stack di allocazione degli oggetti, usare dps per eseguire il dump.
• Affinità del parametro 4-Corrente  .

Informazioni aggiuntive

• Livello di test: Threadpool
• Stop ID: INCONSISTENT_AFFINITY_MASK
• Codice di arresto: 700NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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

• Format: - threadpool thread (%x) dopo l'esecuzione del callback (%p) contiene un messaggio di finestra in sospeso (%x: %x)
• Parametro 1-Funzione   di callback.
• Parametro 2-Context  .
• 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: Threadpool
• Stop ID: ORPHANED_THREAD_MESSAGE
• Codice di arresto: 700NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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) in cui è stato eseguito callback (%p) ha hwnd valido (%x: %s) che potrebbe ricevere messaggi
• Parametro 1-Funzione   di callback.
• Parametro 2-Context  .
• 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: Threadpool
• Stop ID: ORPHANED_THREAD_WINDOW
• Codice di arresto: 700NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare backtrace: sì

ExitThread() 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   di callback.
• Parametro 2-Context  .
• Parametro 3-Threadpool   Analisi dello stack di allocazione degli oggetti, usare dps per eseguire il dump.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Threadpool
• Stop ID: ILLEGAL_THREAD_EXIT
• Codice di arresto: 700NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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   di callback.
• Parametro 2-Context  .
• Parametro 3-Threadpool   Analisi dello stack di allocazione degli oggetti, usare dps per eseguire il dump.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Threadpool
• Stop ID: THREAD_IN_IMPERSONATION
• Codice di arresto: 700NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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   di callback.
• Parametro 2-Context  .
• Parametro 3-Threadpool   Analisi dello stack di allocazione degli oggetti, usare dps per eseguire il dump.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Threadpool
• STOP ID: PERSISTED_THREAD_N edizione Enterprise DED
• Codice di arresto: 700NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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   di callback.
• Parametro 2-Context  .
• Parametro 3-Threadpool   Analisi dello stack di allocazione degli oggetti, usare dps per eseguire il dump.
• Handle di transazione del parametro 4  .

Informazioni aggiuntive

• Livello di test: Threadpool
• Stop ID: DIRTY_TRANSACTION_CONTEXT
• Codice di arresto: 700NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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   di callback.
• Parametro 2-Context  .
• Parametro 3-Threadpool   Analisi dello stack di allocazione degli oggetti, usare dps per eseguire il dump.
• Conteggi delle chiamate con bilanciamento del parametro 4  .

Informazioni aggiuntive

• Livello di test: Threadpool
• Stop ID: DIRTY_COM_STATE
• Codice di arresto: 700NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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-Period   specificato.
• Parametro 2-Flags   specificato.
• Parametro 3-Non   utilizzato.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Threadpool
• Stop ID: INCONSISTENT_TIMER_PARAMS
• Codice di arresto: 700NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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   di callback.
• Parametro 2-Context  .
• Parametro 3-Threadpool   Analisi dello stack di allocazione degli oggetti, usare dps per eseguire il dump.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Threadpool
• Stop ID: LOADER_LOCK_HELD
• Codice di arresto: 700NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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   di callback.
• Parametro 2-Context  .
• Parametro 3-Threadpool   Analisi dello stack di allocazione degli oggetti, usare dps per eseguire il dump.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Threadpool
• Stop ID: PREFERRED_LANGUAGES_edizione Standard T
• Codice di arresto: 700NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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   di callback.
• Parametro 2-Context  .
• Parametro 3-Threadpool   Analisi dello stack di allocazione degli oggetti, usare dps per eseguire il dump.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Threadpool
• Stop ID: BACKGROUND_PRIORITY_edizione Standard T
• Codice di arresto: 700NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare 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 utilizzato.
• Parametro 2-Non   utilizzato.
• Parametro 3-Non   utilizzato.
• Parametro 4-Non   utilizzato.

Informazioni aggiuntive

• Livello di test: Threadpool
• ID di arresto: ILLEGAL_THREAD_TERMINATION
• Codice di arresto: 700NAN
• Gravità: Errore
• Errore monouso: 
• Segnalazione errori:  Interruzione
• Log to file: yes
• Creare backtrace: sì

Vedi anche

Application Verifier - Codici e definizioni di arresto

Application Verifier - Panoramica

Application Verifier - Funzionalità

Application Verifier - Testing Applications

Verifica applicazione - Test all'interno di Application Verifier

Application Verifier - Debug dell'applicazione verifier arresta

Application Verifier - Domande frequenti