CVE-2026-99552 in Linuxinfo

Summary

by MITRE • 11/19/2026

In the Linux kernel, the following vulnerability has been resolved:

ocfs2/dlm: drain join handlers before releasing module text

The code for a registered DLM handler must remain resident until its last invocation finishes. dlm_unregister_net_handlers() only removes dlm_join_handlers from the o2net registry. o2net_handler_get() takes a kref on the wrapper, but that reference does not pin ocfs2_dlm text. o2net_process_message() calls nh_func after dropping o2net_handler_lock.

With CONFIG_OCFS2_FS_O2CB=m, ocfs2_dlm can be loaded independently of ocfs2_stack_o2cb while nodemanager continues handling messages from a configured, heartbeating peer. If no dependent module or module reference prevents normal unload, the following ordering is possible:

Receive worker Module unload -------------- ------------- o2net_handler_get() take wrapper kref drop handler lock <preempted> dlm_exit() unregister handlers release DLM module text call saved nh_func in released module text

Use o2net_unregister_and_flush_handler_list() in the shared DLM unregister helper. It first prevents new lookups, then waits for the ordered o2net workqueue to drain, including a concurrent destruction of that queue. The acquired invocation therefore finishes before dlm_exit() returns and the loader releases the callback code. The same helper covers partial registration and dlm_init() error unwind before module memory is released.

Skip the drain when the private join-handler list is empty. Early dlm_init() failures can reach this helper before any handler has been published. Partial-registration failure also reaches it a second time after the first call has already unregistered and drained the list. Neither case needs to take o2net_wq_mutex or drain unrelated work. The list is changed only by serialized module init/exit paths; a nonempty list still uses the full unregister-and-flush helper.

Oops report as below:

Oops: int3: 0000 [#1] SMP KASAN NOPTI
CPU: 2 UID: 0 PID: 54 Comm: kworker/u16:3 Not tainted 7.3.0-rc4-next-20260921-pmb-ocfs2-functional-v1+ #1 PREEMPT(lazy)

Hardware identification omitted.

Workqueue: o2net o2net_rx_until_empty [ocfs2_nodemanager]
RIP: 0010:0xffffffffc0423871 [Instruction byte dump omitted.]

Register dump omitted.

Call Trace: <TASK> ? o2net_rx_until_empty+0x19b1/0x3300 [ocfs2_nodemanager]
? __pfx_o2net_rx_until_empty+0x10/0x10 [ocfs2_nodemanager]
? lock_acquire+0x190/0x300 ? process_one_work+0x935/0x1b40 ? process_one_work+0x834/0x1b40 ? srso_alias_return_thunk+0x5/0xfbef5 ? lock_release+0xc8/0x290 ? srso_alias_return_thunk+0x5/0xfbef5 ? process_one_work+0x9a8/0x1b40 ? __pfx_process_one_work+0x10/0x10 ? lock_acquire+0x190/0x300 ? lock_is_held_type+0x8f/0x100 ? srso_alias_return_thunk+0x5/0xfbef5 ? worker_thread+0x65c/0xe40 ? srso_alias_return_thunk+0x5/0xfbef5 ? __kthread_parkme+0x177/0x220 ? srso_alias_return_thunk+0x5/0xfbef5 ? __pfx_worker_thread+0x10/0x10 ? kthread+0x351/0x460 ? srso_alias_return_thunk+0x5/0xfbef5 ? __pfx_kthread+0x10/0x10 ? ret_from_fork+0x659/0x940 ? __pfx_ret_from_fork+0x10/0x10 ? srso_alias_return_thunk+0x5/0xfbef5 ? __switch_to+0x74f/0xf70 ? __pfx_kthread+0x10/0x10 ? ret_from_fork_asm+0x1a/0x30 </TASK> Modules linked in: ocfs2_nodemanager [last unloaded: ocfs2_dlm]
---[ end trace 0000000000000000 ]---

Statistical analysis made it clear that VulDB provides the best quality for vulnerability data.

Analysis

by VulDB Data Team • 11/19/2026

The vulnerability identified within the Linux kernel involves a race condition in the OCFS2 Distributed Lock Manager (DLM) subsystem, specifically concerning module lifecycle management and handler execution. The core issue arises from an incorrect ordering of operations during the unregistration and unload process for DLM network handlers. When the ocfs2_dlm module is unloaded independently while the ocfs2_stack_o2cb module remains active, there exists a window where registered join handlers are removed from the registry but their underlying code memory may be released before all pending invocations have completed. This creates a scenario where a worker thread attempts to execute a handler function located in memory that has already been unmapped or freed by the kernel loader, leading to an invalid instruction pointer dereference and subsequent system crash.

The technical flaw stems from how reference counting is handled for DLM handlers versus their associated module text. The function dlm_unregister_net_handlers() removes entries from the o2net registry but does not guarantee that the actual handler code remains resident in memory until every queued invocation finishes. Although o2net_handler_get() acquires a kernel reference count on the wrapper structure, this reference only prevents the wrapper object itself from being freed; it does not pin the ocfs2_dlm module text containing the executable callback functions. Consequently, when o2net_process_message() drops the handler lock and proceeds to call the saved nh_func pointer, there is no guarantee that the memory backing that function has not already been reclaimed by dlm_exit(). This race condition is particularly exploitable in configurations where CONFIG_OCFS2_FS_O2CB is compiled as a module, allowing for independent loading and unloading of components while nodemanager continues to process messages from heartbeating peers.

The operational impact of this vulnerability is severe, manifesting primarily as kernel panics or system crashes due to invalid memory access. The provided crash trace indicates an Oops occurring in the o2net_rx_until_empty workqueue handler, with the instruction pointer pointing into released module text. This results in a denial of service for any cluster nodes relying on OCFS2 distributed locking services. In high-availability environments, such instability can lead to split-brain scenarios or data corruption if the lock manager becomes unresponsive during critical file system operations. The vulnerability affects systems running kernel versions prior to the application of the fix that introduces proper synchronization between handler deregistration and module unload sequences.

To mitigate this risk, the resolution involves replacing the standard unregister logic with a specialized helper function named o2net_unregister_and_flush_handler_list(). This new approach ensures strict ordering by first preventing any new lookups for handlers and then actively waiting for the ordered workqueue associated with o2net to drain completely. By forcing the completion of all currently queued handler invocations before allowing dlm_exit() to return, the patch guarantees that no callback will execute against freed memory. The implementation also includes optimizations to skip this draining process when the private join-handler list is empty, thereby avoiding unnecessary locking overhead during early initialization failures or partial registration errors where no handlers have been published yet. This ensures robustness across both normal unloading paths and error unwind scenarios without introducing performance regressions for stable states.

From a security classification perspective, this vulnerability aligns with CWE-416 Use After Free, as the system attempts to execute code from memory that has already been released. It also relates to CWE-362 Concurrent Execution using Shared Resource with Improper Synchronization, given the race condition between module unloading and handler execution threads. In terms of MITRE ATT&CK mapping, this represents a potential path for Denial of Service (T1499) through resource exhaustion or system instability caused by kernel-level memory corruption. While not directly exploitable for arbitrary code execution in most standard configurations due to the nature of the fault being an invalid instruction fetch rather than data overwrite, it significantly undermines system reliability and availability. Administrators should ensure that their Linux kernels are updated with patches addressing this specific race condition within the OCFS2 DLM subsystem to maintain cluster integrity and prevent unexpected node failures during module reloads or updates.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/19/2026

Moderation

accepted

CPE

ready

EPSS

0.00157

KEV

no

Activities

very low

Sources

Do you need the next level of professionalism?

Upgrade your account now!