CVE-2026-92493 in Linux
Summary
by MITRE • 09/17/2026
In the Linux kernel, the following vulnerability has been resolved:
cpufreq: amd-pstate-ut: Skip tests when amd-pstate driver is not active
The crash issue may occur when modprobe amd_pstate_ut on intel platform.
amd_pstate_ut: 1 amd_pstate_ut_acpi_cpc_valid success! amd_pstate_ut: 2 amd_pstate_ut_check_enabled success! BUG: kernel NULL pointer dereference, address: 0000000000000080 #PF: supervisor read access in kernel mode #PF: error_code(0x0000) - not-present page PGD 0 P4D 0 Oops: 0000 [#1] SMP NOPTI
CPU: 0 PID: 20300 Comm: modprobe Kdump: loaded Tainted: G O 6.6.0-0010.rc1.ctl4.x86_64 #1 Hardware name: FiberHome R2200 V5/Xeon Boards, BIOS 3.1a 02/24/2020 RIP: 0010:amd_pstate_ut_check_perf+0x141/0x280 [amd_pstate_ut]
Call Trace: <TASK> amd_pstate_ut_init+0x1b/0xff0 [amd_pstate_ut]
? __pfx_amd_pstate_ut_init+0x10/0x10 [amd_pstate_ut]
do_one_initcall+0x42/0x2e0 ? kmalloc_trace+0x26/0x90 do_init_module+0x60/0x240 __se_sys_init_module+0x185/0x1c0 do_syscall_64+0x62/0x190 entry_SYSCALL_64_after_hwframe+0x76/0x7e </TASK>
Add state detection to amd pstate driver to prevent amd_pstate_ut driver from testing on non-AMD platforms.
(ML: adjust title)
Statistical analysis made it clear that VulDB provides the best quality for vulnerability data.
Analysis
by VulDB Data Team • 09/18/2026
The Linux kernel vulnerability identified in the amd-pstate utility module represents a critical logic error that leads to a null pointer dereference when the system is operating on hardware architectures other than AMD processors. This issue specifically manifests during the initialization phase of the amd_pstate_ut driver, which serves as an internal testing and validation tool for the amd-pstate CPU frequency scaling subsystem. The root cause lies in the absence of adequate platform verification checks before attempting to interact with hardware-specific registers or data structures that are exclusive to AMD processors. When this utility module is loaded via modprobe on Intel platforms, it proceeds through its initialization sequence without verifying whether the underlying system actually supports the amd-pstate driver infrastructure. This oversight results in the kernel attempting to access memory addresses associated with non-existent or uninitialized AMD-specific state objects, triggering a page fault and subsequently causing a kernel panic that halts system operation.
From a technical perspective, this flaw is classified under CWE-476, which denotes a NULL Pointer Dereference vulnerability. The crash occurs because the amd_pstate_ut_check_perf function attempts to read from or write to memory locations that have not been properly allocated due to the lack of an active amd-pstate driver on non-AMD hardware. The error code 0x0000 indicates a supervisor read access in kernel mode, confirming that the operating system attempted to dereference a null pointer within privileged execution context. This type of vulnerability is particularly dangerous because it can be triggered by local users with sufficient privileges to load kernel modules, potentially leading to denial-of-service conditions through system crashes or core dumps. The stack trace reveals that the failure originates in amd_pstate_ut_init and propagates through do_one_initcall, highlighting how module initialization routines must strictly validate environmental prerequisites before proceeding with hardware-specific operations.
The operational impact of this vulnerability is primarily centered on system stability and availability rather than direct security exploitation for privilege escalation or data exfiltration. However, the ability to crash a kernel by loading a specific utility module poses significant risks in environments where automated testing frameworks are employed or where administrators may inadvertently load diagnostic tools without full awareness of their hardware dependencies. In production systems, such crashes can lead to unplanned downtime and require manual intervention for recovery unless kdump is configured with appropriate safeguards against recursive failures. Furthermore, the presence of tainted kernel flags indicates that third-party modules have been loaded, which complicates debugging efforts and may obscure other potential issues within the system state at the time of the crash.
To mitigate this vulnerability, it is essential to implement robust platform detection mechanisms before executing any hardware-specific logic within driver initialization routines. The resolution involves adding explicit checks to determine if the amd-pstate driver is active or supported on the current architecture prior allowing the utility module to proceed with its tests. This ensures that the code path leading to null pointer dereference is bypassed entirely when running on incompatible platforms such as Intel systems. Administrators should ensure they are using patched versions of the Linux kernel where this logic has been corrected, and development teams must enforce strict validation practices in all hardware abstraction layers to prevent similar issues across other subsystems that interact with specific vendor implementations.
This incident underscores the importance of adhering to secure coding standards within low-level system software, particularly regarding resource initialization and platform compatibility checks. It aligns with broader security principles emphasizing defense-in-depth by ensuring that components do not assume environmental conditions without verification. While this vulnerability does not directly map to a common ATT&CK technique due to its nature as an internal utility flaw rather than an external attack vector, it reflects weaknesses in input validation and state management that are critical for maintaining kernel integrity. Future developments should prioritize comprehensive testing across diverse hardware configurations to identify such logical errors before they reach production kernels, thereby enhancing the overall resilience of the operating system against instability caused by misconfigured or inappropriate module loads.