A flaw was found in the Linux kernel's firmware loader component. This vulnerability occurs in the `firmware_upload_register()` function when an allocation failure happens after a device instance is created. The system fails to properly release a device reference, leading to an unbalanced reference count. This can result in a resource leak within the kernel.

A flaw was found in the Linux kernel's `proc` filesystem. A local attacker with low privileges could exploit a race condition within the `ptrace_may_access()` function when handling file descriptor links. This vulnerability arises because the system performs multiple task lookups without proper synchronization during access checks. Successful exploitation could allow the attacker to bypass security restrictions, potentially leading to unauthorized information disclosure, modification of system data, or a denial of service.

A flaw was found in the Linux kernel's real-time (RT) scheduler. In non-real-time configurations, the RT_PUSH_IPI mechanism, designed to improve task migration, can lead to a live lock. This occurs when a CPU handling heavy network traffic is repeatedly interrupted by other CPUs attempting to schedule waiting real-time tasks. The continuous interruptions prevent the CPU from processing tasks, resulting in a Denial of Service (DoS) for that CPU.

A flaw was found in the Linux kernel's CPU frequency scaling (cpufreq) subsystem. During a system reboot, a race condition can occur when the system attempts to suspend CPU frequency operations while CPU hotplug operations are still active. This can lead to a null pointer dereference, which may cause the system to crash, resulting in a denial of service.

A flaw was found in the Linux kernel's cpufreq subsystem. This vulnerability, a use-after-free and double-free error, occurs during the two-phase _OSC negotiation in the `pcc_cpufreq_do_osc()` function. A local attacker could exploit this memory corruption to cause a denial of service (DoS) or potentially achieve privilege escalation.

A flaw was found in the Linux kernel's posix-cpu-timers component. This vulnerability allows a local user to trigger a resource leak within the `do_cpu_nanosleep()` function. The issue occurs because a process identifier (PID) reference is not properly released if a timer creation operation fails. This unreleased resource can accumulate over time, potentially leading to a denial of service (DoS) due to system resource exhaustion.

A flaw was found in the Linux kernel, specifically within the s390 architecture. When the system attempts to read unaligned data that spans across memory pages, it can trigger exceptions. For memory pages designated for secure execution by the Ultravisor, the exception handling mechanism does not correctly resolve these issues. This improper handling can lead to a continuous loop of exceptions, ultimately causing a Denial of Service (DoS) where the system becomes unresponsive.

A flaw was found in the Linux kernel's memory management subsystem. This issue occurs when the kernel's memory allocator attempts to zero out newly allocated memory, but an incorrect check prevents the full memory region from being cleared under specific configurations. This can lead to memory not being fully zeroed as intended, potentially allowing a local attacker to access sensitive information from previously used memory regions.

A flaw was found in the Linux kernel's hid-goodix-spi driver. This vulnerability, a stack buffer overflow, allows a local attacker to provide an oversized report to the system. This can lead to a buffer overflow, potentially enabling the attacker to execute arbitrary code with elevated privileges or cause the system to crash, resulting in a denial of service.

A flaw was found in the Linux kernel's Wacom Human Interface Device (HID) driver. This vulnerability occurs in the `wacom_wac_queue_insert` function when handling incoming reports. Improper management of the kernel's internal buffer (kfifo) can lead to a slab-out-of-bounds write, allowing an attacker to corrupt memory. This memory corruption could potentially result in a denial of service or, in some cases, arbitrary code execution.

A flaw was found in the Linux kernel's `letsketch` Human Interface Device (HID) driver. This vulnerability, a Use-After-Free (UAF), occurs because a timer is not properly shut down when the device is removed or during an error in its setup. This can cause the system to attempt to access memory that has already been released, leading to system instability, crashes, or potentially allowing an attacker to execute malicious code.

A flaw was found in the Linux kernel's Human Interface Device (HID) multitouch subsystem. A remote attacker can exploit this vulnerability by connecting a specially crafted multitouch device that advertises a large contact count. This can lead to an out-of-bounds bit access, corrupting adjacent memory and causing a kernel panic, resulting in a Denial of Service (DoS).

A flaw was found in the `appleir` Human Interface Device (HID) driver in the Linux kernel. A use-after-free (UAF) vulnerability can occur if a key is pressed shortly before an Apple infrared (IR) device is disconnected. This timing issue allows a pending timer to access freed memory, which may lead to system instability or a denial of service.

A flaw was found in the Linux kernel's lg-g15 Human Interface Device (HID) driver. This vulnerability, a use-after-free, occurs when a Logitech G15, G15 v2, or G510 keyboard is unplugged while a work item is pending. The driver fails to properly cancel this pending work, allowing it to access memory that has already been freed. This race condition can lead to system instability or crashes.

A flaw was found in the Linux kernel's HFS/HFS+ filesystem driver. An integer overflow vulnerability exists in the `check_and_correct_requested_length` function, where a calculation involving `off + len` can wrap around due to 32-bit arithmetic. This allows an attacker to bypass bounds checks, leading to an out-of-bounds read of approximately 4GB of memory. A local attacker with low privileges could exploit this to potentially disclose sensitive information or cause memory corruption.

A flaw was found in the Linux kernel. The `hfs_bnode_read()` function within the HFS/HFS+ filesystem driver could return without fully initializing a buffer. This could lead to the use of uninitialized memory, potentially causing unpredictable system behavior or the disclosure of sensitive information.

A flaw was found in the Linux kernel's nilfs2 filesystem. This vulnerability occurs because user-supplied segment numbers are not properly validated before processing `CLEAN_SEGMENTS` ioctl requests. An attacker, by providing out-of-range segment numbers, can trigger excessive logging. This prolonged logging can cause the system to become unresponsive, leading to a Denial of Service (DoS) where legitimate operations are blocked.

A flaw was found in the Linux kernel's media component, specifically within the `mtk-jpeg` driver. An internal function attempts to cancel a background task even when that task is not active on certain system configurations. This can lead to the system logging warning messages, potentially causing minor system instability or unexpected behavior. This issue does not result in critical security impacts such as data compromise or unauthorized code execution.

No description is available for this CVE.

A flaw was found in the Linux kernel's XFS filesystem. This vulnerability occurs during the creation of XFS metadata directories, where a failure in the creation process or a subsequent commit can lead to a memory leak. This leak results in allocated update and transaction state not being properly released, and an inode reference being left behind. Over time, this can lead to resource exhaustion and potentially cause the system to become unresponsive, resulting in a Denial of Service (DoS).