A race condition vulnerability in the Linux kernel's brcmfmac WiFi driver caused a kernel crash when the driver was removed while a user space process that created a P2P device was still exiting. This double removal of the P2P device interface leads to a use-after-free fault and kernel oops. The issue occurs due to concurrent removal paths attempting to unregister and free the same device interface.
A type confusion vulnerability in the Linux kernel's ati_remote2 driver was resolved by correcting device attribute handlers. The issue arose because attribute callbacks incorrectly treated usb_interface pointers as usb_device pointers, leading to invalid pointer usage. This was fixed by updating the callbacks to use the correct usb_interface pointers.
A reference leak vulnerability in the Linux kernel's Btrfs filesystem scrub functionality was fixed. The issue occurred in the scrub_print_warning_inode() function, where a reference obtained by btrfs_get_fs_root() was not properly released if paths_from_inode() failed, causing a local_root reference leak. This leak happened every time path resolution failed during scrub warning printing. The fix ensures the reference is dropped on the failure path to prevent the leak.
A race condition in the Linux kernel's cpuset subsystem related to CPU hotplug operations could lead to a NULL pointer dereference. This occurs because the update order of cpu_active_mask and cpu_online_mask allows a race window where the top cpuset may have no active CPU. The issue was fixed by reintroducing a NULL check in guarantee_active_cpus() to prevent dereferencing a NULL pointer.
A vulnerability in the Linux kernel's openvswitch component caused a soft lockup during netlink flow dumps on production compute nodes with many datapath flows. The issue arises because the softirq backlog refills as fast as it drains, causing the dumping thread to monopolize CPU time without rescheduling, leading to a system hang. The fix involves holding bottom halves off across the entire callback to prevent nested softirq draining, ensuring the CPU can reschedule properly.
A vulnerability in the Linux kernel's skb_copy_and_csum_bits() function could cause stale memory bytes to be sent in network packets. When the function encounters unreadable fragments, it copies only the linear part of the buffer and leaves the rest unchanged, potentially leaking residual memory data in ICMP error messages or driver transmit buffers. The issue has been resolved by zeroing the unfilled parts of the buffer to prevent unintended data leakage.
A vulnerability in the Linux kernel's SCSI changer driver (ch) caused references to data transfer element devices to be retained improperly. This led to scsi_device objects never being released after device removal, preventing the unloading of the low-level driver module and requiring a system reboot to recover. The issue was fixed by dropping the reference immediately after use and removing the unused array that caused the leak.
A vulnerability in the Linux kernel's packet_rcv_spkt() function could cause a kernel panic when processing packets on devices without a visible link layer header, such as CAN interfaces. The issue arises because packet_rcv_spkt() does not guard the link layer header push operation, leading to an invalid length calculation and a panic in skb_push(). This flaw was introduced when other receive paths were updated but packet_rcv_spkt() was not. The vulnerability has been resolved by adding the appropriate guard to prevent the panic.
A vulnerability in the Linux kernel's Xilinx axienet network driver was resolved. The issue involved the improper freeing of DMA buffers on dmaengine stop, causing a memory leak of SKBs and DMA mappings during interface shutdown. This could exhaust limited IOMMU aperture resources. The fix ensures all DMA-mapped buffers are properly unmapped and freed on stop, and adds synchronization to prevent race conditions between buffer callbacks and driver stop operations.
A vulnerability in the Linux kernel regulator driver for the LTC3676 chip involved reading write-only registers HRST and CLIRQ. These registers trigger hardware reset and interrupt clear commands when written, but reading them causes unintended board resets. The issue was resolved by making these registers writable only and preventing reads that cause resets.
A vulnerability in the Linux kernel's TPS6594 regulator driver was resolved involving an out-of-bounds array access due to an incorrect count of linear voltage ranges. The issue affects the TPS65224 BUCK2, BUCK3, and BUCK4 descriptors, as well as TPS652G1, where the code reads beyond the defined array when checking voltage selectors. This could cause improper handling of voltage constraints during regulator registration.
A use-after-free vulnerability in the Linux kernel's net/smc subsystem was resolved. The flaw occurs in the smc_getname() function, which dereferences a pointer to a CLC socket without proper locking, allowing a race condition where the socket may be released asynchronously. This can lead to either a use-after-free or a NULL pointer dereference during getsockname() calls. The fix involves holding the clcsock_release_lock to serialize access and returning an error if the socket has already been released.
A vulnerability in the Linux kernel's RISC-V architecture under CONFIG_SHADOW_CALL_STACK allowed an unprivileged user to bypass kernel shadow call stack pointer reload checks by manipulating the user-writable tp register. This could lead to arbitrary kernel memory write and control-flow hijacking. The issue was fixed by changing the check to rely on the hardware sstatus.SPP bit, which cannot be forged by user mode, ensuring correct reload of the shadow call stack pointer on user traps.
A vulnerability in the Linux kernel's network team driver was resolved involving improper handling of broadcast packets when no transmitable port is available. The function bc_transmit() sends the original socket buffer (skb) through the last transmitable port, but if no port is transmitable, it returns false without consuming the skb. However, team_xmit() incorrectly returns NETDEV_TX_OK, causing AF_PACKET sockets to retain the skb and its associated socket write-memory charge, potentially leading to resource leaks. The fix ensures the original skb is freed on the no-port path while maintaining existing drop accounting.
A vulnerability in the Linux kernel's network bridge component involving recursive multicast port cleanup has been resolved. The issue occurs in the function br_multicast_sg_del_exclude_ports(), which removes automatically added STAR_EXCL port groups by calling br_multicast_del_pg(). For certain S,G entries, this deletion triggers recursive calls that consume one kernel stack frame per port, potentially hitting the stack guard page and causing a stack overflow. The fix suppresses recursive exclude-port cleanup during the same entry walk while retaining the overall port-group deletion behavior.
A vulnerability in the Linux kernel's mmc sdhci-sprd driver was resolved. The issue involved improper runtime power management (PM) cleanup during device removal, where runtime PM was enabled on probe but not properly disabled on remove. This could lead to clocks being disabled twice or in an inconsistent state if the device was runtime suspended during removal. The fix ensures the device is resumed before removal and runtime PM is properly disabled before clocks are turned off.
A use-after-free vulnerability in the Linux kernel's network team driver was resolved. The issue involved improper reuse of socket buffers (skb) after a queue override operation, leading to potential kernel memory corruption and panic. The flaw was due to incorrect handling of dev_queue_xmit() results and skb ownership, causing a slab-use-after-free error detected by KASAN. This vulnerability could cause kernel crashes and instability.
A vulnerability in the Linux kernel's regulator subsystem was resolved involving the function of_regulator_bulk_get_all(). This function returned an array with uninitialized supply name fields, which could lead to dereferencing uninitialized memory when the array is used by regulator_bulk_enable(). The fix involved copying supply names into the array's allocation to ensure proper initialization and memory safety.
A vulnerability in the Linux kernel's OP-TEE driver allowed TEE devices to be registered before full initialization, leading to potential use of uninitialized mutexes and NULL pointer dereferences. This occurred because tee_device_register() was called prematurely in optee_probe(), exposing devices to user and kernel space before the struct optee was fully set up. The issue has been fixed by deferring device registration until after complete initialization.
A memory leak vulnerability in the Linux kernel's sparx5 network driver was fixed. The issue involved sparx5_tc_matchall_replace() allocating memory for matchall filters without freeing it upon deletion, causing leaked entries. The fix ensures that the allocated entries are freed after being unlinked, preventing memory leaks.