* [PATCH] coccinelle: locks: Add must_hold.cocci
@ 2026-11-19 21:07 Marco Elver
2026-11-19 21:31 ` Bart Van Assche
0 siblings, 1 reply; 2+ messages in thread
From: Marco Elver @ 2026-11-19 21:07 UTC (permalink / raw)
To: elver
Cc: Julia Lawall, Nicolas Palix, linux-kernel, cocci, kasan-dev,
Bart Van Assche
Clang's context analysis treats lockdep_assert_held*() as an assumption
that the lock is held. A function that asserts instead of being
annotated with __must_hold() therefore passes the analysis, but its
callers are never checked.
Add a script that reports functions which assert on all paths that a
lock is held, where the lock can be named in a function attribute (it is
reachable from a parameter or is a global lock), and which lack a
__must_hold*() or __releases*() annotation.
For example, on v7.4-rc2:
kernel/locking/rwsem.c:396:1-20: rwsem_del_waiter() asserts &sem->wait_lock is held but lacks __must_hold(&sem->wait_lock)
kernel/locking/rwsem.c:437:1-20: rwsem_mark_wake() asserts &sem->wait_lock is held but lacks __must_hold(&sem->wait_lock)
kernel/futex/pi.c:919:1-20: fixup_pi_state_owner() asserts q->lock_ptr is held but lacks __must_hold(q->lock_ptr)
drivers/nvme/host/fabrics.c:650:1-20: nvmf_lookup_transport() asserts &nvmf_transports_rwsem is held but lacks __must_hold(&nvmf_transports_rwsem)
Limitations:
- Annotations on a prototype in another file are not seen; non-static
functions are reported with "check prototype".
- Annotations are detected textually and are not matched against the
asserted lock.
- Functions that require a lock without asserting it are not found.
Cc: Bart Van Assche <bvanassche@acm.org>
Link: https://lore.kernel.org/all/CANpmjNNM=qBJMvBkRu-WbhKA0hnkb_Bk8fyF9DTTsVmENDvZuQ@mail.gmail.com/
Signed-off-by: Marco Elver <elver@google.com>
---
scripts/coccinelle/locks/must_hold.cocci | 100 +++++++++++++++++++++++
1 file changed, 100 insertions(+)
create mode 100644 scripts/coccinelle/locks/must_hold.cocci
diff --git a/scripts/coccinelle/locks/must_hold.cocci b/scripts/coccinelle/locks/must_hold.cocci
new file mode 100644
index 000000000000..ba45544afc46
--- /dev/null
+++ b/scripts/coccinelle/locks/must_hold.cocci
@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/// Find functions that unconditionally assert with lockdep that a lock is
+/// held, but lack the corresponding __must_hold() annotation. For such
+/// functions the compiler's context analysis trusts the assertion instead of
+/// checking the callers.
+///
+/// Only locks that can be named in a function attribute are reported, i.e.
+/// those reachable from a parameter or a global lock (&lock). Assertions on
+/// locks reached through local aliases are skipped.
+//
+// Confidence: Moderate
+// Comments: Annotations on a prototype in another file are not seen; such
+// functions are reported with "check prototype".
+// Options: --no-includes --include-headers
+
+virtual report
+virtual org
+
+@initialize:python@
+@@
+
+import re
+
+def squash(s):
+ return re.sub(r'\s+', '', s)
+
+def missing_must_hold(f, ps, E, pf, p):
+ e = squash(E)
+ m = re.match(r'[&(]*(\w+)', e)
+ if not m:
+ return None
+ params = re.findall(r'(\w+)\s*(?:\[[^\]]*\]\s*)*(?:,|$)', str(ps))
+ if m.group(1) not in params and not re.fullmatch(r'&\w+', e):
+ return None # Local alias: cannot be named in an attribute.
+
+ with open(pf[0].file, errors='replace') as fp:
+ lines = fp.readlines()
+ first, last = int(pf[0].line), int(p[0].line)
+
+ # Attributes between the declarator and the assertion.
+ hdr = ''.join(lines[first - 1:last - 1])
+ if re.search(r'__(must_hold|must_hold_shared|releases|releases_shared|'
+ r'context_unsafe|no_context_analysis)\b', hdr):
+ return None
+
+ # Attributes on a prototype in the same file.
+ for d in re.finditer(r'\b%s\s*\([^;{}]*\)([^;{}]*);' % re.escape(f),
+ ''.join(lines)):
+ if '__must_hold' in d.group(1):
+ return None
+
+ static = 'static' in ''.join(lines[max(first - 3, 0):first])
+ shared = 'lockdep_assert_held_read' in lines[last - 1]
+ return "%s() asserts %s is held but lacks __must_hold%s(%s)%s" % (
+ f, e, "_shared" if shared else "", e,
+ "" if static else "; check prototype")
+
+@r@
+identifier f;
+parameter list ps;
+expression E;
+position pf, p;
+@@
+
+f@pf(ps)
+{
+ ...
+(
+ lockdep_assert_held@p(E);
+|
+ lockdep_assert_held_write@p(E);
+|
+ lockdep_assert_held_read@p(E);
+)
+ ...
+}
+
+@script:python depends on report@
+f << r.f;
+ps << r.ps;
+E << r.E;
+pf << r.pf;
+p << r.p;
+@@
+
+msg = missing_must_hold(f, ps, E, pf, p)
+if msg:
+ coccilib.report.print_report(p[0], msg)
+
+@script:python depends on org@
+f << r.f;
+ps << r.ps;
+E << r.E;
+pf << r.pf;
+p << r.p;
+@@
+
+msg = missing_must_hold(f, ps, E, pf, p)
+if msg:
+ coccilib.org.print_todo(p[0], msg)
--
2.56.1.750.gf70dc682cf-goog
^ permalink raw reply [flat|nested] 2+ messages in thread* Re: [PATCH] coccinelle: locks: Add must_hold.cocci
2026-11-19 21:07 [PATCH] coccinelle: locks: Add must_hold.cocci Marco Elver
@ 2026-11-19 21:31 ` Bart Van Assche
0 siblings, 0 replies; 2+ messages in thread
From: Bart Van Assche @ 2026-11-19 21:31 UTC (permalink / raw)
To: Marco Elver; +Cc: Julia Lawall, Nicolas Palix, linux-kernel, cocci, kasan-dev
On 11/19/26 1:07 PM, Marco Elver wrote:
> Clang's context analysis treats lockdep_assert_held*() as an assumption
> that the lock is held. A function that asserts instead of being
> annotated with __must_hold() therefore passes the analysis, but its
> callers are never checked.
Hi Marco,
The LLM I asked for help with reviewing this patch provided the
following feedback (not sure all of this is correct):
> drivers/nvme/host/fabrics.c:650:1-20: nvmf_lookup_transport()
asserts &nvmf_transports_rwsem is held but lacks
__must_hold(&nvmf_transports_rwsem)
This suggestion is wrong. The only caller of nvmf_lookup_transport()
holds nvmf_transports_rwsem as a reader:
down_read(&nvmf_transports_rwsem);
ops = nvmf_lookup_transport(opts);
Hence, the correct annotation is __must_hold_shared() and adding
__must_hold() would trigger a new context analysis warning in the
caller. lockdep_assert_held() succeeds if a lock is held in any mode, so
for that macro the script cannot know which of the two annotations is
appropriate. How about reporting "lacks __must_hold() or
__must_hold_shared()" for lockdep_assert_held() and keeping the specific
suggestion for the _write() and _read() variants only?
> + # Attributes on a prototype in the same file.
> + for d in re.finditer(r'\b%s\s*\([^;{}]*\)([^;{}]*);' % re.escape(f),
> + ''.join(lines)):
> + if '__must_hold' in d.group(1):
> + return None
It seems to me that this test never succeeds. '[^;{}]*\)' is greedy and
hence matches up to the last ')' before the semicolon. That is the
closing parenthesis of the attribute itself, so group 1 is empty:
>>> import re
>>> s = 'static int foo(struct x *x) __must_hold(&x->lock);'
>>> re.search(r'\bfoo\s*\([^;{}]*\)([^;{}]*);', s).group(1)
''
The result is the same if the attribute occurs on the next line. I think
that this will cause functions that are only annotated on a forward
declaration to be reported. Testing d.group(0) instead of d.group(1)
would fix this. Additionally, should this test use the same attribute
list as the test above it (__releases*(), __context_unsafe(),
__no_context_analysis)?
> +@r@
> +identifier f;
> +parameter list ps;
> +expression E;
> +position pf, p;
> +@@
> +
> +f@pf(ps)
> +{
> + ...
> +(
> + lockdep_assert_held@p(E);
> +|
> + lockdep_assert_held_write@p(E);
> +|
> + lockdep_assert_held_read@p(E);
> +)
> + ...
> +}
Is my understanding correct that the default for a rule without
'-', '+' or '*' annotations is "exists" instead of "forall"? If so, this
rule also matches conditional assertions, e.g. this code from
fs/btrfs/backref.c:
if (!current->journal_info)
lockdep_assert_held(&fs_info->commit_root_sem);
__must_hold() would be wrong for such functions, and the above does not
match "assert on all paths" from the patch description nor
"unconditionally assert" from the comment at the top of the script.
Please consider specifying "forall" or "exists" explicitly.
Additionally, this rule matches functions that acquire E themselves
before asserting that it is held. Can these be excluded, e.g. with a
"when" constraint on the first "..."?
> + m = re.match(r'[&(]*(\w+)', e)
> + if not m:
> + return None
> + params = re.findall(r'(\w+)\s*(?:\[[^\]]*\]\s*)*(?:,|$)', str(ps))
> + if m.group(1) not in params and not re.fullmatch(r'&\w+', e):
> + return None # Local alias: cannot be named in an attribute.
Only the first identifier of E is checked. Expressions like
&tbl->locks[idx] with 'tbl' a parameter and 'idx' a local variable are
reported although these cannot be used as an attribute argument. Would
it be possible to verify that all identifiers that occur in E are either
parameters or struct member names?
The 'params' regular expression does not extract the correct name for
all parameter declarations:
'void (*cb)(struct foo *), int n' -> ['n']
'int (*fn)(void *data, int x)' -> ['data']
'struct task_struct *p __maybe_unused' -> ['__maybe_unused']
Is there a way to let Coccinelle provide the parameter names instead of
extracting these with a regular expression?
> + static = 'static' in ''.join(lines[max(first - 3, 0):first])
This is a substring search across three lines, so e.g. a
"static int counter;" declaration two lines above a non-static function
suppresses the "check prototype" hint. Can 'static' be matched in the
SmPL rule instead?
Some further remarks:
- lockdep_assert_held_once() and assert_spin_locked() are not handled
(71 respectively 256 occurrences in .c files in my tree), nor are
wrappers like lockdep_assert_wiphy(). Please either add these or
mention this in the "Limitations" section.
- Global locks are only recognized if E has the form "&name".
Expressions like &init_mm.mmap_lock are skipped silently. That's fine
with me but it is not mentioned in the comment at the top.
- The patch description mentions that functions with a __must_hold*()
or __releases*() annotation are skipped. The script also skips
functions annotated with __context_unsafe() or __no_context_analysis.
Thanks,
Bart.
^ permalink raw reply [flat|nested] 2+ messages in thread
end of thread, other threads:[~2026-11-19 21:31 UTC | newest]
Thread overview: 2+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2026-11-19 21:07 [PATCH] coccinelle: locks: Add must_hold.cocci Marco Elver
2026-11-19 21:31 ` Bart Van Assche
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox
all inboxes | Powered by JetHome®