Partager via

Fonction NtQuerySystemInformation (winternl.h)

[NtQuerySystemInformation peut être modifié ou indisponible dans les futures versions de Windows. Les applications doivent utiliser les autres fonctions répertoriées dans cette rubrique.]

Récupère les informations système spécifiées.

Syntaxe

__kernel_entry NTSTATUS NtQuerySystemInformation(
  [in]            SYSTEM_INFORMATION_CLASS SystemInformationClass,
  [in, out]       PVOID                    SystemInformation,
  [in]            ULONG                    SystemInformationLength,
  [out, optional] PULONG                   ReturnLength
);

Paramètres

[in] SystemInformationClass

Une des valeurs énumérées dans SYSTEM_INFORMATION_CLASS, qui indiquent le type d’informations système à récupérer. Il s’agit notamment des valeurs suivantes.

SystemBasicInformation

Retourne le nombre de processeurs dans le système dans une structure SYSTEM_BASIC_INFORMATION . Utilisez plutôt la fonction GetSystemInfo .

SystemCodeIntegrityInformation

Retourne une structure SYSTEM_CODEINTEGRITY_INFORMATION qui peut être utilisée pour déterminer les options appliquées par l’intégrité du code sur le système.

SystemExceptionInformation

Retourne une structure de SYSTEM_EXCEPTION_INFORMATION opaque qui peut être utilisée pour générer une valeur initiale imprévisible pour un générateur de nombres aléatoires. Utilisez plutôt la fonction CryptGenRandom .

SystemInterruptInformation

Retourne une structure SYSTEM_INTERRUPT_INFORMATION opaque qui peut être utilisée pour générer une valeur initiale imprévisible pour un générateur de nombres aléatoires. Utilisez plutôt la fonction CryptGenRandom .

SystemKernelVaShadowInformation

Retourne une structure SYSTEM_KERNEL_VA_SHADOW_INFORMATION qui peut être utilisée pour déterminer les paramètres de contrôle de spéculation pour les attaques impliquant des chargements de cache de données non autorisés (par exemple CVE-2017-5754).

SystemLeapSecondInformation

Retourne une structure de SYSTEM_LEAP_SECOND_INFORMATION opaque qui peut être utilisée pour activer ou désactiver les secondes de saut à l’échelle du système. Ce paramètre persiste même après un redémarrage du système.

SystemLookasideInformation

Retourne une structure SYSTEM_LOOKASIDE_INFORMATION opaque qui peut être utilisée pour générer une valeur initiale imprévisible pour un générateur de nombres aléatoires. Utilisez plutôt la fonction CryptGenRandom .

SystemPerformanceInformation

Retourne une structure de SYSTEM_PERFORMANCE_INFORMATION opaque qui peut être utilisée pour générer une valeur initiale imprévisible pour un générateur de nombres aléatoires. Utilisez plutôt la fonction CryptGenRandom .

SystemPolicyInformation

Retourne des informations de stratégie dans une structure SYSTEM_POLICY_INFORMATION . Utilisez plutôt la fonction SLGetWindowsInformation pour obtenir des informations de stratégie.

SystemProcessInformation

Retourne un tableau de structures SYSTEM_PROCESS_INFORMATION , une pour chaque processus s’exécutant dans le système.

Ces structures contiennent des informations sur l’utilisation des ressources de chaque processus, notamment le nombre de threads et de handles utilisés par le processus, l’utilisation maximale des fichiers de pages et le nombre de pages mémoire allouées par le processus.

Note

Dans la mesure du possible, SystemBasicProcessInformation doit être utilisé à la place, car il est plus rapide, consomme moins de mémoire et n’a pas besoin de synchroniser les données de minutage (éliminant les sorties de veille du processeur).

SystemBasicProcessInformation

Disponible à partir de Windows 11 version 26100.4770

Retourne un tableau de structures SYSTEM_BASICPROCESS_INFORMATION , une pour chaque processus en cours d’exécution dans le système.

Ces structures contiennent des informations de base sur chaque processus, y compris le nom du processus, son ID de processus et un numéro de séquence unique.

Note

SYSTEM_BASICPROCESS_INFORMATION est identique à SYSTEM_PROCESS_INFORMATION à l’exception du membre SequenceNumber , qui est une valeur unique affectée à chaque processus et utilisée pour détecter la réutilisation UniqueProcessId (au lieu du processus CreateTime).

typedef struct _SYSTEM_BASICPROCESS_INFORMATION {
    ULONG NextEntryOffset;
    HANDLE UniqueProcessId;
    HANDLE InheritedFromUniqueProcessId;
    ULONG64 SequenceNumber;
    UNICODE_STRING ImageName;
} SYSTEM_BASICPROCESS_INFORMATION, *PSYSTEM_BASICPROCESS_INFORMATION;

Ses membres sont identiques à ceux de SYSTEM_PROCESS_INFORMATION, à l’exception de SequenceNumber, qui est un nombre unique affecté à chaque processus qui peut être utilisé pour détecter la réutilisation UniqueProcessId au lieu du processus CreateTime.

SystemProcessorPerformanceInformation

Retourne un tableau de structures SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION , un pour chaque processeur installé dans le système.

SystemQueryPerformanceCounterInformation

Retourne une structure SYSTEM_QUERY_PERFORMANCE_COUNTER_INFORMATION qui peut être utilisée pour déterminer si le système nécessite une transition de noyau pour récupérer les informations de compteur de performances haute résolution via un appel de fonction QueryPerformanceCounter .

SystemRegistryQuotaInformation

Retourne une structure SYSTEM_REGISTRY_QUOTA_INFORMATION .

SystemSpeculationControlInformation

Retourne une structure SYSTEM_SPECULATION_CONTROL_INFORMATION qui peut être utilisée pour déterminer les paramètres de contrôle de spéculation pour les attaques impliquant l’injection de cible de branche (par exemple CVE-2017-5715).

Chaque structure SYSTEM_SPECULATION_CONTROL_INFORMATION a la disposition suivante :

typedef struct _SYSTEM_SPECULATION_CONTROL_INFORMATION {
    struct {
        ULONG BpbEnabled : 1;
        ULONG BpbDisabledSystemPolicy : 1;
        ULONG BpbDisabledNoHardwareSupport : 1;
        ULONG SpecCtrlEnumerated : 1;
        ULONG SpecCmdEnumerated : 1;
        ULONG IbrsPresent : 1;
        ULONG StibpPresent : 1;
        ULONG SmepPresent : 1;
        ULONG SpeculativeStoreBypassDisableAvailable : 1;
        ULONG SpeculativeStoreBypassDisableSupported : 1;
        ULONG SpeculativeStoreBypassDisabledSystemWide : 1;
        ULONG SpeculativeStoreBypassDisabledKernel : 1;
        ULONG SpeculativeStoreBypassDisableRequired : 1;
        ULONG BpbDisabledKernelToUser : 1;
        ULONG SpecCtrlRetpolineEnabled : 1;
        ULONG SpecCtrlImportOptimizationEnabled : 1;
        ULONG Reserved : 16;
    } SpeculationControlFlags;
} SYSTEM_SPECULATION_CONTROL_INFORMATION, * PSYSTEM_SPECULATION_CONTROL_INFORMATION;
Marquer Signification
BpbEnabled Si la valeur est TRUE, les fonctionnalités de contrôle de spéculation sont prises en charge et activées.
BpbDisabledSystemPolicy Si la valeur est TRUE, les fonctionnalités de contrôle de spéculation sont désactivées en raison d’une stratégie système.
BpbDisabledNoHardwareSupport Si la valeur est TRUE, les fonctionnalités de contrôle de spéculation sont désactivées en raison de l’absence de prise en charge matérielle.
SpecCtrlEnumerated Si la valeur est TRUE, l’IA32_SPEC_CTRL MSR i386/AMD64 est énuméré par le matériel.
SpecCmdEnumerated Si la valeur est TRUE, l’IA32_SPEC_CMD MSR i386/AMD64 est énuméré par le matériel.
IbrsPresent Si la valeur EST TRUE, l’IBRS MSR i386/AMD64 est traité comme étant présent.
StibpPresent Si la valeur est TRUE, le MSR STIBP i386/AMD64 est présent.
SmepPresent Si la valeur EST TRUE, la fonctionnalité SMEP est présente et activée.
SpéculativeStoreBypassDisableAvailable Si true, la prise en charge du système d’exploitation pour SSBD existe.
SpeculativeStoreBypassDisableSupported Si la valeur est TRUE, la prise en charge matérielle de SSBD existe.
SpeculativeStoreBypassDisabledSystemWide Si la valeur est TRUE, SSBD est définie à l’échelle du système.
SpéculativeStoreBypassDisabledKernel Si la valeur est TRUE, SSBD est définie dans le noyau.
SpéculativeStoreBypassDisableRequired Si la valeur est TRUE, SSBD est nécessaire pour empêcher les attaques spéculatives.
BpbDisabledKernelToUser Si la valeur est TRUE, la prédiction de branche indirecte n’est pas vidée sur chaque noyau vers la transition utilisateur.
SpecCtrlRetpolineEnabled Si la valeur EST TRUE, Retpoline est activée pour les pilotes compatibles.
SpecCtrlImportOptimizationEnabled Si la valeur EST TRUE, l’optimisation de l’importation est activée.
Réservé Indicateurs réservés.
 

SystemTimeOfDayInformation

Retourne une structure de SYSTEM_TIMEOFDAY_INFORMATION opaque qui peut être utilisée pour générer une valeur initiale imprévisible pour un générateur de nombres aléatoires. Utilisez plutôt la fonction CryptGenRandom .

[in, out] SystemInformation

Pointeur vers une mémoire tampon qui reçoit les informations demandées. La taille et la structure de ces informations varient en fonction de la valeur du paramètre SystemInformationClass :

SYSTEM_BASIC_INFORMATION

Lorsque le paramètre SystemInformationClass est SystemBasicInformation, la mémoire tampon pointée par le paramètre SystemInformation doit être suffisamment grande pour contenir une seule structure SYSTEM_BASIC_INFORMATION ayant la disposition suivante :

typedef struct _SYSTEM_BASIC_INFORMATION {
    BYTE Reserved1[24];
    PVOID Reserved2[4];
    CCHAR NumberOfProcessors;
} SYSTEM_BASIC_INFORMATION;

Le membre NumberOfProcessors contient le nombre de processeurs présents dans le système. Utilisez GetSystemInfo à la place pour récupérer ces informations.

Les autres membres de la structure sont réservés à une utilisation interne par le système d’exploitation.

SYSTEM_CODEINTEGRITY_INFORMATION

Lorsque le paramètre SystemInformationClass est SystemCodeIntegrityInformation, la mémoire tampon pointée par le paramètre SystemInformation doit être suffisamment grande pour contenir une seule structure SYSTEM_CODEINTEGRITY_INFORMATION ayant la disposition suivante :

typedef struct _SYSTEM_CODEINTEGRITY_INFORMATION {
    ULONG  Length;
    ULONG  CodeIntegrityOptions;
} SYSTEM_CODEINTEGRITY_INFORMATION, *PSYSTEM_CODEINTEGRITY_INFORMATION;

Le membre Length contient la taille de la structure en octets. Cela doit être défini par l’appelant.

Le membre CodeIntegrityOptions contient un masque de bits pour identifier les options d’intégrité du code.

Valeur Signification
0x01 CODEINTEGRITY_OPTION_ENABLED L’application de l’intégrité du code en mode noyau est activée.
0x02 CODEINTEGRITY_OPTION_TESTSIGN Le contenu signé de test est autorisé par l’intégrité du code.
0x04 CODEINTEGRITY_OPTION_UMCI_ENABLED L’application de l’intégrité du code en mode utilisateur est activée.
0x08 CODEINTEGRITY_OPTION_UMCI_AUDITMODE_ENABLED L’application de l’intégrité du code en mode utilisateur est activée en mode audit. Les exécutables sont autorisés à s’exécuter/charger ; toutefois, les événements d’audit seront enregistrés.
0x10 CODEINTEGRITY_OPTION_UMCI_EXCLUSIONPATHS_ENABLED Les fichiers binaires en mode utilisateur exécutés à partir de certains chemins sont autorisés à s’exécuter même s’ils échouent aux vérifications d’intégrité du code.

Les chemins d’exclusion sont répertoriés dans la clé de Registre suivante au format REG_MULTI_SZ :

  • Clé : HKLM\SYSTEM\CurrentControlSet\Control\CI\TRSData
  • Valeur : TestPath
Les chemins ajoutés à cette clé doivent se trouver dans l’un des deux formats suivants :
  • Chemin d’accès (absolu ou relatif) : \Program Files\TestAutomationPath
  • Binaire (spécifique) : \Program Files\TestAutomationPath\mybinary.exe
Les chemins d’accès suivants sont restreints et ne peuvent pas être ajoutés en tant qu’exclusion :
  • \
  • \Windows
  • \Windows\System32
  • \Program Files
Exclusions de chemins intégrés : les chemins d’accès suivants sont exclus par défaut. Vous n’avez pas besoin d’ajouter spécifiquement ces éléments aux exclusions de chemin d’accès. Cela s’applique uniquement sur ARM (Windows Runtime).
  • \Program Files\WTT
  • \Program Files (x86)\WTT
  • \WTT\JobsWorkingDir
  • \Program Files\Common Files\Model Design Environment
  • \TAEF
  • \$ASITEMP
  • \ATDEVXCT1\WTTInstall
  • \ATUEXCT1\WTTInstall
  • \ATESCCT1\WTTInstall
  • \ATCORECT1\WTTInstall
  • \ATStressCT1\WTTInstall
  • \ATWSCCT1\WTTInstall
  • \ATFUNCT1\WTTInstall
  • \ATIDCCT1\WTTInstall
  • \ATDNTCT1\WTTInstall
0x20 CODEINTEGRITY_OPTION_TEST_BUILD La build de l’intégrité du code provient d’une build de test.
0x40 CODEINTEGRITY_OPTION_PREPRODUCTION_BUILD La build de l’intégrité du code provient d’une build de préproduction.
0x80 CODEINTEGRITY_OPTION_DEBUGMODE_ENABLED Le débogueur du noyau est attaché et l’intégrité du code peut autoriser le chargement du code non signé.
0x100 CODEINTEGRITY_OPTION_FLIGHT_BUILD La build de l’intégrité du code provient d’une build de version d’évaluation.
0x200 CODEINTEGRITY_OPTION_FLIGHTING_ENABLED Le contenu signé de version d’évaluation est autorisé par l’intégrité du code. Le contenu signé par version d’évaluation est le contenu signé par l’autorité de certification racine du développement Microsoft 2014.
0x400 CODEINTEGRITY_OPTION_HVCI_KMCI_ENABLED L’intégrité du code appliquée à l’hyperviseur est activée pour les composants en mode noyau.
0x800 CODEINTEGRITY_OPTION_HVCI_KMCI_AUDITMODE_ENABLED L’intégrité du code appliquée à l’hyperviseur est activée en mode audit. Les événements d’audit sont enregistrés pour les composants en mode noyau qui ne sont pas compatibles avec HVCI. Ce bit peut être défini si CODEINTEGRITY_OPTION_HVCI_KMCI_ENABLED est défini ou non.
0x1000 CODEINTEGRITY_OPTION_HVCI_KMCI_STRICTMODE_ENABLED L’intégrité du code appliquée à l’hyperviseur est activée pour les composants en mode noyau, mais en mode strict.
0x2000 CODEINTEGRITY_OPTION_HVCI_IUM_ENABLED L’intégrité du code appliquée à l’hyperviseur est activée avec l’application de la signature de composant en mode utilisateur isolé.
 

SYSTEM_EXCEPTION_INFORMATION

Lorsque le paramètre SystemInformationClass est SystemExceptionInformation, la mémoire tampon pointée par le paramètre SystemInformation doit être suffisamment grande pour contenir une structure de SYSTEM_EXCEPTION_INFORMATION opaque à utiliser pour générer une valeur initiale imprévisible pour un générateur de nombres aléatoires. À cet effet, la structure a la disposition suivante :

typedef struct _SYSTEM_EXCEPTION_INFORMATION {
    BYTE Reserved1[16];
} SYSTEM_EXCEPTION_INFORMATION;

Les membres individuels de la structure sont réservés à une utilisation interne par le système d’exploitation.

Utilisez plutôt la fonction CryptGenRandom pour générer des données aléatoires par chiffrement.

SYSTEM_INTERRUPT_INFORMATION

Lorsque le paramètre SystemInformationClass est SystemInterruptInformation, la mémoire tampon pointée par le paramètre SystemInformation doit être suffisamment grande pour contenir un tableau qui contient autant de structures de SYSTEM_INTERRUPT_INFORMATION opaques qu’il existe des processeurs installés sur le système. Chaque structure, ou tableau dans son ensemble, peut être utilisée pour générer une valeur initiale imprévisible pour un générateur de nombres aléatoires. À cet effet, la structure a la disposition suivante :

typedef struct _SYSTEM_INTERRUPT_INFORMATION {
    BYTE Reserved1[24];
} SYSTEM_INTERRUPT_INFORMATION;

Les membres individuels de la structure sont réservés à une utilisation interne par le système d’exploitation.

Utilisez plutôt la fonction CryptGenRandom pour générer des données aléatoires par chiffrement.

SYSTEM_KERNEL_VA_SHADOW_INFORMATION

Lorsque le paramètre SystemInformationClass est SystemKernelVaShadowInformation, la mémoire tampon pointée par le paramètre SystemInformation doit être suffisamment grande pour contenir une seule structure SYSTEM_KERNEL_VA_SHADOW_INFORMATION ayant la disposition suivante :

typedef struct _SYSTEM_KERNEL_VA_SHADOW_INFORMATION {
    struct {
        ULONG KvaShadowEnabled:1;
        ULONG KvaShadowUserGlobal:1;
        ULONG KvaShadowPcid:1;
        ULONG KvaShadowInvpcid:1;
        ULONG KvaShadowRequired:1;
        ULONG KvaShadowRequiredAvailable:1;
        ULONG InvalidPteBit:6;
        ULONG L1DataCacheFlushSupported:1;
        ULONG L1TerminalFaultMitigationPresent:1;
        ULONG Reserved:18;
    } KvaShadowFlags;
} SYSTEM_KERNEL_VA_SHADOW_INFORMATION, * PSYSTEM_KERNEL_VA_SHADOW_INFORMATION;

KvaShadowEnabled indique si l’ombre est activée.

KvaShadowUserGlobal indique que l’utilisateur/global est activé.

KvaShadowPcid indique si PCID est activé.

KvaShadowInvpcid indique si PCID est activé et si INVPCID est en cours d’utilisation.

KvaShadowRequired indique si le matériel est connu pour être sensible à CVE-2017-5754.

KvaShadowRequiredAvailable indique si le champ KvaShadowRequired est pris en charge par le système d’exploitation.

InvalidPteBit indique le bit d’adresse physique utilisé pour les entrées de table de pages non valides, ou zéro s’il n’est pas défini.

Le L1DataCacheFlushSupported indique si le matériel prend en charge le vidage du cache de données L1.

L1TerminalFaultMitigationPresent indique si le système d’exploitation prend en charge l’atténuation du système d’exploitation du terminal L1 (CVE-2018-3620).

Le membre réservé de la structure est réservé à une utilisation interne par le système d’exploitation.

SYSTEM_LEAP_SECOND_INFORMATION

Lorsque le paramètre SystemInformationClass est SystemLeapSecondInformation, la mémoire tampon pointée par le paramètre SystemInformation doit être suffisamment grande pour contenir une structure de SYSTEM_LEAP_SECOND_INFORMATION opaque à utiliser pour activer ou désactiver les secondes de saut à l’échelle du système. Ce paramètre persiste même après un redémarrage du système. À cet effet, la structure a la disposition suivante :

typedef struct _SYSTEM_LEAP_SECOND_INFORMATION {
    BOOLEAN Enabled;
    ULONG Flags;
} SYSTEM_LEAP_SECOND_INFORMATION

Le champ Indicateurs est réservé à une utilisation ultérieure.

SYSTEM_LOOKASIDE_INFORMATION

Lorsque le paramètre SystemInformationClass est SystemLookasideInformation, la mémoire tampon pointée par le paramètre SystemInformation doit être suffisamment grande pour contenir une structure de SYSTEM_LOOKASIDE_INFORMATION opaque à utiliser pour générer une valeur initiale imprévisible pour un générateur de nombres aléatoires. À cet effet, la structure a la disposition suivante :

typedef struct _SYSTEM_LOOKASIDE_INFORMATION {
    BYTE Reserved1[32];
} SYSTEM_LOOKASIDE_INFORMATION;

Les membres individuels de la structure sont réservés à une utilisation interne par le système d’exploitation.

Utilisez plutôt la fonction CryptGenRandom pour générer des données aléatoires par chiffrement.

SYSTEM_PERFORMANCE_INFORMATION

Lorsque le paramètre SystemInformationClass est SystemPerformanceInformation, la mémoire tampon pointée par le paramètre SystemInformation doit être suffisamment grande pour contenir une structure de SYSTEM_PERFORMANCE_INFORMATION opaque à utiliser pour générer une valeur initiale imprévisible pour un générateur de nombres aléatoires. À cet effet, la structure a la disposition suivante :

typedef struct _SYSTEM_PERFORMANCE_INFORMATION {
    BYTE Reserved1[312];
} SYSTEM_PERFORMANCE_INFORMATION;

Les membres individuels de la structure sont réservés à une utilisation interne par le système d’exploitation.

Utilisez plutôt la fonction CryptGenRandom pour générer des données aléatoires par chiffrement.

SYSTEM_POLICY_INFORMATION

Lorsque le paramètre SystemInformationClass est SystemPolicyInformation, la mémoire tampon pointée par le paramètre SystemInformation doit être suffisamment grande pour contenir une seule structure de SYSTEM_POLICY_INFORMATION ayant la disposition suivante :

typedef struct _SYSTEM_POLICY_INFORMATION {
    PVOID Reserved1[2];
    ULONG Reserved2[3];
} SYSTEM_POLICY_INFORMATION;

Les membres individuels de la structure sont réservés à une utilisation interne par le système d’exploitation.

Utilisez plutôt la fonction SLGetWindowsInformation pour obtenir des informations de stratégie.

SYSTEM_PROCESS_INFORMATION

Lorsque le paramètre SystemInformationClass est SystemProcessInformation, la mémoire tampon pointée par le paramètre SystemInformation contient une structure SYSTEM_PROCESS_INFORMATION pour chaque processus. Chacune de ces structures est immédiatement suivie en mémoire par une ou plusieurs structures SYSTEM_THREAD_INFORMATION qui fournissent des informations pour chaque thread du processus précédent. Pour plus d’informations sur SYSTEM_THREAD_INFORMATION, consultez la section relative à cette structure dans cet article.

La mémoire tampon pointée par le paramètre SystemInformation doit être suffisamment grande pour contenir un tableau qui contient autant d’SYSTEM_PROCESS_INFORMATION et de structures SYSTEM_THREAD_INFORMATION qu’il existe des processus et des threads en cours d’exécution dans le système. Cette taille est spécifiée par le paramètre ReturnLength .

Chaque structure SYSTEM_PROCESS_INFORMATION a la disposition suivante :

typedef struct _SYSTEM_PROCESS_INFORMATION {
    ULONG NextEntryOffset;
    ULONG NumberOfThreads;
    BYTE Reserved1[48];
    UNICODE_STRING ImageName;
    KPRIORITY BasePriority;
    HANDLE UniqueProcessId;
    HANDLE InheritedFromUniqueProcessId;
    ULONG HandleCount;
    ULONG SessionId;
    PVOID Reserved3;
    SIZE_T PeakVirtualSize;
    SIZE_T VirtualSize;
    ULONG Reserved4;
    SIZE_T PeakWorkingSetSize;
    SIZE_T WorkingSetSize;
    PVOID Reserved5;
    SIZE_T QuotaPagedPoolUsage;
    PVOID Reserved6;
    SIZE_T QuotaNonPagedPoolUsage;
    SIZE_T PagefileUsage;
    SIZE_T PeakPagefileUsage;
    SIZE_T PrivatePageCount;
    LARGE_INTEGER Reserved7[6];
} SYSTEM_PROCESS_INFORMATION;

Le début de l’élément suivant dans le tableau est l’adresse de l’élément précédent, ainsi que la valeur du membre NextEntryOffset . Pour le dernier élément du tableau, NextEntryOffset est 0.

Le membre NumberOfThreads contient le nombre de threads dans le processus.

Le membre ImageName contient le nom de l’image du processus.

Le membre BasePriority contient la priorité de base du processus, qui est la priorité de départ pour les threads créés dans le processus associé.

Le membre UniqueProcessId contient l’ID de processus unique du processus.

Le membre InheritedFromUniqueProcessId contient l’ID de processus unique de son parent.

Le membre HandleCount contient le nombre total de handles utilisés par le processus en question ; utilisez GetProcessHandleCount pour récupérer ces informations à la place.

Le membre SessionId contient l’identificateur de session de la session de processus.

Le membre PeakVirtualSize contient la taille maximale, en octets, de la mémoire virtuelle utilisée par le processus.

Le membre VirtualSize contient la taille actuelle, en octets, de la mémoire virtuelle utilisée par le processus.

Le membre PeakWorkingSetSize contient la taille maximale, en kilo-octets, du jeu de travail du processus.

Le membre QuotaPagedPoolUsage contient le quota actuel facturé au processus d’utilisation du pool paginé.

Le membre QuotaNonPagedPoolUsage contient le quota actuel facturé au processus d’utilisation du pool nonpage.

Le membre PagefileUsage contient le nombre d’octets de stockage de fichiers de page utilisés par le processus.

Le membre PeakPagefileUsage contient le nombre maximal d’octets de stockage de fichiers de pages utilisés par le processus.

Le membre PrivatePageCount contient le nombre de pages de mémoire allouées pour l’utilisation de ce processus.

Vous pouvez également récupérer les informations PeakWorkingSetSize, QuotaPagedPoolUsage, QuotaNonPagedPoolUsage, PagefileUsage, PeakPagefileUsage et PrivatePageCount à l’aide de la fonction GetProcessMemoryInfo ou de la classe Win32_Process .

Les autres membres de la structure sont réservés à une utilisation interne par le système d’exploitation.

SYSTEM_THREAD_INFORMATION

Lorsque le paramètre SystemInformationClass est SystemProcessInformation, la mémoire tampon pointée par le paramètre SystemInformation contient une structure SYSTEM_PROCESS_INFORMATION pour chaque processus. Chacune de ces structures est immédiatement suivie en mémoire par une ou plusieurs structures SYSTEM_THREAD_INFORMATION qui fournissent des informations pour chaque thread du processus précédent. Pour plus d’informations sur SYSTEM_PROCESS_INFORMATION, consultez la section relative à cette structure dans cet article. Chaque structure SYSTEM_THREAD_INFORMATION a la disposition suivante :

typedef struct _SYSTEM_THREAD_INFORMATION {
    LARGE_INTEGER Reserved1[3];
    ULONG Reserved2;
    PVOID StartAddress;
    CLIENT_ID ClientId;
    KPRIORITY Priority;
    LONG BasePriority;
    ULONG Reserved3;
    ULONG ThreadState;
    ULONG WaitReason;
} SYSTEM_THREAD_INFORMATION;

Le membre StartAddress contient l’adresse de début du thread.

Le membre ClientId contient l’ID du thread et le processus propriétaire du thread.

Le membre Priority contient la priorité de thread dynamique.

Le membre BasePriority contient la priorité du thread de base.

Le membre ThreadState contient l’état actuel du thread.

Le membre WaitReason contient la raison pour laquelle le thread attend.

Les autres membres de la structure sont réservés à une utilisation interne par le système d’exploitation.

SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION

Lorsque le paramètre SystemInformationClass est SystemProcessorPerformanceInformation, la mémoire tampon pointée par le paramètre SystemInformation doit être suffisamment grande pour contenir un tableau qui contient autant de structures SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION qu’il existe des processeurs (PROCESSEURs) installés dans le système. Chaque structure a la disposition suivante :

typedef struct
_SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION {
    LARGE_INTEGER IdleTime;
    LARGE_INTEGER KernelTime;
    LARGE_INTEGER UserTime;
    LARGE_INTEGER Reserved1[2];
    ULONG Reserved2;
} SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION;

Le membre IdleTime contient la durée pendant laquelle le système a été inactif, dans des intervalles de 100 nanosecondes.

Le membre KernelTime contient la durée pendant laquelle le système a passé à s’exécuter en mode Noyau (y compris tous les threads de tous les processus, sur tous les processeurs), dans les intervalles de 100 nanosecondes.

Le membre UserTime contient la durée pendant laquelle le système a passé à s’exécuter en mode Utilisateur (y compris tous les threads de tous les processus, sur tous les processeurs), dans des intervalles de 100 nanosecondes.

Utilisez GetSystemTimes à la place pour récupérer ces informations.

SYSTEM_QUERY_PERFORMANCE_COUNTER_INFORMATION

Lorsque le paramètre SystemInformationClass est SystemQueryPerformanceCounterInformation, la mémoire tampon pointée par le paramètre SystemInformation doit être suffisamment grande pour contenir une seule structure SYSTEM_QUERY_PERFORMANCE_COUNTER_INFORMATION ayant la disposition suivante :

typedef struct _SYSTEM_QUERY_PERFORMANCE_COUNTER_INFORMATION {
    ULONG                           Version;
    QUERY_PERFORMANCE_COUNTER_FLAGS Flags;
    QUERY_PERFORMANCE_COUNTER_FLAGS ValidFlags;
} SYSTEM_QUERY_PERFORMANCE_COUNTER_INFORMATION;

Les membres Flags et ValidFlags sont QUERY_PERFORMANCE_COUNTER_FLAGS structures ayant la disposition suivante :

typedef struct _QUERY_PERFORMANCE_COUNTER_FLAGS {
    union {
        struct {
            ULONG KernelTransition:1;
            ULONG Reserved:31;
        };
        ULONG ul;
    };
} QUERY_PERFORMANCE_COUNTER_FLAGS;

Le membre ValidFlags de la structure SYSTEM_QUERY_PERFORMANCE_COUNTER_INFORMATION indique quels bits du membre Flags contiennent des informations valides . Si une transition de noyau est requise, le bit KernelTransition est défini dans ValidFlags et Flags. Si une transition de noyau n’est pas nécessaire, le bit KernelTransition est défini dans ValidFlags et efface dans Flags.

SYSTEM_REGISTRY_QUOTA_INFORMATION

Lorsque le paramètre SystemInformationClass est SystemRegistryQuotaInformation, la mémoire tampon pointée par le paramètre SystemInformation doit être suffisamment grande pour contenir une seule structure SYSTEM_REGISTRY_QUOTA_INFORMATION ayant la disposition suivante :

typedef struct _SYSTEM_REGISTRY_QUOTA_INFORMATION {
    ULONG RegistryQuotaAllowed;
    ULONG RegistryQuotaUsed;
    PVOID Reserved1;
} SYSTEM_REGISTRY_QUOTA_INFORMATION;

Le membre RegistryQuotaAllowed contient la taille maximale, en octets, que le Registre peut atteindre sur ce système.

Le membre RegistryQuotaUsed contient la taille actuelle du Registre, en octets.

Utilisez GetSystemRegistryQuota à la place pour récupérer ces informations.

L’autre membre de la structure est réservé à une utilisation interne par le système d’exploitation.

SYSTEM_SPECULATION_CONTROL_INFORMATION

Lorsque le paramètre SystemInformationClass est SystemSpeculationControlInformation, la mémoire tampon pointée par le paramètre SystemInformation doit être suffisamment grande pour contenir une seule structure SYSTEM_SPECULATION_CONTROL_INFORMATION ayant la disposition suivante :

typedef struct _SYSTEM_SPECULATION_CONTROL_INFORMATION {
    struct {
         ULONG BpbEnabled:1;
         ULONG BpbDisabledSystemPolicy:1;
         ULONG BpbDisabledNoHardwareSupport:1;
         ULONG SpecCtrlEnumerated:1;
         ULONG SpecCmdEnumerated:1;
         ULONG IbrsPresent:1;
         ULONG StibpPresent:1;
         ULONG SmepPresent:1;
         ULONG SpeculativeStoreBypassDisableAvailable:1;
         ULONG SpeculativeStoreBypassDisableSupported:1;
         ULONG SpeculativeStoreBypassDisabledSystemWide:1;
         ULONG SpeculativeStoreBypassDisabledKernel:1;
         ULONG SpeculativeStoreBypassDisableRequired:1;
         ULONG BpbDisabledKernelToUser:1;
         ULONG Reserved:18;
    } SpeculationControlFlags;

} SYSTEM_SPECULATION_CONTROL_INFORMATION, * PSYSTEM_SPECULATION_CONTROL_INFORMATION;

Le BpbEnabled indique si les fonctionnalités de contrôle de spéculation sont prises en charge et activées.

BpbDisabledSystemPolicy indique si les fonctionnalités de contrôle de spéculation sont désactivées en raison d’une stratégie système.

BpbDisabledNoHardwareSupport indique si les fonctionnalités de contrôle de spéculation sont désactivées en raison de l’absence de prise en charge matérielle.

Valeur SpecCtrlEnumerated indiquant si la IA32_SPEC_CTRL MSR est énumérée par du matériel.

La valeur SpecCmdEnumerated indique si la IA32_SPEC_CMD MSR est énumérée par le matériel.

L’IbrsPresent indique si le MSR IBRS est traité comme étant présent.

StibpPresent indique si le MSR STIBP est présent.

Le SmepPresent indique si la fonctionnalité SMEP est présente et activée.

The SpeculativeStoreBypassDisableAvailable indique si les autres champs de contournement de magasin spéculatif disable (SSBD) de cette structure de données sont pris en charge par le système d’exploitation.

The SpeculativeStoreBypassDisableSupported indique si la prise en charge matérielle de SSBD est présente.

The SpeculativeStoreBypassDisabledSystemWide indique si SSBD a été activé à l’échelle du système.

Le spéculatifStoreBypassDisabledKernel indique si SSBD a été désactivé pour le mode noyau.

The SpeculativeStoreBypassDisableRequired indique si le matériel est connu pour être susceptible d’être susceptible de contourner le magasin spéculatif.

BpbDisabledKernelToUser indique si la prédiction de branche indirecte est vidée sur chaque noyau vers la transition utilisateur.

Le membre réservé de la structure est réservé à une utilisation interne par le système d’exploitation.

SYSTEM_TIMEOFDAY_INFORMATION

Lorsque le paramètre SystemInformationClass est SystemTimeOfDayInformation, la mémoire tampon pointée par le paramètre SystemInformation doit être suffisamment grande pour contenir une structure de SYSTEM_TIMEOFDAY_INFORMATION opaque à utiliser pour générer une valeur initiale imprévisible pour un générateur de nombres aléatoires. À cet effet, la structure a la disposition suivante :

typedef struct _SYSTEM_TIMEOFDAY_INFORMATION {
    BYTE Reserved1[48];
} SYSTEM_TIMEOFDAY_INFORMATION;

Les membres individuels de la structure sont réservés à une utilisation interne par le système d’exploitation.

Utilisez plutôt la fonction CryptGenRandom pour générer des données aléatoires par chiffrement.

[in] SystemInformationLength

Taille de la mémoire tampon pointée par le paramètre SystemInformation , en octets.

[out, optional] ReturnLength

Pointeur facultatif vers un emplacement où la fonction écrit la taille réelle des informations demandées. Si cette taille est inférieure ou égale à la taille
Paramètre SystemInformationLength , la fonction copie les informations dans la mémoire tampon SystemInformation ; sinon, elle retourne un code d’erreur NTSTATUS et retourne dans ReturnLength la taille de la mémoire tampon requise pour recevoir les informations demandées.

Valeur retournée

Retourne un code de réussite ou d’erreur NTSTATUS.

Les formulaires et l’importance des codes d’erreur NTSTATUS sont répertoriés dans le fichier d’en-tête Ntstatus.h disponible dans le DDK, et sont décrits dans la documentation du DDK.

Remarques

La fonction NtQuerySystemInformation et les structures qu’elle retourne sont internes au système d’exploitation et soumises à une modification d’une version de Windows à une autre. Pour maintenir la compatibilité de votre application, il est préférable d’utiliser les autres fonctions mentionnées précédemment.

Si vous utilisez NtQuerySystemInformation, accédez à la fonction via la liaison dynamique au moment de l’exécution. Cela permet à votre code de répondre correctement si la fonction a été modifiée ou supprimée du système d’exploitation. Toutefois, les modifications de signature peuvent ne pas être détectables.

Cette fonction n’a aucune bibliothèque d’importation associée. Vous devez utiliser les fonctions LoadLibrary et GetProcAddress pour lier dynamiquement à Ntdll.dll.

Spécifications

Requirement Valeur
plateforme cible Fenêtres
Header winternl.h
Library ntdll.lib
DLL ntdll.dll

Voir aussi

GetProcessHandleCount

GetProcessMemoryInfo

GetSystemInfo

GetSystemRegistryQuota

GetSystemTimes

  • Last updated on