Compartilhar via

Verificação de bugs 0xD1: DRIVER_IRQL_NOT_LESS_OR_EQUAL

  • Artigo

A verificação de bugs DRIVER_IRQL_NOT_LESS_OR_EQUAL tem um valor de 0x000000D1. Isso indica que um driver no modo kernel tentou acessar a memória paginável enquanto o IRQL do processo estava muito alto.

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.

DRIVER_IRQL_NOT_LESS_OR_EQUAL parâmetros

Parâmetro Descrição

1

Memória referenciada.

2

IRQL no momento da referência.

3
  • 0 - Leitura
  • 1 - Gravar
  • 2 - Executar
  • 8 - Executar

4

Aborde essa memória referenciada. Use ln (lista de símbolos mais próximos) neste endereço para ver o nome da função.

Causa

A determinação da causa requer o depurador do Windows, experiência em programação e acesso ao código-fonte para o módulo com falha.

Normalmente, quando esse erro ocorre, um driver tentou acessar um endereço que é paginável (ou que é completamente inválido) enquanto o nível de solicitação de interrupção (IRQL) estava muito alto. Isso pode ser causado por:

  • Desreferenciar um ponteiro inválido (como um ponteiro NULO ou liberado) durante a execução no DISPATCH_LEVEL ou acima.

  • Acessar dados paginável no DISPATCH_LEVEL ou acima.

  • Executar um código paginável no DISPATCH_LEVEL ou acima.

Se um driver responsável pelo erro puder ser identificado, seu nome será mostrado na tela azul e armazenado na memória no local (PUNICODE_STRING) KiBugCheckDriver. Você pode usar dx (exibe a expressão do modelo de objeto do depurador), um comando do depurador, para exibir: dx KiBugCheckDriver.

Essa verificação de bugs geralmente é causada por drivers que usaram endereços de memória impróprios.

As possíveis causas para a falha de página incluem os seguintes eventos:

  • A função foi marcada como paginável e estava sendo executada em um IRQL elevado (que inclui a obtenção de um bloqueio).

  • A chamada de função foi feita para uma função em outro driver e esse driver foi descarregado.

  • A função foi chamada usando um ponteiro de função que era um ponteiro inválido.

Para obter mais informações sobre IRQLs do Windows, consulte Windows Internals 7ª edição - Parte 1 de Pavel Yosifovich, Mark E. Russinovich, David A. Solomon e Alex Ionescu.

Resolução

Se o problema for causado pelo driver que você está desenvolvendo, certifique-se de que a função que estava sendo executada no momento da verificação de bugs seja:

  • Não marcado como paginável
  • Não chama nenhuma outra função embutida que possa ser paginada.

A extensão do depurador !analyze exibe informações sobre a verificação de bugs e pode ser útil para determinar a causa raiz. O exemplo a seguir é a saída de !analyze.

DRIVER_IRQL_NOT_LESS_OR_EQUAL (d1)
An attempt was made to access a pageable (or completely invalid) address at an
interrupt request level (IRQL) that is too high.  This is usually
caused by drivers using improper addresses.
If kernel debugger is available get stack backtrace.
Arguments:
Arg1: fffff808add27150, memory referenced
Arg2: 0000000000000002, IRQL
Arg3: 0000000000000000, value 0 = read operation, 1 = write operation
Arg4: fffff808adc386a6, address which referenced memory

Se um driver responsável pelo erro puder ser identificado, seu nome será mostrado na tela azul e armazenado na memória no local (PUNICODE_STRING) KiBugCheckDriver. Você pode usar dx (exibe a expressão do modelo de objeto do depurador), um comando do depurador, para exibir: dx KiBugCheckDriver.

0: kd> dx KiBugCheckDriver
KiBugCheckDriver                 : 0xffffc6092de892c8 : "Wdf01000.sys" [Type: _UNICODE_STRING *]

Se um quadro de interceptação estiver disponível no arquivo de despejo, use o comando .trap para definir seu contexto para o endereço fornecido.

Para iniciar a depuração desse tipo de verificação de bug, examine o rastreamento de pilha usando os comandos k, kb, kc, kd, kp, kP, kv (exibir backtrace da pilha).

No depurador, execute o comando !irql para exibir informações sobre o IRQL de um processador no computador de destino antes da interrupção do depurador. Por exemplo:

0: kd> !irql
Debugger saved IRQL for processor 0x0 -- 2 (DISPATCH_LEVEL)

Na maioria dos casos desse tipo de verificação de bugs, o problema não é o nível de IRQL, mas sim a memória que está sendo acessada.

Como essa verificação de bugs geralmente é causada por drivers que usaram endereços de memória impróprios, use os parâmetros 1, 3 e 4 para investigar mais.

Use ln (lista de símbolos mais próximos) com o parâmetro 4 para ver o nome da função que foi chamada. Também examine a saída !analyze para verificar se o código de falha foi identificado.

Use !pool no endereço de parâmetro 1 para ver se ele é um pool paginado. Use !address e o comando avançado !pte para saber mais sobre essa área da memória.

Use os comandos de memória de exibição para examinar a memória referenciada no comando no parâmetro 1.

Use os comandos u, ub, uu (desmontar) para examinar o código no endereço que fez referência à memória no parâmetro 4.

Use o comando lm t n para listar os módulos que estão carregados na memória. Use !memusage e examine o estado geral da memória do sistema.

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.

Comentários

Se você não estiver equipado para usar o depurador do Windows para resolver esse problema, use algumas técnicas básicas de solução de problemas.

  • Verifique se há mensagens de erro adicionais no log do sistema no Visualizador de Eventos que possam ajudar a identificar o dispositivo ou o driver que está causando a verificação de bugs.

  • Se um driver for identificado na mensagem de verificação de bugs, desabilite o driver ou verifique com o fabricante se há atualizações de driver.

  • Confirme se o novo hardware instalado é compatível com a versão instalada do Windows. Por exemplo, você pode obter informações sobre o hardware necessário em Especificações do Windows 10.

Para obter mais informações gerais sobre solução de problemas, consulte Analisar dados de tela azul de verificação de bugs.