A vulnerability in the Linux kernel's drm_bridge_add() function was resolved. The issue involved modifying linked lists without holding the required bridge_lock, potentially causing list corruption when re-adding a previously removed bridge. This could affect the stability of the drm bridge subsystem.
A vulnerability in the Linux kernel related to namespace handling and locked mounts has been resolved. Locked mounts are designed to protect underlying files and directories from being revealed. The flaw allowed an unlocked ancestor mount to expire a locked mount beneath it, potentially exposing protected directories. The fix ensures that locked mounts are not expired independently but only as part of their parent mount, preventing the exposure of hidden files. Lazy unmounts still remove the entire mount tree including locked mounts. This vulnerability is addressed by changes to the expiry logic and mount locking behavior.
A vulnerability in the Linux kernel's mount namespace handling has been resolved. The flaw involves attach_recursive_mnt() not properly considering the topmost mount in a mount namespace file chain, leading to incorrect mountpoint attachment. This can cause mounts to become inaccessible and prevent synchronous unmounting due to lingering child mounts.
A vulnerability in the Linux kernel namespace handling was resolved involving the order of unhashing a dentry before detaching mounts on it. The issue allowed a race condition during unlink(), rmdir(), and rename() operations where the dentry remained hashed and visible between detach_mounts() and d_delete(), potentially exposing mount points that should have been hidden. This race window could be exploited by concurrent lookups to observe mounts that were supposed to be detached. The fix changes the order to unhash the dentry before detaching mounts, preventing lookups from seeing stale mount information.
A vulnerability in the Linux kernel's net/sched subsystem was resolved that involved improper handling of unterminated algorithm names in the em_text module. The flaw allowed an out-of-bounds read and potential kernel memory disclosure when a 16-byte algorithm name without a NUL terminator was passed, causing the kernel to read adjacent memory and invoke a usermode helper with unintended data. The issue was fixed by rejecting attributes lacking a NUL terminator within the expected byte size.
A vulnerability in the Linux kernel's pivot_root() function involves improper checks of mount points before reading their parent mounts. The issue arises when new_root or the caller's root is a file descriptor to a mount that has been unmounted but still kept alive by the file descriptor, potentially leading to a use-after-free condition. The vulnerability causes a read operation on freed memory, resulting in a kernel bug detected by KASAN. The fix involves verifying that both mounts are in the caller's mount namespace before accessing their parents, preventing the unsafe read. All error paths return EINVAL, so no other side effects occur.
A vulnerability in the Linux kernel's drm/vc4 component involved a memory leak where the BO cache size list was not freed during teardown, leading to resource leakage on every unbind operation. This issue has been resolved by ensuring the size list is freed properly in vc4_bo_cache_destroy().
A vulnerability in the Linux kernel's cxgb4 driver related to ch_ktls handling has been resolved. The issue involves improper locking when erasing entries from a shared tid_list array, which can lead to a spinlock deadlock due to softirqs not being disabled during xa_erase operations. The fix involves using xa_erase_bh() to properly disable softirqs and prevent lock contention.
A vulnerability in the Linux kernel's dcache handling has been resolved. The issue involves improper handling of mountpoints on dentries that are being removed, allowing a bind mount of a directory being removed to be moved beneath an existing mount. This causes the mount to remain on the removed directory indefinitely, preventing its detachment. The flaw arises due to a race condition between detach_mounts() and d_delete(), where the victim dentry is still hashed and not properly locked during mount operations.
A use-after-free vulnerability in the Linux kernel's AMT relay component was resolved. The issue involved queuing a packet buffer (skb) referencing a tunnel that could be freed before the packet was processed, leading to a use-after-free in amt_dev_xmit(). The fix changes the relay's General Query sending method to avoid queuing and referencing freed tunnels, removing unsafe skb control block usage. This eliminates the use-after-free condition and related kernel warnings.
A use-after-free (UaF) vulnerability in the Linux kernel's cgroup cpuset subsystem was resolved by avoiding direct access to a potentially stale pointer in the is_in_v2_mode() function. The fix introduces a new flag to safely indicate cpuset v2 mode, preventing unsafe memory access during cgroup filesystem rebind operations.
A vulnerability in the Linux kernel's XFS filesystem handling was resolved that involved improper management of reflink flags during file extent exchanges. The flaw caused reflink flags to be incorrectly transferred between files during certain extent exchange operations, potentially leading to data corruption due to writes occurring in place instead of copy-on-write. The fix stops exchanging reflink flags during these operations and ensures both inodes retain the flag as appropriate. The vulnerability affects the XFS_IOC_SWAPEXT operation as well, which was corrected by setting reflink flags on both inodes and ensuring copy-on-write forks exist. The reflink flags remain set until explicitly removed by specific operations.
A vulnerability in the Linux kernel related to mount locking for automounts across user namespaces has been resolved. The issue involved improper locking of mounts when mounts are propagated across user namespaces, causing the host's mount to be locked instead of the child's copy. This could prevent the host from changing mount flags correctly. The fix ensures that the lock is applied to the mount in the namespace where the mount actually occurs, preserving correct mount flag management.
A vulnerability in the Linux kernel's namei component allowed refwalk operations to reveal overmounted entries due to a race condition when a mountpoint was unlinked. This could cause a refwalk to expose underlying filesystem entries that should have been hidden. The issue was addressed by adding checks to detect dentries marked as unlinked during refwalk traversal, preventing exposure of detached mounts.
A vulnerability in the Linux kernel's unshare system call was resolved. The issue involved dropping active namespace references that were never taken, leading to reference count inconsistencies. This could cause namespaces the caller lives in to no longer be listed by listns(). The problem occurred when set_cred_ucounts() failed during ksys_unshare(), causing improper reference decrementing. The fix involved properly freeing nsproxy structures that were prepared but never installed.
A vulnerability in the Linux kernel's gpio: exar driver was resolved by correcting the initialization order of an ID before registering its cleanup action. The issue involved improper handling of allocated IDs during failure in registering cleanup actions, potentially causing ID leaks and incorrect freeing of device IDs.
A vulnerability in the Linux kernel's namespace handling allowed automounts to be added below a mount that is not in the caller's mount namespace. This could lead to a kernel crash (general protection fault) due to a null pointer dereference when accessing certain filesystem layers via fanotify. The issue arises because an internal mount flag (MNT_NS_INTERNAL) was incorrectly treated as a valid mount namespace, causing unsafe operations. The flaw has been resolved by using a safer check that rejects unmounted and internal mounts, preventing the crash and restoring expected behavior.
A vulnerability in the Linux kernel's statmount functionality allowed reading the parent of an unmounted mount under mount_lock, potentially leading to dereferencing a mount that has already been freed. This issue arises because statmount_mnt_basic() reads the parent mount's IDs without proper synchronization when the mount has been unmounted but kept alive by a file descriptor. The flaw has been resolved in the Linux kernel.
A vulnerability in the Linux kernel's mount notification system allows a mount to be queued multiple times for notifications, leading to use-after-free memory access. This occurs because mnt_notify_add() does not check if a mount is already on the notification list, causing corrupted list state and potential kernel memory errors. The issue affects mounts with the MNT_SHRINKABLE flag, such as submounts of NFS, AFS, CIFS, and tracefs. The flaw has been resolved by initializing the notification list properly and preventing duplicate queueing of mounts.
A vulnerability in the Linux kernel's namespace handling was resolved by preventing the MNT_UMOUNT flag from being inherited in clone_mnt(). The issue involved mounts that were lazily unmounted but kept alive by file descriptors still being copied with the MNT_UMOUNT flag set, causing multiple bugs including mount namespace leaks, improper unmount behavior, and corrupted mount propagation. The fix adds MNT_UMOUNT to internal flags so it is not copied during cloning, preventing these issues.