Partager via

Simulation de ressources faibles

  • Article

Lorsque l’option Simulation de ressources faibles (appelée simulation aléatoire de ressources faibles dans Windows 8.1) est active, driver Verifier échoue à exécuter des instances aléatoires des allocations de mémoire du pilote, comme cela peut se produire si le pilote s’exécute sur un ordinateur avec une mémoire insuffisante. Cela teste la capacité du pilote à répondre correctement à une mémoire insuffisante et à d’autres conditions de faible ressource.

Le test Low Resources Simulation échoue aux allocations demandées par les appels à plusieurs fonctions différentes, notamment ExAllocatePoolWithXXX, MmGetSystemAddressForMdlSafe, MmProbeAndLockPages, MmMapLockedPagesSpecifyCache et MmMapIoSpace.

À compter de Windows Vista, le test Low Resource Simulation injecte également des erreurs dans IoAllocateIrp, IoAllocateMdl, IoAllocateWorkItem, IoAllocateErrorLogEntry, MmAllocateContiguousMemory, MmAllocateContiguousMemorySpecifyCache, MmAllocatePagesForMdl et MmAllocatePagesForMdlEx. En outre, à compter de Windows Vista, lorsque la simulation de ressources faibles est activée, les appels à KeWaitForMultipleObjects ou KeWaitForSingleObject avec le paramètre Alertable défini sur TRUE peuvent retourner STATUS_ALERTED lors de l’exécution dans le contexte de processus non privilégiés. Cela simule une alerte de thread possible provenant d’un autre thread dans la même application non privilégiée.

Le test Low Resource Simulation injecte également des erreurs dans les fonctions GDI suivantes : EngAllocMem, EngAllocUserMem, EngCreateBitmap, EngCreateDeviceSurface, EngCreateDeviceBitmap, EngCreatePalette, EngCreateClip, EngCreatePath, EngCreateWnd, EngCreateDriverObj, BRUSHOBJ_pvAllocRbrush et CLIPOBJ_ppoGetPath.

Dans Windows 7 et versions ultérieures du système d’exploitation Windows, l’option Simulation de ressources faibles prend en charge la mémoire allouée à l’aide des API de noyau suivantes :

À compter de Windows 8.1, l’option Simulation de ressources faibles échoue également aux allocations demandées par les appels à MmAllocateNodePagesForMdlEx. En outre, pour certaines fonctions, Driver Verifier remplit désormais la mémoire allouée avec un modèle aléatoire. Mais uniquement dans les situations où la fonction retourne une mémoire non initialisée. Ces fonctions incluent :

Paramètres personnalisés pour la simulation de faibles ressources

Sur Windows Vista et les versions ultérieures de Windows, vous pouvez spécifier les paramètres personnalisés suivants.

  • Probabilité qu’une allocation donnée échoue. La valeur par défaut est 6 %.

  • Applications affectées. Ce paramètre limite les allocations d’échec injectées aux applications spécifiées. Par défaut, toutes les allocations sont affectées.

  • Balises de pool affectées. Ce paramètre limite les erreurs injectées aux allocations avec les balises de pool spécifiées. Par défaut, toutes les allocations sont affectées.

  • Délai (en minutes) avant l’échec des allocations. Ce délai permet au système de démarrer et de se stabiliser avant que les erreurs ne soient injectées. La valeur par défaut est de huit minutes.

Sur les systèmes d’exploitation antérieurs à Windows Vista, vous ne pouvez pas personnaliser ces paramètres. Le système d’exploitation utilise les valeurs par défaut.

Simulation de ressources faibles sans redémarrage

Vous pouvez activer la simulation de ressources faibles sur Windows 2000 et versions ultérieures de Windows sans redémarrer l’ordinateur à l’aide du paramètre /volatile . Les paramètres entrent en vigueur immédiatement, mais sont perdus si vous arrêtez ou redémarrez l’ordinateur.

Vous pouvez également stocker les paramètres de simulation de ressources faibles dans le Registre en omettant le paramètre /volatile . Ces paramètres ne sont effectifs que lorsque vous redémarrez l’ordinateur, mais ils restent effectifs jusqu’à ce que vous les modifiez.

Activation de cette option

Vous pouvez activer l’option Simulation de ressources faibles pour un ou plusieurs pilotes à l’aide du Gestionnaire du vérificateur de pilotes ou de la ligne de commande Verifier.exe. Pour plus d’informations, consultez Sélection des options du vérificateur de pilote.

  • Sur la ligne de commande

    Sur la ligne de commande, l’option Simulation de ressources faibles est représentée par Bit 2 (0x4). Pour activer la simulation de ressources faibles, utilisez une valeur d’indicateur de 0x4 ou ajoutez 0x4 à la valeur des indicateurs. Par exemple :

    verifier /flags 0x4 /driver MyDriver.sys

    L’option sera active après le prochain démarrage.

    Sur Windows Vista et les versions ultérieures de Windows, vous pouvez utiliser le paramètre /faults ou une valeur d’indicateur de 0x4 pour activer la simulation de ressources faibles. Pour modifier les paramètres de la simulation à faibles ressources, vous devez utiliser /faults. Par exemple :

    verifier /faults /driver MyDriver.sys

    Sur Windows 2000 et versions ultérieures de Windows, vous pouvez également activer et désactiver La simulation de ressources faibles sans redémarrer l’ordinateur en ajoutant le paramètre /volatile à la commande. Par exemple :

    verifier /volatile /flags 0x4 /adddriver MyDriver.sys

    Ce paramètre prend effet immédiatement, mais il est perdu lorsque vous arrêtez ou redémarrez l’ordinateur. Pour plus d’informations, consultez Utilisation de paramètres volatiles.

    Sur Windows Vista, vous pouvez utiliser le paramètre /faults pour représenter la simulation de ressources faibles avec le paramètre /volatile afin de représenter un paramètre qui est effectif sans redémarrage. La modification du paramètre s’affiche. Par exemple :

    0>  verifier /volatile /faults /adddriver MyDriver.sys
New Low Resources Simulation options:

- Use default fault injection probability.
- Allocations using any pool tag can be failed.
- Simulate low resources conditions in any application.

The new settings are in effect until you restart this computer
or change them again.

  • Utilisation du Gestionnaire de vérificateur de pilotes

    1. Démarrez le Gestionnaire de vérificateur de pilotes. Tapez Vérificateur dans une fenêtre d’invite de commandes.
    2. Sélectionnez Créer des paramètres personnalisés (pour les développeurs de code), puis cliquez sur Suivant.
    3. Sélectionnez Sélectionner des paramètres individuels dans une liste complète.
    4. Sélectionnez Simulation de ressources faibles.

Personnalisation des paramètres (Windows Vista et versions ultérieures)

À partir de Windows Vista, vous pouvez modifier les paramètres par défaut pour les propriétés de délai, de probabilité, d’applications et d’étiquettes de pool de l’option Simulation de ressources faibles. Vous pouvez modifier ces paramètres à l’aide du Gestionnaire du vérificateur de pilotes ou de la ligne de commande Verifier.exe. Pour plus d’informations, consultez Sélection des options du vérificateur de pilote.

Sur la ligne de commande, la syntaxe de ces paramètres est la suivante :

vérificateur [/volatile] /faults[Probabilité|PoolTags|Applications|DelayMins][/driverList|]

Note Les paramètres personnalisés doivent apparaître dans l’ordre affiché. Si vous omettez une valeur, tapez des guillemets pour qu’elle conserve sa place.

Sous-paramètres

  • /faults

    Active l’option Simulation de faibles ressources dans Driver Verifier. (Vous ne pouvez pas utiliser /flags 0x4 avec les sous-paramètres de paramètre personnalisés.)

  • Probabilité

    Spécifie la probabilité que driver Verifier échoue une allocation donnée. Tapez un nombre (au format décimal ou hexadécimal) pour représenter le nombre de chances dans 10 000 que Driver Verifier échoue à l’allocation. La valeur par défaut, 600, signifie 600/10000, ou 6 %.

  • PoolTags

    Limite les allocations que le vérificateur de pilotes peut échouer aux allocations avec les balises de pool spécifiées. Vous pouvez utiliser un caractère générique (*) pour représenter plusieurs balises de pool. Pour répertorier plusieurs balises de pool, séparez les balises par des espaces. Par défaut, toutes les allocations peuvent échouer.

  • Applications

    Limite les allocations que le vérificateur de pilotes peut échouer aux allocations pour le programme spécifié. Tapez le nom d’un fichier exécutable. Pour répertorier les programmes, séparez les noms des programmes par des espaces. Par défaut, toutes les allocations peuvent échouer.

  • DelayMins

    Spécifie le nombre de minutes après le démarrage pendant lesquelles driver Verifier n’échoue pas intentionnellement aux allocations. Ce délai permet aux pilotes de charger et au système de se stabiliser avant le début du test. Tapez un nombre (au format décimal ou hexadécimal). La valeur par défaut est 8 (minutes).

Par exemple, la commande suivante active la simulation de ressources faibles avec une probabilité de 10 % (1000/10 000) et un délai de cinq minutes pour les balises de pool, Tag1 et Fred, et l’application, Notepad.exe.

verifier /faults 1000 "Tag1 Fred" Notepad.exe 5

La commande suivante active Low Resources Simulation avec les valeurs par défaut, sauf qu’elle étend le délai à 10 minutes.

verifier /faults "" "" "" 0xa

Utilisation du Gestionnaire du vérificateur de pilotes

  1. Démarrez le Gestionnaire du vérificateur de pilotes. Tapez Vérificateur dans une fenêtre d’invite de commandes.

  2. Sélectionnez Créer des paramètres personnalisés (pour les développeurs de code), puis cliquez sur Suivant.

  3. Sélectionnez Sélectionner des paramètres individuels dans une liste complète.

  4. Sélectionnez Simulation de ressources faibles, puis cliquez sur Suivant.

  5. Modifiez les paramètres des propriétés de délai, de probabilité, d’applications et de balises de pool selon vos besoins.

Affichage des résultats

Vous pouvez surveiller le nombre de fois où le vérificateur de pilotes échoue intentionnellement aux allocations de ressources en affichant le compteur global Erreurs injectées du vérificateur de pilotes. Ce compteur affiche le nombre total d’allocations de ressources que driver Verifier a délibérément échoué depuis le dernier démarrage.

Vous pouvez afficher ce compteur dans un fichier journal du vérificateur de pilote (/log), sur la ligne de commande (/query) ou dans le Gestionnaire du vérificateur de pilote. Dans Windows 2000, pour afficher les compteurs globaux, sélectionnez l’onglet Compteurs globaux . Dans les versions ultérieures de Windows, sélectionnez Afficher les informations sur la tâche pilotes actuellement vérifiée , puis appuyez deux fois sur Suivant . Pour plus d’informations, consultez Surveillance des compteurs globaux.

Vous pouvez également afficher le nombre d’allocations ayant échoué intentionnellement et le nombre d’allocations totales (pour calculer la probabilité) à l’aide de l’extension de débogueur !verifier. L’exemple suivant montre un exemple de la sortie !verifier .

Dans cet exemple, injecter des échecs aléatoires de l’API à faible ressource indique que la simulation de faibles ressources est activée. Les allocations de ressources ont échoué délibérément représente le nombre d’allocations ayant échoué intentionnellement et les allocations de pool tentées représentent le nombre total d’allocations.

!verifier

Verify Level 5 ... enabled options are:
        Special pool
        Inject random low-resource API failures

Summary of All Verifier Statistics

RaiseIrqls                             0x2c671f
AcquireSpinLocks                       0xca1a02
Synch Executions                       0x10a623
Trims                                  0x0

Pool Allocations Attempted             0x862e0e
Pool Allocations Succeeded             0x8626e3
Pool Allocations Succeeded SpecialPool 0x768060
Pool Allocations With NO TAG           0x0
Pool Allocations Failed                0x34f
Resource Allocations Failed Deliberately   0x3f5

Pour afficher les traces de pile pour les allocations les plus récentes ayant échoué par driver Verifier, utilisez !verifier 4 dans le débogueur du noyau.

L’exemple suivant montre un exemple de sortie de !verifier 4. Par défaut, !verifier 4 affiche les traces de pile des quatre dernières allocations ayant échoué, mais vous pouvez utiliser son paramètre Quantity pour augmenter le nombre de traces de pile affichées. Par exemple, !verifier 0x80 affiche les 128 dernières allocations ayant échoué.

Dans cet exemple, notez que le vérificateur a intercepté et remplacé l’appel du pilote à ExAllocatePoolWithTag. L’une des causes les plus courantes d’incidents de pilote se produit lorsqu’un pilote tente d’allouer de la mémoire, puis utilise le pointeur retourné par la fonction d’allocation avant de vérifier qu’il n’est pas NULL.

kd> !verifier 4
Resource fault injection history:
Tracker @ 8354A000 (# entries: 80, size: 80, depth: 8)

Entry @ 8354B258 (index 75)

    Thread: C2638220

    816760CB nt!VerifierExAllocatePoolWithTag+0x49
    A4720443 win32k!bDeleteAllFlEntry+0x15d
    A4720AB0 win32k!GreEnableEUDC+0x70
    A47218FA win32k!CleanUpEUDC+0x37
    A473998E win32k!GdiMultiUserFontCleanup+0x5
    815AEACC nt!MiDereferenceSession+0x74
    8146D3B4 nt!MmCleanProcessAddressSpace+0x112
    815DF739 nt!PspExitThread+0x603

Entry @ 8354B230 (index 74)

    Thread: 8436D770

    816760CB nt!VerifierExAllocatePoolWithTag+0x49
    A462141C win32k!Win32AllocPool+0x13
    A4725F94 win32k!StubGdiAlloc+0x10

L’expérience avec le test de simulation de ressources faibles révèle que la plupart des accidents de pilote sont causés par l’allocation ayant échoué le plus récemment. Dans l’exemple ci-dessus, le plantage était sur le chemin de win32k! GreEnableEUDC. Examinez le code dans le chemin de l’allocation pour trouver la cause de l’incident.

Pour plus d’informations sur !verifier, consultez la documentation Outils de débogage pour Windows .

Pour afficher les paramètres du Registre sur la ligne de commande, utilisez l’option /querysettings . Par exemple :

C:\>verifier /querysettings
Special pool: Disabled
Pool tracking: Disabled
Force IRQL checking: Disabled
I/O verification: Disabled
Enhanced I/O verification: Disabled
Deadlock detection: Disabled
DMA checking: Disabled
Security checks: Disabled
Force pending I/O requests: Disabled
Low resources simulation: Enabled
IRP Logging: Disabled
Miscellaneous checks: Disabled

Low Resources Simulation options:

- Fault injection probability: 1/10000.
- Fail only allocations using pool tags: Tag1 Tag2.
- Simulate low resources conditions only in applications: test1.exe test2.exe.
- Boot time delay: 2 minutes.

Verified drivers:

blah.sys