These pages are published after PatchSiren validates generated defensive summaries against stored public CVE and source evidence.
A vulnerability in the Linux kernel's power supply driver for max17040 has been addressed. The max17040_get_vcell() and max17040_get_soc() functions ignored errors returned by regmap_read(). When an I2C transfer fails, the uninitialized register value is converted and reported to userspace as a valid voltage or state of charge. The polling worker can also replace the cached state of charge with the bogus [truncated]
A Linux kernel vulnerability has been resolved, affecting the power: supply: max17040 component. The issue involves synchronizing work cancellation on suspend to prevent the polling callback from continuing to access the fuel gauge and requeue itself after the suspend callback returns. This fix ensures that the system suspend process is not disrupted by ongoing polling activities, which could lead to unpr [truncated]
A Linux kernel vulnerability allows a system crash when using the 'perf stat' command with CPU hotplug events. The issue arises from the dynamic allocation of per-CPU event infrastructure during event creation, which is not sufficient for handling CPU hotplug events. This can cause a kernel panic when the scheduler runs a process on a CPU that has not created and initialized its per-CPU event infrastructure.
A Linux kernel vulnerability was resolved, addressing an issue with the MVIY_PERCPU() macro that could lead to incorrect per-CPU address register handling after migration. The fix involves using C string literals directly and separating assembler macro arguments with an explicit comma, ensuring compatibility with GNU as versions prior to binutils 2.39. This change prevents assembler macro invocation issue [truncated]
A vulnerability in the Linux kernel's s390/dasd component has been addressed. The issue involves the handling of failed ESE read operations, where the code was incorrectly marking the request as successful, potentially leading to the exposure of stale or uninitialized memory. This could allow attackers to access sensitive information. The fix checks the ese_read() return value and fails the request throug [truncated]
A vulnerability in the Linux kernel's s390/dasd component can cause partial completion lengths to be lost during ERP recovery, potentially leading to silent data corruption. This issue was resolved through a patch that propagates partial completion lengths across ERP recovery. The vulnerability affects Linux kernel infrastructure, particularly those using s390/dasd, and requires verification of Linux kern [truncated]
A vulnerability was found in the Linux kernel's PCI: plda driver, which did not properly clean up IRQ domains in error paths of the `plda_init_interrupts()` function. This could lead to IRQ domain leaks. The issue has been resolved by adding a call to `plda_pcie_irq_domain_deinit()` in the error paths. The vulnerability was discovered through automated review, and the fix ensures that IRQ domains are prop [truncated]
A Linux kernel vulnerability has been resolved, involving a reference count leak in the iommu/amd driver when handling PPR faults. The issue arises from iommu_call_iopf_notifier() using pci_get_domain_bus_and_slot() to look up the requester, which increments the PCI device reference count. However, neither the successful nor abort paths drop this reference, leading to a PCI device reference leak for every [truncated]
A Linux kernel vulnerability has been resolved, involving the msm_iommu_probe() function. The issue arises when the function adds its devm-managed IOMMU object to qcom_iommu_devices before adding the IOMMU sysfs device and registering it with the IOMMU core. If iommu_device_sysfs_add() or iommu_device_register() fails, the probe returns with the object still on qcom_iommu_devices, potentially leaving a da [truncated]
A Linux kernel vulnerability was resolved, affecting the iommu/tegra241-cmdqv component. The issue involves rejecting a vSID wider than the SID_MATCH field. The bound check currently only rejects virt_sid > UINT_MAX, allowing a value wider than the field. This can cause the entry to alias the wrong Stream ID, potentially allowing a VMM to trigger it.
A memory leak vulnerability was found in the Linux kernel's iommu_mock_device_add function. When device_add fails, the error path only calls iommu_fwspec_free, leaving dev->iommu still allocated. This triggers a kmemleak report. The issue is resolved by calling dev_iommu_free instead of iommu_fwspec_free in the device_add failure path. The vulnerability was discovered through fuzzing with Syzkaller, which [truncated]
A Linux kernel vulnerability has been resolved, involving a misconfiguration with ACS disabled while iommu is later forced on by tboot_force_iommu(). The issue arises from the conditions of requesting ACS in detect_intel_iommu() not including tboot, leading to potential misconfiguration. Linux kernel administrators and developers should verify their configurations to ensure ACS is properly requested when [truncated]
A vulnerability in the Linux kernel's iommufd has been resolved. The issue arises from iommufd_access_notify_unmap() skipping internal accesses without an external unmap callback, but locking the object before checking if it's internal, leading to a reference leak. This issue may impact Linux kernel developers and maintainers who should verify if their versions are affected and consider updating.
A vulnerability in the Linux kernel has been resolved, where the iommufd fails to release the current IOAS on xa_store() failure. This could potentially lead to resource leaks. The issue arises from iommufd_take_all_iova_rwsem() taking an object reference and the iova_rwsem write lock before storing the IOAS in the temporary ioas_list xarray. If xa_store() fails, the current IOAS has not been inserted int [truncated]
A use-after-free vulnerability was found in the Linux kernel's IOMMUFD selftest TRIGGER_IOPF. This vulnerability could lead to a use-after-free condition when a concurrent iommu_report_device_fault() is called. The issue arises from borrowing an attach handle from group->pasid_array without proper synchronization against PASID detach. The vulnerability was resolved by adding a iopf_rwsem in mock_dev to fo [truncated]
The Linux kernel vulnerability CVE-2026-89444 exposes the admin password in the kernel log due to a hex dump of the security buffer in the dell-wmi-sysman platform/x86 module. This issue was partially addressed by a previous commit for password attributes but remained in the BIOS attribute path. The vulnerability allows unauthorized access to sensitive information, potentially leading to system compromise [truncated]
A vulnerability in the Linux kernel's platform/x86: ISST subsystem allows for out-of-bounds reads due to improper validation of user-provided levels in perf mask ioctls. This issue has been resolved through the addition of bounds checks in the affected helpers. The vulnerability could potentially lead to local privilege escalation, denial of service, or information disclosure if exploited. Linux kernel ma [truncated]
A vulnerability in the Linux kernel's platform/x86: ISST subsystem has been resolved. The isst_if_clos_assoc() function did not properly validate user-supplied socket IDs, allowing for out-of-bounds array access and potential NULL pointer dereferences. This issue could lead to system crashes, instability, or potential local privilege escalation if exploited. Linux kernel developers and maintainers, Linux [truncated]
A use-after-free vulnerability was found in the Linux kernel's mmc: via-sdmmc module. When the device interrupt is disabled and the IRQ is freed, new card-detect work can still run, accessing freed memory. The issue was resolved by canceling card-detect work after freeing the IRQ and before canceling finish_bh_work. This vulnerability requires attention from Linux kernel developers, maintainers, and users [truncated]
A Linux kernel vulnerability was found and resolved in the mmc: via-sdmmc driver. The driver did not properly handle probe failure, leading to a potential use-after-free issue. The interrupt was not disabled and freed on probe failure, allowing the handler to run against freed memory. This issue could lead to system instability or crashes if exploited. Defenders should review the Linux kernel version and [truncated]
A vulnerability was found in the Linux kernel's platform/x86: ISST (Intel Speed Select Technology) module. The issue involves adding a NULL check for sst_inst[] to prevent potential crashes or unexpected behavior when socket loading fails. This change aims to ensure consistency with other parts of the codebase. The vulnerability is specific, requires local access to exploit, and has a low defensive priori [truncated]
The Linux kernel has a vulnerability that has been resolved by validating logical CPU id and clos id for core power feature. This vulnerability is related to the platform/x86: ISST. The CVE record was published on 2026-09-11T20:19:24.087Z and has not been modified since then. The vulnerability requires verification of Linux kernel versions and configurations to determine exposure and prioritize remediatio [truncated]
A Linux kernel vulnerability allows for a silent 4-byte heap overflow due to a sentinel write past the end of the pcc->sinf array. The issue arises from the acpi_pcc_retrieve_biosdata function, which does not properly check the bounds of pcc->sinf when writing a sentinel value. This can occur when the DSDT's SINF package count equals SQTY+1, triggering an off-by-one workaround that makes num_sifr equal to [truncated]
A memory leak vulnerability was found in the Linux kernel's platform/x86: think-lmi driver. When the driver is removed, it leaks system certificate signatures. This issue has been resolved by freeing the signatures. The vulnerability can lead to increased memory usage and potential denial of service. Linux kernel developers and maintainers should verify system certificate signatures and ensure proper memo [truncated]
A vulnerability in the Linux kernel's platform/chrome sensorhub has been resolved. The EC-reported sensor number was not validated, allowing for an out-of-bounds read and write of batch_state[]. This vulnerability impacts Linux kernel developers and maintainers, Linux distribution maintainers, and users of Linux-based systems. Defenders should verify and apply kernel updates, review system configurations [truncated]
A vulnerability in the Linux kernel's platform/x86/amd/pmc component has been addressed. The amd_stb_s2d_init() function was not properly handling return values from S2D SMU commands, potentially leading to uninitialized physical addresses being passed to devm_ioremap(). This could result in mapping physical address 0 and triggering an ioremap-on-RAM warning.
A vulnerability in the Linux kernel's amd_pmc driver has been resolved. The driver failed to properly unwind LPS0 and debugfs resources when amd_stb_s2d_init() failed during probe, leading to potential crashes or stale registrations on subsequent s2idle transitions. This issue could result in system instability or unexpected behavior if not addressed. The fix involves ensuring proper cleanup of resources [truncated]
A heap out-of-bounds (OOB) read vulnerability exists in the Linux kernel's platform/x86: hp-bioscfg module. The vulnerability is due to the `sk_store()` and `kek_store()` functions not properly handling the stripping of trailing newlines from sysfs writes, leading to a buffer overflow when calling `hp_wmi_perform_query()`. This could potentially allow an attacker to read sensitive information from the heap.
A vulnerability in the Linux kernel's platform/x86: hp-bioscfg allows for an out-of-bounds read when writing an empty string to current_password or new_password. This issue arises from the validate_password_input() function not checking if the input string is empty before attempting to strip a trailing newline character. The vulnerability was confirmed via KASAN, which detected a slab-out-of-bounds read. [truncated]
A Linux kernel vulnerability was resolved in the platform/x86: hp-bioscfg module. The hp_get_string_from_buffer() function had an off-by-one write issue, allowing for a potential buffer overflow. This vulnerability affects multiple fixed-size destinations, including path, current_value, current_password, and per-entry buffers in encodings and prerequisites.