Verificação de bugs 0xA: IRQL_NOT_LESS_OR_EQUAL
A verificação de bugs IRQL_NOT_LESS_OR_EQUAL tem um valor de 0x0000000A. Essa verificação de bugs indica que o Microsoft Windows ou um driver no modo kernel acessou a memória paginada em um endereço inválido enquanto estava em um nível de solicitação de interrupção (IRQL) elevado. A causa geralmente é um ponteiro incorreto ou um problema de paginação.
Importante
Este artigo é para programadores. Se você for um cliente que recebeu um código de erro de tela azul enquanto estava usando o computador, confira Solucionar problemas de erros de tela azul.
IRQL_NOT_LESS_OR_EQUAL parâmetros
| Parâmetro | Descrição |
|---|---|
| 1 | O endereço de memória virtual que não pôde ser acessado. Use !pool neste endereço para ver se é um pool paginado. Outros comandos que podem ser úteis na coleta de informações sobre a falha são !pte, !address e ln (lista de símbolos mais próximos).. |
| 2 | IRQL no momento da falha. Valores: 2 - O IRQL era DISPATCH_LEVEL no momento da falha. |
| 3 | Campo de bits que descreve a operação que causou a falha. Observe que o bit 3 só está disponível em chipsets que suportam esse nível de relatório. Valores de bit 0: 0 - Operação de leitura 1 - Operação de gravação Valores de bit 3: 0 - Não é uma operação de execução 1 - Executar operação Valores combinados do bit 0 e do bit 3: 0x0 - Falha ao tentar LER a partir do endereço no parâmetro 1 0x1 - Falha ao tentar GRAVAR no endereço no parâmetro 1 0x8 - Falha ao tentar EXECUTAR código a partir do endereço no parâmetro 1 Esse valor é causado por:
|
| 4 | O ponteiro de instrução no momento da falha. Use o comando ln (lista de símbolos mais próximos) neste endereço para ver o nome da função. |
Causa
Essa verificação de bugs é causada por drivers de dispositivo no modo kernel que usam endereços impróprios.
Essa verificação de bugs indica que foi feita uma tentativa de acessar um endereço inválido enquanto estava em um nível de solicitação de interrupção (IRQL) elevado. A causa é um ponteiro de memória inválido ou um problema de paginação com o código do driver do dispositivo.
As diretrizes gerais que você pode usar para categorizar o tipo de erro de codificação que causou a verificação de bugs são as seguintes:
Se o parâmetro 1 for menor que 0x1000, o problema provavelmente será uma desreferência de ponteiro NULL.
Se !pool relatar que o parâmetro 1 é pool paginado (ou outros tipos de memória paginável), o IRQL é muito alto para acessar esses dados. Execute em um IRQL inferior ou aloque os dados no pool não paginado.
Se o parâmetro 3 indicar que a verificação de bugs foi uma tentativa de executar código paginável, então o IRQL é muito alto para chamar essa função. Execute em um IRQL inferior ou não marque o código como paginável.
Pode ser um ponteiro ruim causado por uso após liberação ou inversão de bits. Investigue a validade do parâmetro 1 com !pte, !address e ln (lista de símbolos mais próximos)
Resolução
Se um depurador de kernel estiver disponível, obtenha um rastreamento de pilha. Comece executando a extensão de depuração !analyze para exibir informações sobre a verificação de bugs. A extensão !analyze pode ser útil para determinar a causa raiz. Em seguida, insira um dos comandos k* (exibir backtrace de pilha) para exibir a pilha de chamadas.
Coletar informações
Examine o nome do driver se ele estiver listado na tela azul.
Verifique o log do sistema no Visualizador de Eventos para ver se há outras mensagens de erro que possam ajudar a identificar o dispositivo ou driver que está causando o erro. Procure erros críticos no log do sistema que ocorreram no mesmo período de tempo da tela azul.
Driver Verifier
O verificador de driver é uma ferramenta que é executada em tempo real para examinar o comportamento dos drivers. Por exemplo, o Verificador de Driver verifica o uso de recursos de memória, como pools de memória. Se identificar erros na execução do código do driver, ele cria de forma proativa uma exceção para permitir que essa parte do código do driver seja examinada mais detalhadamente. O Gerenciador de Verificação de Driver é integrado ao Windows e está disponível em todos os PCs com Windows.
Para iniciar o Gerenciador de Verificação de Driver, digite verifier em um prompt de comando. Você pode configurar quais drivers verificar. O código que verifica os drivers adiciona sobrecarga à medida que é executado, portanto, tente verificar o menor número possível de drivers. Para obter mais informações, consulte Driver Verifier.
O código a seguir mostra um exemplo de depuração:
kd> .bugcheck [Lists bug check data.]
Bugcheck code 0000000a
Arguments 00000000 0000001c 00000000 00000000
kd> kb [Lists the stack trace.]
ChildEBP RetAddr Args to Child
8013ed5c 801263ba 00000000 00000000 e12ab000 NT!_DbgBreakPoint
8013eecc 801389ee 0000000a 00000000 0000001c NT!_KeBugCheckEx+0x194
8013eecc 00000000 0000000a 00000000 0000001c NT!_KiTrap0E+0x256
8013ed5c 801263ba 00000000 00000000 e12ab000
8013ef64 00000246 fe551aa1 ff690268 00000002 NT!_KeBugCheckEx+0x194
kd> kv [Lists the trap frames.]
ChildEBP RetAddr Args to Child
8013ed5c 801263ba 00000000 00000000 e12ab000 NT!_DbgBreakPoint (FPO: [0,0,0])
8013eecc 801389ee 0000000a 00000000 0000001c NT!_KeBugCheckEx+0x194
8013eecc 00000000 0000000a 00000000 0000001c NT!_KiTrap0E+0x256 (FPO: [0,0] TrapFrame @ 8013eee8)
8013ed5c 801263ba 00000000 00000000 e12ab000
8013ef64 00000246 fe551aa1 ff690268 00000002 NT!_KeBugCheckEx+0x194
kd> .trap 8013eee8 [Gets the registers for the trap frame at the time of the fault.]
eax=dec80201 ebx=ffdff420 ecx=8013c71c edx=000003f8 esi=00000000 edi=87038e10
eip=00000000 esp=8013ef5c ebp=8013ef64 iopl=0 nv up ei pl nz na pe nc
cs=0008 ss=0010 ds=0023 es=0023 fs=0030 gs=0000 efl=00010202
ErrCode = 00000000
00000000 ??????????????? [The current instruction pointer is NULL.]
kd> kb [Gives the stack trace before the fault.]
ChildEBP RetAddr Args to Child
8013ef68 fe551aa1 ff690268 00000002 fe5620d2 NT!_DbgBreakPoint
8013ef74 fe5620d2 fe5620da ff690268 80404690
NDIS!_EthFilterIndicateReceiveComplete+0x31
8013ef64 00000246 fe551aa1 ff690268 00000002 elnkii!_ElnkiiRcvInterruptDpc+0x1d0
Comentários
O erro que gera essa verificação de bugs geralmente ocorre após a instalação de um driver de dispositivo, serviço do sistema ou BIOS com defeito.
Se você encontrar 0xA de verificação de bugs ao atualizar para uma versão mais recente do Windows, o erro pode ser causado por um driver de dispositivo, um serviço do sistema, um antivírus ou uma ferramenta de backup incompatível com a nova versão.
Resolução de um problema de hardware defeituoso: se o hardware foi adicionado ao sistema recentemente, remova-o para ver se o erro se repete. Se o hardware existente tiver falhado, remova ou substitua o componente defeituoso. Executar diagnósticos de hardware fornecidos pelo fabricante do sistema. Para obter detalhes sobre esses procedimentos, consulte o manual do proprietário do seu computador.
Resolução de um problema de serviço do sistema defeituoso: desative o serviço e confirme se isso resolve o erro. Em caso afirmativo, entre em contato com o fabricante do serviço do sistema sobre uma possível atualização. Se o erro ocorrer durante a inicialização do sistema, investigue as opções de reparo do Windows. Para obter mais informações, consulte Opções de recuperação no Windows 10.
Resolução de um problema de software antivírus: desative o programa e confirme se isso resolve o erro. Se isso acontecer, entre em contato com o fabricante do programa para obter uma possível atualização.
Para obter informações gerais sobre como solucionar problemas de verificações de bugs, consulte Analisar dados de tela azul de verificação de bugs.