CVE-2026-93252
Received Received - Intake

Circular Locking Dependency in Linux Kernel OCFS2

Vulnerability report for CVE-2026-93252, including description, CVSS score, EPSS score, affected products, exploitability, helpful resources, and attack-flow context.

Publication date: 2026-09-24

Last updated on: 2026-09-24

Assigner: kernel.org

Description

In the Linux kernel, the following vulnerability has been resolved: ocfs2: fix circular locking dependency in ocfs2_init_acl() A lockdep warning indicates a circular locking dependency between `&oi->ip_xattr_sem` and `&journal->j_trans_barrier`: WARNING: possible circular locking dependency detected is trying to acquire lock: (&oi->ip_xattr_sem){++++}-{4:4}, at: ocfs2_init_acl+0x2fd/0x7e0 fs/ocfs2/acl.c:367 but task is already holding lock: (&journal->j_trans_barrier){.+.+}-{4:4}, at: ocfs2_start_trans+0x3ab/0x700 fs/ocfs2/journal.c:369 The deadlock involves two code paths: Path 1 (setxattr) where `ocfs2_xattr_set()` acquires `ip_xattr_sem` (write) and then starts a transaction, which acquires `j_trans_barrier` (read); and Path 2 (mkdir/mknod) where `ocfs2_mknod()` starts a transaction (`j_trans_barrier` read) and then calls `ocfs2_init_acl()`, which attempts to acquire `ip_xattr_sem` (read) on the parent directory to retrieve the default ACL. Because rw_semaphores are subject to writer priority, a pending writer on `j_trans_barrier` (e.g., the journal commit thread) can cause Path 1 to block, while Path 2 is blocked waiting for Path 1 to release `ip_xattr_sem`. The patch fixes the lock ordering by precomputing the ACL state before starting the OCFS2 transaction, while preserving POSIX ACL storage semantics and the existing inode/security initialization order. By reading the parent directory's default ACL and preparing the new inode's ACLs outside the transaction, `ip_xattr_sem` is always acquired before `j_trans_barrier`. `struct ocfs2_acl_state` encapsulates the prepared ACL state, while `ocfs2_acl_init_prepare()` and `ocfs2_acl_init_release()` avoid code duplication between `ocfs2_mknod()` and `ocfs2_init_security_and_acl()`. `ocfs2_calc_xattr_init()` and `ocfs2_init_acl()` use this precomputed state, removing internal `ip_xattr_sem` acquisition and redundant disk reads. Additionally, remove the `ip_xattr_sem` acquisition from `ocfs2_xattr_set_handle()`. This function is only used while initializing a new inode that has not yet been inserted into the inode hash or attached to a dentry, meaning there is no risk of concurrent access and the lock is unnecessary.

CVSS Scores

EPSS Scores

Probability:
Percentile:

Meta Information

Published
2026-09-24
Last Modified
2026-09-24
Generated
2026-09-25
AI Q&A
2026-09-24
EPSS Evaluated
N/A
NVD
EUVD

Affected Vendors & Products

Showing 1 associated CPE
Vendor Product Version / Range
oracle ocfs2 *

Helpful Resources

Exploitability

CWE
CWE Icon
KEV
KEV Icon
CWE ID Description
CWE-UNKNOWN

Attack-Flow Graph

AI Quick Actions

Instant insights powered by AI
Executive Summary

This is a Linux kernel vulnerability involving a circular locking dependency in the OCFS2 filesystem. The issue occurs when two code paths attempt to acquire locks in conflicting orders. One path tries to get a write lock on ip_xattr_sem then a read lock on j_trans_barrier, while another path does the reverse. This can lead to a deadlock where both paths wait for each other to release locks.

Detection Guidance

This vulnerability is specific to the Linux kernel's OCFS2 filesystem and involves a circular locking dependency. Detection requires checking kernel logs for lockdep warnings related to ip_xattr_sem and j_trans_barrier. Use dmesg or journalctl to search for lockdep warnings: dmesg | grep -i "circular locking dependency" or journalctl -k | grep -i "locking dependency"

Impact Analysis

This vulnerability could cause system hangs or crashes when using OCFS2 filesystem operations that involve ACLs. Specifically, operations like setxattr, mkdir, or mknod might trigger deadlocks, leading to unresponsive systems or kernel panics. It primarily affects systems using OCFS2 with ACL features enabled.

Compliance Impact

This vulnerability does not directly affect compliance with GDPR, HIPAA, or similar standards. It is a Linux kernel locking dependency issue in the OCFS2 filesystem that could lead to deadlocks but does not involve data exposure, integrity, or access control violations that these regulations typically address.

Mitigation Strategies

Apply the kernel patch that resolves the circular locking issue in OCFS2. Update your Linux kernel to a version containing the fix for CVE-2026-93252. Monitor system logs for lockdep warnings after applying the patch to ensure the issue is resolved.

Chat Assistant

Ask questions about this CVE
Hi! I’m here to help you understand CVE-2026-93252. Ask me anything about the vulnerability, its impact, or mitigation strategies.
0/70

EPSS Chart