Skip to main content
VulnerabilityPublished Updated

CVE-2026-93252: Linux kernel · ocfs2: fix circular locking dependency in ocfs2_init_acl()

Affects Linux kernelSource CVE Database V5

0

Not known to be exploited · fixed in f8747d81aa6d3efe3ee339a9d912ff3ca6e4d758 : update Linux kernel when convenient.

Data as of 26 Oct 2026, 12:55 UTC

Severity
Unrated

Rated by Threat Radar · CVSS not yet scored by NVD

EPSS
0.2% chance of exploitation in 30 days – higher than 11% of CVEsExploit Prediction Scoring System: the likelihood attackers will use this flaw soon.
Patch
Available – fixed in f8747d81aa6d3efe3ee339a9d912ff3ca6e4d758, caf3056936fb8b5ce92e419cf8b246ce9c437343, bd7c05fb4a4776dff5a87b19008d28458647d15d +9

Exploitation evidence

  1. Disclosed: evidence found.

    CVE published 24 Sep 2026

  2. Detectable: no evidence on record.

    No public nuclei template indexed

  3. Weaponised: no evidence on record.

    No public exploit code indexed in Metasploit or Exploit-DB

  4. Exploited in the wild: no evidence on record.

    Not in CISA KEV and no source reports exploitation

  5. Observed by OffSeq Mirage: no evidence on record.

    No attack traffic recorded by OffSeq Mirage sensors

A missing step is not evidence of safety. Sources: cve.org (opens in a new tab), the Metasploit, Exploit-DB and nuclei-templates index as of 26 Oct 2026.

What to do

Upgrade to a fixed release listed under Affected software.

Affected software

ProductAffectedFixed in
LinuxLinuxAffected
  • >=3.18.111 <3.19
  • >=4.4.134 <4.5
  • >=4.9.104 <4.10
  • >=4.14.37 <4.15
Fixed in
  • f8747d81aa6d3efe3ee339a9d912ff3ca6e4d758
  • caf3056936fb8b5ce92e419cf8b246ce9c437343
  • bd7c05fb4a4776dff5a87b19008d28458647d15d
  • 8931403ee3dcfe8a24a5267efec9d9460ab7a1b5
  • 4936d4464d1ae10b5fbba64374085a0dcc060560
  • 1222f7a3183b35c0c566899fdaead5c7c4043076
  • 8d88f52fbbbcc18adf4091a955511d0cf605bf11
  • 5b7b3c50c39ad0dc27e7418981e01c4183273f89
  • 4.15
  • 4.10
  • 4.5
  • 3.19
LinuxLinuxAffected
  • =4.16
Fixed in–

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.

References

Community reviews

Loading reviews…