Compiler-Based Context- and Locking-Analysis
Subsystems (31)
Marco Elver
maintainerv4 cover Compiler-Based Context- and Locking-Analysis
Context Analysis is a language extension, which enables statically checking that required contexts are active (or inactive) by acquiring and releasing user-definable "context guards". An obvious application is lock-safety checking for the kernel's various synchronization primitives (each of which represents a "context guard"), and checking that locking rules are not violated.
The feature requires Clang 22 (unreleased) or later. Clang originally called the feature "Thread Safety Analysis" [1]. This was later changed and the feature became more flexible, gaining the ability to define custom "capabilities". Its foundations can be found in "Capability Systems" [2], used to specify the permissibility of operations to depend on some "capability" being held (or not held).
Because the feature is not just able to express "capabilities" related to synchronization primitives, and "capability" is already overloaded in the kernel, the naming chosen for the kernel departs from Clang's "Thread Safety" and "capability" nomenclature; we refer to the feature as "Context Analysis" to avoid confusion. The internal implementation still makes references to Clang's terminology in a few places, such as -Wthread-safety being the warning option that also still appears in diagnostic messages.
Additional details can be found in the added kernel-doc documentation. An LWN article covered v2 of the series: https://lwn.net/Articles/1012990/
[1] https://clang.llvm.org/docs/ThreadSafetyAnalysis.html
[2] https://www.cs.cornell.edu/talc/papers/capabilities.pdf
=== Development Approach ===
Prior art exists in the form of Sparse's Context Tracking. Locking annotations on functions already exist sparsely, so the concept of analyzing locking rules is not foreign to the kernel's codebase.
However, Clang's analysis is more complete vs. Sparse's, with the typical trade-offs in static analysis: improved completeness is sacrificed for more possible false positives or additional annotations required by the programmer. Numerous options exist to disable or opt out certain code from analysis.
This series initially aimed to retain compatibility with Sparse, which can provide tree-wide analysis of a subset of the context analysis introduced, but it was later decided to drop Sparse compatibility. For the most part, the new (and old) keywords used for annotations remain the same, and many of the pre-existing annotations remain valid.
One big question is how to enable this feature, given we end up with a new dialect of C; two approaches have been considered:
A. Tree-wide all-or-nothing approach. This approach requires tree-wide
changes, adding annotations or selective opt-outs. Making more primitives context-analysis aware increases churn where maintainers are unfamiliar with the feature and the analysis is unable to deal with complex code patterns as-is.
Because we can't change the programming language (even if from one C dialect to another) of the kernel overnight, a different approach might cause less friction.
B. A selective, incremental, and much less intrusive approach.
Maintainers of subsystems opt in their modules or directories into context analysis (via Makefile):
CONTEXT_ANALYSIS_foo.o := y # foo.o only
CONTEXT_ANALYSIS := y # all TUs
Most (eventually all) synchronization primitives, and more context guards including ones that track "irq disabled", "preemption" disabled, etc. could be supported.
The approach taken by this series is B. This ensures that only subsystems where maintainers are willing to deal with any warnings are opted-in. Introducing the feature can be done incrementally, without large tree-wide changes and adding numerous opt-outs and annotations to the majority of code.
Note: Bart Van Assche concurrently worked on enabling -Wthread-safety:
https://lore.kernel.org/all/[email protected]/
Bart's work has shown what it might take to go with approach A (tree-wide, restricted to 'mutex' usage). This has shown that the analysis finds real issues when applied to enough subsystems! We hope this serves as motivation to eventually enable the analysis in as many subsystems as possible, particularly subsystems that are not as easily tested by CI systems and test robots.
=== Initial Uses ===
With this initial series, the following synchronization primitives are
supported: raw_spinlock_t, spinlock_t, rwlock_t, mutex, seqlock_t, bit_spinlock, RCU, SRCU (srcu_struct), rw_semaphore, local_lock_t, ww_mutex.
To demonstrate use of the feature on real kernel code, the series also enables context analysis for the following subsystems:
* kernel/kcov
* kernel/kcsan
* kernel/sched/
* lib/rhashtable
* lib/stackdepot
* mm/kfence
* security/tomoyo
* crypto/
The initial benefits are static detection of violations of locking rules. As more context guards are supported, we would see more static checking beyond what regular C can provide, all while remaining easy (and quick) to use via the Clang compiler.
Note: The kernel already provides dynamic analysis tools Lockdep and KCSAN for lock-safety checking and data-race detection respectively. Unlike those, Clang's context analysis is a compile-time static analysis with no runtime impact. The static analysis complements existing dynamic analysis tools, as it may catch some issues before even getting into a running kernel, but is *not* a replacement for whole-kernel testing with the dynamic analysis tools enabled!
=== Appendix ===
A Clang version that supports -Wthread-safety-pointer and the new alias-analysis of context-guard pointers is required (from this version onwards):
https://github.com/llvm/llvm-project/commit/7ccb5c08f0685d4787f12c3224a72f0650c5865e
The minimum required release version will be Clang 22.
This series is also available at this Git tree:
https://git.kernel.org/pub/scm/linux/kernel/git/melver/linux.git/log/?h=ctx-analysis/dev
=== Changelog ===
v4:
- Rename capability -> context analysis, per Linus's suggestion:
https://lore.kernel.org/all/CAHk-=wgd-Wcp0GpYaQnU7S9ci+FvFmaNw1gm75mzf0ZWdNLxvw@mail.gmail.com/
- Minor fixes.
v3: https://lore.kernel.org/all/[email protected]/
- Bump min. Clang version to 22+ (unreleased), which now supports:
* re-entrancy via __attribute__((reentrant_capability));
* basic form of capability alias analysis - which is the biggest improvement since v2.
This was the result of conclusions from this discussion:
https://lore.kernel.org/all/CANpmjNPquO=W1JAh1FNQb8pMQjgeZAKCPQUAd7qUg=5pjJ6x=Q@mail.gmail.com/
- Rename __asserts_cap/__assert_cap to __assumes_cap/__assume_cap.
- Switch to DECLARE_LOCK_GUARD_1_ATTRS().
- Add __acquire_ret and __acquire_shared_ret helper macros - can be used to define function-like macros that return objects which contains a held capabilities. Works now because of capability alias analysis.
- Add capability_unsafe_alias() helper, where the analysis rightfully points out we're doing strange things with aliases but we don't care.
- Support multi-argument attributes.
- Enable for kernel/sched/{core,fair}.c, kernel/kcsan.
- Drop drivers/tty changes (revisit later).
v2: https://lore.kernel.org/all/[email protected]/
- Remove Sparse context tracking support - after the introduction of Clang support, so that backports can skip removal of Sparse support.
- Remove __cond_lock() function-like helper.
- ww_mutex support.
- -Wthread-safety-addressof was reworked and committed in upstream Clang as -Wthread-safety-pointer.
- Make __cond_acquires() and __cond_acquires_shared() take abstract value, since compiler only cares about zero and non-zero.
- Rename __var_guarded_by to simply __guarded_by. Initially the idea was to be explicit about if the variable itself or the pointed-to data is guarded, but in the long-term, making this shorter might be better.
- Likewise rename __ref_guarded_by to __pt_guarded_by.
- Introduce common header warning suppressions - this is a better solution than guarding header inclusions with disable_ + enable_capability_analysis(). Header suppressions are disabled when selecting CONFIG_WARN_CAPABILITY_ANALYSIS_ALL=y. This bumps the minimum Clang version required to 20+.
- Make the data_race() macro imply disabled capability analysis. Writing capability_unsafe(data_race(..)) is unnecessarily verbose and data_race() on its own already indicates something subtly unsafe is happening. This change was made after analysis of a finding in security/tomoyo.
- Enable analysis in the following subsystems as additional examples of larger subsystem. Where it was obvious, the __guarded_by attribute was added to lock-guarded variables to improve coverage.
* drivers/tty
* security/tomoyo
* crypto/
RFC v1: https://lore.kernel.org/lkml/[email protected]
Marco Elver (35):
compiler_types: Move lock checking attributes to
compiler-context-analysis.h
compiler-context-analysis: Add infrastructure for Context Analysis
with Clang
compiler-context-analysis: Add test stub
Documentation: Add documentation for Compiler-Based Context Analysis
checkpatch: Warn about context_unsafe() without comment
cleanup: Basic compatibility with context analysis
lockdep: Annotate lockdep assertions for context analysis locking/rwlock, spinlock: Support Clang's context analysis
compiler-context-analysis: Change __cond_acquires to take return value locking/mutex: Support Clang's context analysis locking/seqlock: Support Clang's context analysis
bit_spinlock: Include missing <asm/processor.h>
bit_spinlock: Support Clang's context analysis
rcu: Support Clang's context analysis
srcu: Support Clang's context analysis
kref: Add context-analysis annotations
locking/rwsem: Support Clang's context analysis locking/local_lock: Include missing headers locking/local_lock: Support Clang's context analysis locking/ww_mutex: Support Clang's context analysis
debugfs: Make debugfs_cancellation a context guard struct
compiler-context-analysis: Remove Sparse support
compiler-context-analysis: Remove __cond_lock() function-like helper
compiler-context-analysis: Introduce header suppressions
compiler: Let data_race() imply disabled context analysis
MAINTAINERS: Add entry for Context Analysis
kfence: Enable context analysis
kcov: Enable context analysis
kcsan: Enable context analysis
stackdepot: Enable context analysis
rhashtable: Enable context analysis
printk: Move locking annotation to printk.c security/tomoyo: Enable context analysis
crypto: Enable context analysis
sched: Enable context analysis for core.c and fair.c
Documentation/dev-tools/context-analysis.rst | 146 +++++ Documentation/dev-tools/index.rst | 1 + Documentation/dev-tools/sparse.rst | 19 - Documentation/mm/process_addrs.rst | 6 +- MAINTAINERS | 11 + Makefile | 1 + crypto/Makefile | 2 + crypto/acompress.c | 6 +- crypto/algapi.c | 2 + crypto/api.c | 1 + crypto/crypto_engine.c | 2 +- crypto/drbg.c | 5 + crypto/internal.h | 2 +- crypto/proc.c | 3 + crypto/scompress.c | 24 +- .../net/wireless/intel/iwlwifi/iwl-trans.c | 4 +- .../net/wireless/intel/iwlwifi/iwl-trans.h | 6 +- .../intel/iwlwifi/pcie/gen1_2/internal.h | 5 +- .../intel/iwlwifi/pcie/gen1_2/trans.c | 4 +- fs/dlm/lock.c | 2 +- include/crypto/internal/acompress.h | 7 +- include/crypto/internal/engine.h | 2 +- include/linux/bit_spinlock.h | 24 +- include/linux/cleanup.h | 17 + include/linux/compiler-context-analysis.h | 429 +++++++++++++ include/linux/compiler.h | 2 + include/linux/compiler_types.h | 18 +- include/linux/console.h | 4 +- include/linux/debugfs.h | 12 +- include/linux/kref.h | 2 + include/linux/list_bl.h | 2 + include/linux/local_lock.h | 45 +- include/linux/local_lock_internal.h | 73 ++- include/linux/lockdep.h | 12 +- include/linux/mm.h | 33 +- include/linux/mutex.h | 35 +- include/linux/mutex_types.h | 4 +- include/linux/rcupdate.h | 90 +-- include/linux/refcount.h | 6 +- include/linux/rhashtable.h | 14 +- include/linux/rwlock.h | 22 +- include/linux/rwlock_api_smp.h | 43 +- include/linux/rwlock_rt.h | 44 +- include/linux/rwlock_types.h | 10 +- include/linux/rwsem.h | 66 +- include/linux/sched.h | 6 +- include/linux/sched/signal.h | 16 +- include/linux/sched/task.h | 5 +- include/linux/sched/wake_q.h | 3 + include/linux/seqlock.h | 24 + include/linux/seqlock_types.h | 5 +- include/linux/spinlock.h | 89 ++- include/linux/spinlock_api_smp.h | 34 +- include/linux/spinlock_api_up.h | 112 +++- include/linux/spinlock_rt.h | 37 +- include/linux/spinlock_types.h | 10 +- include/linux/spinlock_types_raw.h | 5 +- include/linux/srcu.h | 64 +- include/linux/srcutiny.h | 4 + include/linux/srcutree.h | 6 +- include/linux/ww_mutex.h | 22 +- kernel/Makefile | 2 + kernel/kcov.c | 36 +- kernel/kcsan/Makefile | 2 + kernel/kcsan/report.c | 11 +- kernel/printk/printk.c | 2 + kernel/sched/Makefile | 3 + kernel/sched/core.c | 89 ++- kernel/sched/fair.c | 9 +- kernel/sched/sched.h | 110 +++- kernel/signal.c | 4 +- kernel/time/posix-timers.c | 13 +- lib/Kconfig.debug | 44 ++ lib/Makefile | 6 + lib/dec_and_lock.c | 8 +- lib/rhashtable.c | 5 +- lib/stackdepot.c | 20 +- lib/test_context-analysis.c | 596 ++++++++++++++++++ mm/kfence/Makefile | 2 + mm/kfence/core.c | 20 +- mm/kfence/kfence.h | 14 +- mm/kfence/report.c | 4 +- mm/memory.c | 4 +- mm/pgtable-generic.c | 19 +- net/ipv4/tcp_sigpool.c | 2 +- scripts/Makefile.context-analysis | 11 + scripts/Makefile.lib | 10 + scripts/checkpatch.pl | 7 + scripts/context-analysis-suppression.txt | 33 + security/tomoyo/Makefile | 2 + security/tomoyo/common.c | 52 +- security/tomoyo/common.h | 77 +-- security/tomoyo/domain.c | 1 + security/tomoyo/environ.c | 1 + security/tomoyo/file.c | 5 + security/tomoyo/gc.c | 28 +- security/tomoyo/mount.c | 2 + security/tomoyo/network.c | 3 + tools/include/linux/compiler_types.h | 2 - 99 files changed, 2377 insertions(+), 592 deletions(-) create mode 100644 Documentation/dev-tools/context-analysis.rst create mode 100644 include/linux/compiler-context-analysis.h create mode 100644 lib/test_context-analysis.c create mode 100644 scripts/Makefile.context-analysis create mode 100644 scripts/context-analysis-suppression.txt
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Marco Elver
maintainerPATCH v4 1/35 compiler_types: Move lock checking attributes to compiler-context-analysis.h
The conditional definition of lock checking macros and attributes is about to become more complex. Factor them out into their own header for better readability, and to make it obvious which features are supported by which mode (currently only Sparse). This is the first step towards generalizing towards "context analysis".
No functional change intended.
---
v4:
* Rename capability -> context analysis.
--- include/linux/compiler-context-analysis.h | 32 +++++++++++++++++++++++ include/linux/compiler_types.h | 18 ++----------- 2 files changed, 34 insertions(+), 16 deletions(-) create mode 100644 include/linux/compiler-context-analysis.h
include/linux/compiler-context-analysis.h new file +32 -0
@@ -0,0 +1,32 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Macros and attributes for compiler-based static context analysis. +*/ + +#ifndef _LINUX_COMPILER_CONTEXT_ANALYSIS_H +#define _LINUX_COMPILER_CONTEXT_ANALYSIS_H + +#ifdef __CHECKER__ + +/* Sparse context/lock checking support. */ +# define __must_hold (x) __attribute__((context(x,1,1))) +# define __acquires (x) __attribute__((context(x,0,1))) +# define __cond_acquires (x) __attribute__((context(x,0,-1))) +# define __releases (x) __attribute__((context(x,1,0))) +# define __acquire (x) __context__(x,1) +# define __release (x) __context__(x,-1) +# define __cond_lock (x, c) ((c) ? ({ __acquire(x); 1; }) : 0) + +#else /* !__CHECKER__ */ + +# define __must_hold (x) +# define __acquires (x) +# define __cond_acquires (x) +# define __releases (x) +# define __acquire (x) (void)0 +# define __release (x) (void)0 +# define __cond_lock (x, c) (c) + +#endif /* __CHECKER__ */ + +#endif /* _LINUX_COMPILER_CONTEXT_ANALYSIS_H */
include/linux/compiler_types.h +2 -16
@@ -24,6 +24,8 @@# define BTF_TYPE_TAG (value)/* nothing */ #endif +#include <linux/compiler-context-analysis.h> +/* sparse defines __CHECKER__; see Documentation/dev-tools/sparse.rst */ #ifdef __CHECKER__/* address spaces */
@@ -34,14 +36,6 @@# define __rcu __attribute__((noderef, address_space(__rcu)))static inline void __chk_user_ptr (const volatile void __user *ptr) { }static inline void __chk_io_ptr (const volatile void __iomem *ptr) { } -/* context/locking */ -# define __must_hold (x) __attribute__((context(x,1,1))) -# define __acquires (x) __attribute__((context(x,0,1))) -# define __cond_acquires (x) __attribute__((context(x,0,-1))) -# define __releases (x) __attribute__((context(x,1,0))) -# define __acquire (x) __context__(x,1) -# define __release (x) __context__(x,-1) -# define __cond_lock (x,c) ((c) ? ({ __acquire(x); 1; }) : 0)/* other */ # define __force __attribute__((force))# define __nocast __attribute__((nocast))
@@ -62,14 +56,6 @@ static inline void __chk_io_ptr(const volatile void __iomem *ptr) { }# define __chk_user_ptr (x) (void)0# define __chk_io_ptr (x) (void)0 -/* context/locking */ -# define __must_hold (x) -# define __acquires (x) -# define __cond_acquires (x) -# define __releases (x) -# define __acquire (x) (void)0 -# define __release (x) (void)0 -# define __cond_lock (x,c) (c)/* other */ # define __force# define __nocast
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Marco Elver
maintainerPATCH v4 2/35 compiler-context-analysis: Add infrastructure for Context Analysis with Clang
In reply to Marco ElverContext Analysis is a language extension, which enables statically checking that required contexts are active (or inactive), by acquiring and releasing user-definable "context guards". An obvious application is lock-safety checking for the kernel's various synchronization primitives (each of which represents a "context guard"), and checking that locking rules are not violated.
Clang originally called the feature "Thread Safety Analysis" [1]. This was later changed and the feature became more flexible, gaining the ability to define custom "capabilities". Its foundations can be found in "Capability Systems" [2], used to specify the permissibility of operations to depend on some "capability" being held (or not held).
Because the feature is not just able to express "capabilities" related to synchronization primitives, and "capability" is already overloaded in the kernel, the naming chosen for the kernel departs from Clang's "Thread Safety" and "capability" nomenclature; we refer to the feature as "Context Analysis" to avoid confusion. The internal implementation still makes references to Clang's terminology in a few places, such as -Wthread-safety being the warning option that also still appears in diagnostic messages.
[1] https://clang.llvm.org/docs/ThreadSafetyAnalysis.html
[2] https://www.cs.cornell.edu/talc/papers/capabilities.pdf
See more details in the kernel-doc documentation added in this and subsequent changes.
Clang version 22+ is required.
---
v4:
* Rename capability -> context analysis.
v3:
* Require Clang 22 or later (reentrant capabilities, basic alias analysis).
* Rename __assert_cap/__asserts_cap -> __assume_cap/__assumes_cap (suggested by Peter).
* Add __acquire_ret and __acquire_shared_ret helper macros - can be used to define function-like macros that return objects which contains a held capabilities. Works now because of capability alias analysis.
* Add capability_unsafe_alias() helper, where the analysis rightfully points out we're doing strange things with aliases but we don't care.
* Support multi-argument attributes.
v2:
* New -Wthread-safety feature rename to -Wthread-safety-pointer (was -Wthread-safety-addressof).
* Introduce __capability_unsafe() function attribute.
* Rename __var_guarded_by to simply __guarded_by. The initial idea was to be explicit if the variable or pointed-to data is guarded by, but having a shorter attribute name is likely better long-term.
* Rename __ref_guarded_by to __pt_guarded_by (pointed-to guarded by).
--- Makefile | 1 + include/linux/compiler-context-analysis.h | 452 +++++++++++++++++++++- lib/Kconfig.debug | 30 ++ scripts/Makefile.context-analysis | 7 + scripts/Makefile.lib | 10 + 5 files changed, 493 insertions(+), 7 deletions(-) create mode 100644 scripts/Makefile.context-analysis
Makefile +1 -0
@@ -1093,6 +1093,7 @@ include-$(CONFIG_RANDSTRUCT) += scripts/Makefile.randstruct include-$(CONFIG_KSTACK_ERASE) += scripts/Makefile.kstack_erase include-$(CONFIG_AUTOFDO_CLANG) += scripts/Makefile.autofdo include-$(CONFIG_PROPELLER_CLANG) += scripts/Makefile.propeller +include-$(CONFIG_WARN_CONTEXT_ANALYSIS) += scripts/Makefile.context-analysis include-$(CONFIG_GCC_PLUGINS) += scripts/Makefile.gcc-plugins include $(addprefix $(srctree)/, $(include-y))
include/linux/compiler-context-analysis.h +445 -7
472 lines not on this page · raw message
lib/Kconfig.debug +30 -0
@@ -613,6 +613,36 @@ config DEBUG_FORCE_WEAK_PER_CPU To ensure that generic code follows the above rules, this option forces all percpu variables to be defined as weak. +config WARN_CONTEXT_ANALYSIS + bool "Compiler context-analysis warnings" + depends on CC_IS_CLANG && CLANG_VERSION >= 220000 + # Branch profiling re-defines "if", which messes with the compiler's + # ability to analyze __cond_acquires(..), resulting in false positives. + depends on !TRACE_BRANCH_PROFILING + default y + help + Context Analysis is a language extension, which enables statically + checking that required contexts are active (or inactive) by acquiring + and releasing user-definable "context guards". + + Clang's name of the feature is "Thread Safety Analysis". Requires + Clang 22 or later. + + Produces warnings by default. Select CONFIG_WERROR if you wish to + turn these warnings into errors. + + For more details, see Documentation/dev-tools/context-analysis.rst. + +config WARN_CONTEXT_ANALYSIS_ALL + bool "Enable context analysis for all source files" + depends on WARN_CONTEXT_ANALYSIS + depends on EXPERT && !COMPILE_TEST + help + Enable tree-wide context analysis. This is likely to produce a + large number of false positives - enable at your own risk. + + If unsure, say N. + endmenu # "Compiler options" menu "Generic Kernel Debugging Instruments"
scripts/Makefile.context-analysis new file +7 -0
@@ -0,0 +1,7 @@ +# SPDX-License-Identifier: GPL-2.0 + +context-analysis-cflags := -DWARN_CONTEXT_ANALYSIS \ + -fexperimental-late-parse-attributes -Wthread-safety \ + -Wthread-safety-pointer -Wthread-safety-beta + +export CFLAGS_CONTEXT_ANALYSIS := $(context-analysis-cflags)
scripts/Makefile.lib +10 -0
@@ -105,6 +105,16 @@ _c_flags += $(if $(patsubst n%,, \ -D__KCSAN_INSTRUMENT_BARRIERS__) endif +# +# Enable context analysis flags only where explicitly opted in. +# (depends on variables CONTEXT_ANALYSIS_obj.o, CONTEXT_ANALYSIS) +# +ifeq ($(CONFIG_WARN_CONTEXT_ANALYSIS),y) +_c_flags += $(if $(patsubst n%,, \ + $(CONTEXT_ANALYSIS_$(target-stem).o)$(CONTEXT_ANALYSIS)$(if $(is-kernel-object),$(CONFIG_WARN_CONTEXT_ANALYSIS_ALL))), \ + $(CFLAGS_CONTEXT_ANALYSIS)) +endif + # # Enable AutoFDO build flags except some files or directories we don't want to # enable (depends on variables AUTOFDO_PROFILE_obj.o and AUTOFDO_PROFILE).
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Re: [PATCH v4 02/35] compiler-context-analysis: Add infrastructure for Context Analysis with Clang
include/linux/compiler-context-analysis.h line 9
Quoted 8 lines · Marco Elver
include/linux/compiler-context-analysis.h +1
-0@@ -6,27 +6,465 @@#ifndef _LINUX_COMPILER_CONTEXT_ANALYSIS_H#define _LINUX_COMPILER_CONTEXT_ANALYSIS_H +#if defined(WARN_CONTEXT_ANALYSIS )
Note the 400+ added lines to this header...
And then note how the header gets used:
include/linux/compiler-context-analysis.h line 7
Quoted 9 lines
include/linux/compiler-context-analysis.h +8
-0+++ b/scripts/Makefile.context-analysis@@ -0,0 +1,7 @@ +# SPDX -License-Identifier: GPL-2.0 + +context-analysis-cflags := -DWARN_CONTEXT_ANALYSIS \ + -fexperimental-late-parse-attributes -Wthread-safety \ + -Wthread-safety-pointer -Wthread-safety-beta + +export CFLAGS_CONTEXT_ANALYSIS := $(context-analysis-cflags)
Please let's *not* do it this way, where the header contents basically get enabled or not based on a compiler flag, but then everybody includes this 400+ line file whether they need it or not.
Can we please just make the header file *itself* not have any conditionals, and what happens is that the header file is included (or not) using a pattern something like
-include $(srctree)/include/linux/$(context-analysis-header)
instead.
IOW, we'd have three different header files entirely: the "no context analysis", the "sparse" and the "clang context analysis" header, and instead of having a "-DWARN_CONTEXT_ANALYSIS" define, we'd just include the appropriate header automatically.
We already use that "-include" pattern for <linux/kconfig.h> and <linux/compiler-version.h>. It's probably what we should have done for <linux/compiler.h> and friends too.
The reason I react to things like this is that I've actually seen just the parsing of header files being a surprisingly big cost in build times. People think that optimizations are expensive, and yes, some of them really are, but when a lot of the code we parse is never actually *used*, but just hangs out in header files that gets included by everybody, the parsing overhead tends to be noticeable. There's a reason why most C compilers end up integrating the C pre-processor: it avoids parsing and tokenizing things multiple times.
The other reason is that I often use "git grep" for looking up definitions of things, and when there are multiple definitions of the same thing, I actually find it much more informative when they are in two different files than when I see two different definitions (or declarations) in the same file and then I have to go look at what the #ifdef condition is. In contrast, when it's something where there are per-architecture definitions, you *see* that, because the grep results come from different header files.
I dunno. This is not a huge deal, but I do think that it would seem to be much simpler and more straightforward to treat this as a kind of "N different baseline header files" than as "include this one header file in everything, and then we'll have #ifdef's for the configuration".
Particularly when that config is not even a global config, but a per-file one.
Hmm? Maybe there's some reason why this suggestion is very inconvenient, but please at least consider it.
Linus
Marco Elver
maintainerRe: [PATCH v4 02/35] compiler-context-analysis: Add infrastructure for Context Analysis with Clang
Quoted 1 line · Linus Torvalds
On Thu, 20 Nov 2025 at 07:13, Marco Elver <[email protected]> wrote:
[..]
Quoted 4 lines
Quoted 1 line
+#if
defined(WARN_CONTEXT_ANALYSIS)Note the 400+ added lines to this header...
[..]
Quoted 3 lines
Please let's *not* do it this way, where the header contents basically get enabled or not based on a compiler flag, but then everybody includes this 400+ line file whether they need it or not.
Note, there are a good amount of kernel-doc comments in there, so we have 125 real code lines.
% cloc include/linux/compiler-context-analysis.h
1 text file.
1 unique file.
0 files ignored.
github.com/AlDanial/cloc v 2.06 T=0.01 s (97.1 files/s, 41646.9 lines/s)
-------------------------------------------------------------------------------
Language files blank comment code
-------------------------------------------------------------------------------
C/C++ Header 1 37 267 125
-------------------------------------------------------------------------------
Quoted 40 lines
Can we please just make the header file *itself* not have any conditionals, and what happens is that the header file is included (or not) using a pattern something like
-include $(srctree)/include/linux/$(context-analysis-header)instead.
IOW, we'd have three different header files entirely: the "no context analysis", the "sparse" and the "clang context analysis" header, and instead of having a "-DWARN_CONTEXT_ANALYSIS" define, we'd just include the appropriate header automatically.
We already use that "-include" pattern for <
linux/kconfig.h> and <linux/compiler-version.h>. It's probably what we should have done for <linux/compiler.h> and friends too.The reason I react to things like this is that I've actually seen just the parsing of header files being a surprisingly big cost in build times. People think that optimizations are expensive, and yes, some of them really are, but when a lot of the code we parse is never actually *used*, but just hangs out in header files that gets included by everybody, the parsing overhead tends to be noticeable. There's a reason why most C compilers end up integrating the C pre-processor: it avoids parsing and tokenizing things multiple times.
The other reason is that I often use "git grep" for looking up definitions of things, and when there are multiple definitions of the same thing, I actually find it much more informative when they are in two different files than when I see two different definitions (or declarations) in the same file and then I have to go look at what the #ifdef condition is. In contrast, when it's something where there are per-architecture definitions, you *see* that, because the grep results come from different header files.
I dunno. This is not a huge deal, but I do think that it would seem to be much simpler and more straightforward to treat this as a kind of "N different baseline header files" than as "include this one header file in everything, and then we'll have #ifdef's for the configuration".
Quoted 4 lines
Particularly when that config is not even a global config, but a per-file one.
Hmm? Maybe there's some reason why this suggestion is very inconvenient, but please at least consider it.
Fair points; I gave this a shot, as a patch on top so we can skip the Sparse version.
Reduced version below:
-------------------------------------------------------------------------------
Language files blank comment code
-------------------------------------------------------------------------------
C/C++ Header 1 26 189 80
-------------------------------------------------------------------------------
My suspicion (or I'm doing it wrong): there really isn't all that much we can conditionally -include, because we need at least the no-op stubs everywhere regardless because of annotations provided by common headers (spinlock, mutex, rcu, etc. etc.).
If we assume that in the common case we need the no-op macros everywhere, thus every line in <linux/compiler-context-analysis.h> is required in the common case with the below version, the below experiment should be be close to what we can achieve.
However, it might still be worthwhile for the code organization aspect?
Thoughts?
Thanks,
-- Marco
------ >8 ------
From: Marco Elver <[email protected]>
Date: Thu, 20 Nov 2025 22:37:52 +0100
Subject: [PATCH] compiler-context-analysis: Move Clang definitions to separate
header
In the interest of improving compile-times, it makes sense to move the conditionally enabled definitions when the analysis is enabled to a separate file and include it only with -include.
A very unscientific comparison, on a system with 72 CPUs; before:
125.67 wallclock secs = ( 5681.04 usr secs + 367.63 sys secs / 4815.83% CPU )
After:
125.61 wallclock secs = ( 5684.80 usr secs + 366.53 sys secs / 4817.95% CPU )
[ Work in progress - with this version, there is no measurable
difference in compile times. ]
--- Documentation/dev-tools/context-analysis.rst | 10 +- .../linux/compiler-context-analysis-clang.h | 144 ++++++++++++++++++ include/linux/compiler-context-analysis.h | 136 +---------------- scripts/Makefile.context-analysis | 3 +- 4 files changed, 153 insertions(+), 140 deletions(-) create mode 100644 include/linux/compiler-context-analysis-clang.h
Documentation/dev-tools/context-analysis.rst +6 -4
@@ -99,10 +99,7 @@ Keywords ~~~~~~~~ .. kernel-doc:: include/linux/compiler-context-analysis.h - :identifiers: context_guard_struct - token_context_guard token_context_guard_instance - __guarded_by __pt_guarded_by - __must_hold + :identifiers: __must_hold __must_not_hold __acquires __cond_acquires
@@ -119,6 +116,11 @@ Keywords __acquire_shared_ret context_unsafe __context_unsafe + +.. kernel-doc:: include/linux/compiler-context-analysis-clang.h + :identifiers: __guarded_by __pt_guarded_by + context_guard_struct + token_context_guard token_context_guard_instance disable_context_analysis enable_context_analysis .. note::
include/linux/compiler-context-analysis-clang.h new file +144 -0
144 lines not on this page · raw message
include/linux/compiler-context-analysis.h +1 -135
148 lines not on this page · raw message
scripts/Makefile.context-analysis +2 -1
@@ -2,7 +2,8 @@ context-analysis-cflags := -DWARN_CONTEXT_ANALYSIS \ -fexperimental-late-parse-attributes -Wthread-safety \ - -Wthread-safety-pointer -Wthread-safety-beta + -Wthread-safety-pointer -Wthread-safety-beta \ + -include $(srctree)/include/linux/compiler-context-analysis-clang.h ifndef CONFIG_WARN_CONTEXT_ANALYSIS_ALL context-analysis-cflags += --warning-suppression-mappings=$(srctree)/scripts/context-analysis-suppression.txt
Signature · 1 line
2.52.0.rc2.455.g230fcf2819-goog
Peter Zijlstra
maintainerRe: [PATCH v4 02/35] compiler-context-analysis: Add infrastructure for Context Analysis with Clang
In reply to Marco ElverQuoted 6 lines · Marco Elver
include/linux/compiler-context-analysis.h +6
-0+/** +* __guarded_by - struct member and globals attribute, declares variable +* only accessible within active context +* +* Declares that the struct member or global variable is only accessible within +* the context entered by the given context guard. Read operations on the data
include/linux/compiler-context-analysis.h line 49
Quoted 10 lines
include/linux/compiler-context-analysis.h +10
-0+* require shared access, while write operations require exclusive access. +* +* .. code-block:: c +* +* struct some_state { +* spinlock_t lock; +* long counter __guarded_by(&lock); +* }; +*/ +# define __guarded_by (...) __attribute__((guarded_by(__VA_ARGS__)))
I must express pure hatred for this '.. code-block:: c' thing.
Peter Zijlstra
maintainerRe: [PATCH v4 02/35] compiler-context-analysis: Add infrastructure for Context Analysis with Clang
In reply to Marco ElverQuoted 33 lines · Marco Elver
include/linux/compiler-context-analysis.h +33
-0+/** +* context_guard_struct() - declare or define a context guard struct +* @name: struct name +* +* Helper to declare or define a struct type that is also a context guard. +* +* .. code-block:: c +* +* context_guard_struct(my_handle) { +* int foo; +* long bar; +* }; +* +* struct some_state { +* ... +* }; +* // ... declared elsewhere ... +* context_guard_struct(some_state); +* +* Note: The implementation defines several helper functions that can acquire +* and release the context guard. +*/ +# define context_guard_struct (name, ...) \ + struct __ctx_guard_type(name) __VA_ARGS__ name; \ + static __always_inline void __acquire_ctx_guard(const struct name *var) \ + __attribute__((overloadable)) __no_context_analysis __acquires_ctx_guard(var) { } \ + static __always_inline void __acquire_shared_ctx_guard(const struct name *var) \ + __attribute__((overloadable)) __no_context_analysis __acquires_shared_ctx_guard(var) { } \ + static __always_inline bool __try_acquire_ctx_guard(const struct name *var, bool ret) \ + __attribute__((overloadable)) __no_context_analysis __try_acquires_ctx_guard(1, var) \ + { return ret; } \ + static __always_inline bool __try_acquire_shared_ctx_guard(const struct name *var, bool ret) \ + __attribute__((overloadable)) __no_context_analysis __try_acquires_shared_ctx_guard(1, var) \
include/linux/compiler-context-analysis.h line 111
Quoted 10 lines
include/linux/compiler-context-analysis.h +10
-0+ {return ret; } \ + static __always_inline void __release_ctx_guard(const struct name *var) \ + __attribute__((overloadable)) __no_context_analysis__releases_ctx_guard (var) { } \ + static __always_inline void __release_shared_ctx_guard(const struct name *var) \ + __attribute__((overloadable)) __no_context_analysis__releases_shared_ctx_guard (var) { } \ + static __always_inline void __assume_ctx_guard(const struct name *var) \ + __attribute__((overloadable))__assumes_ctx_guard (var) { } \ + static __always_inline void __assume_shared_ctx_guard(const struct name *var) \ + __attribute__((overloadable))__assumes_shared_ctx_guard (var) { } \ +struct name
-typedef struct {
+context_guard_struct(rwlock) {
struct rwbase_rt rwbase;
atomic_t readers;
#ifdef CONFIG_DEBUG_LOCK_ALLOC
struct lockdep_map dep_map; #endif
-} rwlock_t;
+};
+typedef struct rwlock rwlock_t;
I must say I find the 'guard' naming here somewhat confusing. This is not a guard, but an actual lock type.
Marco Elver
maintainerRe: [PATCH v4 02/35] compiler-context-analysis: Add infrastructure for Context Analysis with Clang
Quoted 59 lines · Peter Zijlstra
Quoted 43 lines · Marco Elver
include/linux/compiler-context-analysis.h +43
-0+/** +* context_guard_struct() - declare or define a context guard struct +* @name: struct name +* +* Helper to declare or define a struct type that is also a context guard. +* +* .. code-block:: c +* +* context_guard_struct(my_handle) { +* int foo; +* long bar; +* }; +* +* struct some_state { +* ... +* }; +* // ... declared elsewhere ... +* context_guard_struct(some_state); +* +* Note: The implementation defines several helper functions that can acquire +* and release the context guard. +*/ +# define context_guard_struct (name, ...) \ + struct __ctx_guard_type(name) __VA_ARGS__ name; \ + static __always_inline void __acquire_ctx_guard(const struct name *var) \ + __attribute__((overloadable)) __no_context_analysis __acquires_ctx_guard(var) { } \ + static __always_inline void __acquire_shared_ctx_guard(const struct name *var) \ + __attribute__((overloadable)) __no_context_analysis __acquires_shared_ctx_guard(var) { } \ + static __always_inline bool __try_acquire_ctx_guard(const struct name *var, bool ret) \ + __attribute__((overloadable)) __no_context_analysis __try_acquires_ctx_guard(1, var) \ + { return ret; } \ + static __always_inline bool __try_acquire_shared_ctx_guard(const struct name *var, bool ret) \ + __attribute__((overloadable)) __no_context_analysis __try_acquires_shared_ctx_guard(1, var) \ + { return ret; } \ + static __always_inline void __release_ctx_guard(const struct name *var) \ + __attribute__((overloadable)) __no_context_analysis __releases_ctx_guard(var) { } \ + static __always_inline void __release_shared_ctx_guard(const struct name *var) \ + __attribute__((overloadable)) __no_context_analysis __releases_shared_ctx_guard(var) { } \ + static __always_inline void __assume_ctx_guard(const struct name *var) \ + __attribute__((overloadable)) __assumes_ctx_guard(var) { } \ + static __always_inline void __assume_shared_ctx_guard(const struct name *var) \ + __attribute__((overloadable)) __assumes_shared_ctx_guard(var) { } \ + struct name(quoted diff) +3
-2-typedef struct { +context_guard_struct(rwlock) { struct rwbase_rt rwbase; atomic_t readers; #ifdef CONFIG_DEBUG_LOCK_ALLOC struct lockdep_map dep_map; #endif -} rwlock_t; +}; +typedef struct rwlock rwlock_t;
Quoted 2 lines
I must say I find the 'guard' naming here somewhat confusing. This is not a guard, but an actual lock type.
The switch to "context analysis" required us coming up with a name for the actual objects (previously: "capability") that "guard" those contexts.
The reasoning was that these are guards for entering a particular context. The lock guards the given context, but the context itself != lock. Clang's naming of "capability" was a lot clearer in isolation, but the problem that Linus raised is that "capability" is already overloaded in the kernel.
The fact it overlaps in naming with the other guard(..) infrastructure is not entirely coincidental, but I see the confusion.
What's a better name?
context_lock_struct -> and call it "context lock" rather than "context guard"; it might work also for things like RCU, PREEMPT, BH, etc. that aren't normal "locks", but could claim they are "context locks".
context_handle_struct -> "context handle" ...
?
Peter Zijlstra
maintainerRe: [PATCH v4 02/35] compiler-context-analysis: Add infrastructure for Context Analysis with Clang
Quoted 1 line · Marco Elver
What's a better name?
That must be the hardest question in programming; screw this P-vs-NP debate :-)
Quoted 5 lines
context_lock_struct-> and call it "context lock" rather than "context guard"; it might work also for things like RCU, PREEMPT, BH, etc. that aren't normal "locks", but could claim they are "context locks".
context_handle_struct-> "context handle" ...
Both work for me I suppose, although I think I have a slight preference to the former: 'context_lock_struct'.
One other possibility is wrapping things like so:
#define define_context_struct(name) ... // the big thing
#define define_lock_struct(name) define_context_struct(name)
Marco Elver
maintainerRe: [PATCH v4 02/35] compiler-context-analysis: Add infrastructure for Context Analysis with Clang
Quoted 13 lines · Peter Zijlstra
Quoted 1 line · Marco Elver
What's a better name?
That must be the hardest question in programming; screw this P-vs-NP debate :-)
Quoted 5 lines
context_lock_struct-> and call it "context lock" rather than "context guard"; it might work also for things like RCU, PREEMPT, BH, etc. that aren't normal "locks", but could claim they are "context locks".
context_handle_struct-> "context handle" ...
Quoted 8 lines
Both work for me I suppose, although I think I have a slight preference to the former: '
context_lock_struct'.One other possibility is wrapping things like so:
#define
define_context_struct(name)... // the big thing#define
define_lock_struct(name)define_context_struct(name)
Note that 'context_lock_struct' (assuming that's the new name) can be used to just forward declare structs, too, so 'define' in the name is probably incorrect. And to avoid more levels of indirection I'd just stick with one name; if 'context_lock_struct' isn't too offensive to anyone, that'd be the name for the next version.
Thanks,
-- Marco
Marco Elver
maintainerPATCH v4 3/35 compiler-context-analysis: Add test stub
In reply to Marco ElverAdd a simple test stub where we will add common supported patterns that should not generate false positive of each new supported context guard.
---
v4:
* Rename capability -> context analysis.
--- lib/Kconfig.debug | 14 ++++++++++++++ lib/Makefile | 3 +++ lib/test_context-analysis.c | 18 ++++++++++++++++++ 3 files changed, 35 insertions(+) create mode 100644 lib/test_context-analysis.c
lib/Kconfig.debug +14 -0
@@ -2833,6 +2833,20 @@ config LINEAR_RANGES_TEST If unsure, say N. +config CONTEXT_ANALYSIS_TEST + bool "Compiler context-analysis warnings test" + depends on EXPERT + help + This builds the test for compiler-based context analysis. The test + does not add executable code to the kernel, but is meant to test that + common patterns supported by the analysis do not result in false + positive warnings. + + When adding support for new context guards, it is strongly recommended + to add supported patterns to this test. + + If unsure, say N. + config CMDLINE_KUNIT_TEST tristate "KUnit test for cmdline API" if !KUNIT_ALL_TESTS depends on KUNIT
lib/Makefile +3 -0
@@ -329,4 +329,7 @@ obj-$(CONFIG_GENERIC_LIB_DEVMEM_IS_ALLOWED) += devmem_is_allowed.o obj-$(CONFIG_FIRMWARE_TABLE) += fw_table.o +CONTEXT_ANALYSIS_test_context-analysis.o := y +obj-$(CONFIG_CONTEXT_ANALYSIS_TEST) += test_context-analysis.o + subdir-$(CONFIG_FORTIFY_SOURCE) += test_fortify
lib/test_context-analysis.c new file +18 -0
@@ -0,0 +1,18 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* Compile-only tests for common patterns that should not generate false +* positive errors when compiled with Clang's context analysis. +*/ + +#include <linux/build_bug.h> + +/* +* Test that helper macros work as expected. +*/ +static void __used test_common_helpers (void ) +{ +BUILD_BUG_ON (context_unsafe (3 ) !=3 );/* plain expression */ + BUILD_BUG_ON(context_unsafe((void)2; 3) != 3); /* does not swallow semi-colon */ +BUILD_BUG_ON (context_unsafe ((void )2 ,3 ) !=3 );/* does not swallow commas */ + context_unsafe(do { } while (0)); /* works with void statements */ +}
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Marco Elver
maintainerPATCH v4 4/35 Documentation: Add documentation for Compiler-Based Context Analysis
In reply to Marco ElverAdds documentation in Documentation/dev-tools/context-analysis.rst, and adds it to the index.
---
v4:
* Rename capability -> context analysis.
v2:
* Remove cross-reference to Sparse, since we plan to remove Sparse support anyway.
* Mention __no_context_analysis should be avoided.
--- Documentation/dev-tools/context-analysis.rst | 145 +++++++++++++++++++ Documentation/dev-tools/index.rst | 1 + 2 files changed, 146 insertions(+) create mode 100644 Documentation/dev-tools/context-analysis.rst
Documentation/dev-tools/context-analysis.rst new file +145 -0
@@ -0,0 +1,145 @@ +.. SPDX-License-Identifier: GPL-2.0 +.. Copyright (C) 2025, Google LLC. + +.. _context-analysis: + +Compiler-Based Context Analysis +=============================== + +Context Analysis is a language extension, which enables statically checking +that required contexts are active (or inactive) by acquiring and releasing +user-definable "context guards". An obvious application is lock-safety checking +for the kernel's various synchronization primitives (each of which represents a +"context guard"), and checking that locking rules are not violated. + +The Clang compiler currently supports the full set of context analysis +features. To enable for Clang, configure the kernel with:: + + CONFIG_WARN_CONTEXT_ANALYSIS=y + +The feature requires Clang 22 or later. + +The analysis is *opt-in by default*, and requires declaring which modules and +subsystems should be analyzed in the respective `Makefile`:: + + CONTEXT_ANALYSIS_mymodule.o := y + +Or for all translation units in the directory:: + + CONTEXT_ANALYSIS := y + +It is possible to enable the analysis tree-wide, however, which will result in +numerous false positive warnings currently and is *not* generally recommended:: + + CONFIG_WARN_CONTEXT_ANALYSIS_ALL=y + +Programming Model +----------------- + +The below describes the programming model around using context guard types. + +.. note:: + Enabling context analysis can be seen as enabling a dialect of Linux C with + a Context System. Some valid patterns involving complex control-flow are + constrained (such as conditional acquisition and later conditional release + in the same function). + +Context analysis is a way to specify permissibility of operations to depend on +context guards being held (or not held). Typically we are interested in +protecting data and code in a critical section by requiring a specific context +to be active, for example by holding a specific lock. The analysis ensures that +callers cannot perform an operation without the required context being active. + +Context guards are associated with named structs, along with functions that +operate on struct instances to acquire and release the associated context +guard. + +Context guards can be held either exclusively or shared. This mechanism allows +assigning more precise privileges when a context is active, typically to +distinguish where a thread may only read (shared) or also write (exclusive) to +data guarded within a context. + +The set of contexts that are actually active in a given thread at a given point +in program execution is a run-time concept. The static analysis works by +calculating an approximation of that set, called the context environment. The +context environment is calculated for every program point, and describes the +set of contexts that are statically known to be active, or inactive, at that +particular point. This environment is a conservative approximation of the full +set of contexts that will actually be active in a thread at run-time. + +More details are also documented `here +<https://clang.llvm.org/docs/ThreadSafetyAnalysis.html>`_. + +.. note:: + Clang's analysis explicitly does not infer context guards acquired or + released by inline functions. It requires explicit annotations to (a) assert + that it's not a bug if a context guard is released or acquired, and (b) to + retain consistency between inline and non-inline function declarations. + +Supported Kernel Primitives +~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +.. Currently the following synchronization primitives are supported: + +For context guards with an initialization function (e.g., `spin_lock_init()`), +calling this function before initializing any guarded members or globals +prevents the compiler from issuing warnings about unguarded initialization. + +Lockdep assertions, such as `lockdep_assert_held()`, inform the compiler's +context analysis that the associated synchronization primitive is held after +the assertion. This avoids false positives in complex control-flow scenarios +and encourages the use of Lockdep where static analysis is limited. For +example, this is useful when a function doesn't *always* require a lock, making +`__must_hold()` inappropriate. + +Keywords +~~~~~~~~ + +.. kernel-doc:: include/linux/compiler-context-analysis.h + :identifiers: context_guard_struct + token_context_guard token_context_guard_instance + __guarded_by __pt_guarded_by + __must_hold + __must_not_hold + __acquires + __cond_acquires + __releases + __must_hold_shared + __acquires_shared + __cond_acquires_shared + __releases_shared + __acquire + __release + __cond_lock + __acquire_shared + __release_shared + __cond_lock_shared + __acquire_ret + __acquire_shared_ret + context_unsafe + __context_unsafe + disable_context_analysis enable_context_analysis + +.. note:: + The function attribute `__no_context_analysis` is reserved for internal + implementation of context guard types, and should be avoided in normal code. + +Background +---------- + +Clang originally called the feature `Thread Safety Analysis +<https://clang.llvm.org/docs/ThreadSafetyAnalysis.html>`_, with some keywords +and documentation still using the thread-safety-analysis-only terminology. This +was later changed and the feature became more flexible, gaining the ability to +define custom "capabilities". Its foundations can be found in `Capability +Systems <https://www.cs.cornell.edu/talc/papers/capabilities.pdf>`_, used to +specify the permissibility of operations to depend on some "capability" being +held (or not held). + +Because the feature is not just able to express capabilities related to +synchronization primitives, and "capability" is already overloaded in the +kernel, the naming chosen for the kernel departs from Clang's initial "Thread +Safety" and "capability" nomenclature; we refer to the feature as "Context +Analysis" to avoid confusion. The internal implementation still makes +references to Clang's terminology in a few places, such as `-Wthread-safety` +being the warning option that also still appears in diagnostic messages.
Documentation/dev-tools/index.rst +1 -0
@@ -21,6 +21,7 @@ Documentation/process/debugging/index.rst checkpatch clang-format coccinelle + context-analysis sparse kcov gcov
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Marco Elver
maintainerPATCH v4 5/35 checkpatch: Warn about context_unsafe() without comment
In reply to Marco ElverWarn about applications of context_unsafe() without a comment, to encourage documenting the reasoning behind why it was deemed safe.
---
v4:
* Rename capability -> context analysis.
* Avoid nested if.
--- scripts/checkpatch.pl | 7 +++++++ 1 file changed, 7 insertions(+)
scripts/checkpatch.pl +7 -0
@@ -6722,6 +6722,13 @@ sub process { } } +# check for context_unsafe without a comment. + if ($line =~ /\bcontext_unsafe\b/ && + !ctx_has_comment($first_line, $linenr)) { + WARN("CONTEXT_UNSAFE", + "context_unsafe without comment\n" . $herecurr); + } + # check of hardware specific defines if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) { CHK("ARCH_DEFINES",
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Marco Elver
maintainerPATCH v4 6/35 cleanup: Basic compatibility with context analysis
In reply to Marco ElverIntroduce basic compatibility with cleanup.h infrastructure: introduce DECLARE_LOCK_GUARD_*_ATTRS() helpers to add attributes to constructors and destructors respectively.
Note: Due to the scoped cleanup helpers used for lock guards wrapping acquire and release around their own constructors/destructors that store pointers to the passed locks in a separate struct, we currently cannot accurately annotate *destructors* which lock was released. While it's possible to annotate the constructor to say which lock was acquired, that alone would result in false positives claiming the lock was not released on function return.
Instead, to avoid false positives, we can claim that the constructor "assumes" that the taken lock is held via __assumes_ctx_guard().
This will ensure we can still benefit from the analysis where scoped guards are used to protect access to guarded variables, while avoiding false positives. The only downside are false negatives where we might accidentally lock the same lock again:
raw_spin_lock(&my_lock); ... guard(raw_spinlock)(&my_lock); // no warning
Arguably, lockdep will immediately catch issues like this.
While Clang's analysis supports scoped guards in C++ [1], there's no way to apply this to C right now. Better support for Linux's scoped guard design could be added in future if deemed critical.
[1] https://clang.llvm.org/docs/ThreadSafetyAnalysis.html#scoped-context
---
v4:
* Rename capability -> context analysis.
v3:
* Add *_ATTRS helpers instead of implicit __assumes_cap (suggested by Peter)
* __assert -> __assume rename
--- include/linux/cleanup.h | 17 +++++++++++++++++ 1 file changed, 17 insertions(+)
include/linux/cleanup.h +17 -0
@@ -274,16 +274,21 @@ const volatile void * __must_check_fn(const volatile void *val) #define DEFINE_CLASS(_name, _type, _exit, _init, _init_args...) \ typedef _type class_##_name##_t; \ +typedef _type lock_##_name##_t; \ static inline void class_##_name##_destructor(_type *p) \ + __no_context_analysis \ { _type _T = *p; _exit; } \ static inline _type class_##_name##_constructor(_init_args) \ + __no_context_analysis \ { _type t = _init; return t; } #define EXTEND_CLASS(_name, ext, _init, _init_args...) \ +typedef lock_##_name##_t lock_##_name##ext##_t; \ typedef class_##_name##_t class_##_name##ext##_t; \ static inline void class_##_name##ext##_destructor(class_##_name##_t *p)\ { class_##_name##_destructor(p); } \ static inline class_##_name##_t class_##_name##ext##_constructor(_init_args) \ + __no_context_analysis \ { class_##_name##_t t = _init; return t; }#define CLASS (_name, var) \
@@ -461,12 +466,14 @@ _label: \*/ #define __DEFINE_UNLOCK_GUARD (_name, _type, _unlock, ...) \ +typedef _type lock_##_name##_t; \ typedef struct { \ _type *lock; \ __VA_ARGS__; \ } class_##_name##_t; \ \ static inline void class_##_name##_destructor(class_##_name##_t *_T) \ + __no_context_analysis \ { \ if (!__GUARD_IS_ERR(_T->lock)) { _unlock; } \ } \
@@ -475,6 +482,7 @@ __DEFINE_GUARD_LOCK_PTR(_name, &_T->lock)#define __DEFINE_LOCK_GUARD_1 (_name, _type, _lock) \ static inline class_##_name##_t class_##_name##_constructor(_type *l) \ + __no_context_analysis \ { \ class_##_name##_t _t = { .lock = l }, *_T = &_t; \ _lock; \
@@ -483,6 +491,7 @@ static inline class_##_name##_t class_##_name##_constructor(_type *l) \#define __DEFINE_LOCK_GUARD_0 (_name, _lock) \ static inline class_##_name##_t class_##_name##_constructor(void) \ + __no_context_analysis \ { \ class_##_name##_t _t = { .lock = (void*)1 }, \ *_T __maybe_unused = &_t; \
@@ -490,6 +499,14 @@ static inline class_##_name##_t class_##_name##_constructor(void) \return _t; \ } +#define DECLARE_LOCK_GUARD_0_ATTRS (_name, _lock, _unlock) \ +static inline class_##_name##_t class_##_name##_constructor(void) _lock;\ +static inline void class_##_name##_destructor(class_##_name##_t *_T) _unlock; + +#define DECLARE_LOCK_GUARD_1_ATTRS (_name, _lock, _unlock) \ +static inline class_##_name##_t class_##_name##_constructor(lock_##_name##_t *_T) _lock;\ +static inline void class_##_name##_destructor(class_##_name##_t *_T) _unlock; +#define DEFINE_LOCK_GUARD_1 (_name, _type, _lock, _unlock, ...) \ __DEFINE_CLASS_IS_CONDITIONAL(_name, false); \ __DEFINE_UNLOCK_GUARD(_name, _type, _unlock, __VA_ARGS__) \
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Marco Elver
maintainerPATCH v4 7/35 lockdep: Annotate lockdep assertions for context analysis
Clang's context analysis can be made aware of functions that assert that locks are held.
Presence of these annotations causes the analysis to assume the context guard is held after calls to the annotated function, and avoid false positives with complex control-flow; for example, where not all control-flow paths in a function require a held lock, and therefore marking the function with __must_hold(..) is inappropriate.
---
v4:
* Rename capability -> context analysis.
v3:
* __assert -> __assume rename
--- include/linux/lockdep.h | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-)
include/linux/lockdep.h +6 -6
@@ -282,16 +282,16 @@ extern void lock_unpin_lock(struct lockdep_map *lock, struct pin_cookie); do { WARN_ON_ONCE(debug_locks && !(cond)); } while (0)#define lockdep_assert_held (l) \ - lockdep_assert(lockdep_is_held(l) != LOCK_STATE_NOT_HELD) + do { lockdep_assert(lockdep_is_held(l) != LOCK_STATE_NOT_HELD); __assume_ctx_guard(l); } while (0)#define lockdep_assert_not_held (l) \ lockdep_assert(lockdep_is_held(l) != LOCK_STATE_HELD)#define lockdep_assert_held_write (l) \ - lockdep_assert(lockdep_is_held_type(l, 0)) + do { lockdep_assert(lockdep_is_held_type(l, 0)); __assume_ctx_guard(l); } while (0)#define lockdep_assert_held_read (l) \ - lockdep_assert(lockdep_is_held_type(l, 1)) + do { lockdep_assert(lockdep_is_held_type(l, 1)); __assume_shared_ctx_guard(l); } while (0)#define lockdep_assert_held_once (l) \ lockdep_assert_once(lockdep_is_held(l) != LOCK_STATE_NOT_HELD)
@@ -389,10 +389,10 @@ extern int lockdep_is_held(const void *);#define lockdep_assert (c) do { } while (0)#define lockdep_assert_once (c) do { } while (0) -#define lockdep_assert_held (l) do { (void)(l); } while (0) +#define lockdep_assert_held (l) __assume_ctx_guard(l)#define lockdep_assert_not_held (l) do { (void)(l); } while (0) -#define lockdep_assert_held_write (l) do { (void)(l); } while (0) -#define lockdep_assert_held_read (l) do { (void)(l); } while (0) +#define lockdep_assert_held_write (l) __assume_ctx_guard(l) +#define lockdep_assert_held_read (l) __assume_shared_ctx_guard(l)#define lockdep_assert_held_once (l) do { (void)(l); } while (0)#define lockdep_assert_none_held_once () do { } while (0)
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Peter Zijlstra
maintainerRe: [PATCH v4 07/35] lockdep: Annotate lockdep assertions for context analysis
include/linux/lockdep.h extern void lock_unpin_lock(struct lockdep_map *lock, struct pin_cookie); · line 282
Quoted 9 lines · Marco Elver
include/linux/lockdep.h | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-)include/linux/lockdep.h +0
-0@@ -282,16 +282,16 @@ extern void lock_unpin_lock(struct lockdep_map *lock, struct pin_cookie);do {WARN_ON_ONCE (debug_locks && !(cond)); }while (0 )
Since I typically read patches without first reading the Changelog -- because when I read the code later, I also don't see changelogs.
I must admit to getting most terribly confused here -- *again*, as I then search back to previous discussions and found I was previously also confused.
As such, I think we want a comment here that explains that assume_ctx thing.
It is *NOT* (as the clang naming suggests) an assertion of holding the lock (which is requires_ctx), but rather an annotation that forces the ctx to be considered held.
Quoted 35 lines
include/linux/lockdep.h +6
-6#define lockdep_assert_held (l) \ - lockdep_assert(lockdep_is_held(l) != LOCK_STATE_NOT_HELD) + do { lockdep_assert(lockdep_is_held(l) != LOCK_STATE_NOT_HELD); __assume_ctx_guard(l); } while (0)#define lockdep_assert_not_held (l) \ lockdep_assert(lockdep_is_held(l) != LOCK_STATE_HELD)#define lockdep_assert_held_write (l) \ - lockdep_assert(lockdep_is_held_type(l, 0)) + do { lockdep_assert(lockdep_is_held_type(l, 0)); __assume_ctx_guard(l); } while (0)#define lockdep_assert_held_read (l) \ - lockdep_assert(lockdep_is_held_type(l, 1)) + do { lockdep_assert(lockdep_is_held_type(l, 1)); __assume_shared_ctx_guard(l); } while (0)#define lockdep_assert_held_once (l) \ lockdep_assert_once(lockdep_is_held(l) != LOCK_STATE_NOT_HELD)@@ -389,10 +389,10 @@ extern int lockdep_is_held(const void *);#define lockdep_assert (c) do { } while (0)#define lockdep_assert_once (c) do { } while (0) -#define lockdep_assert_held (l) do { (void)(l); } while (0) +#define lockdep_assert_held (l) __assume_ctx_guard(l)#define lockdep_assert_not_held (l) do { (void)(l); } while (0) -#define lockdep_assert_held_write (l) do { (void)(l); } while (0) -#define lockdep_assert_held_read (l) do { (void)(l); } while (0) +#define lockdep_assert_held_write (l) __assume_ctx_guard(l) +#define lockdep_assert_held_read (l) __assume_shared_ctx_guard(l)#define lockdep_assert_held_once (l) do { (void)(l); } while (0)#define lockdep_assert_none_held_once () do { } while (0)Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Marco Elver
maintainerRe: [PATCH v4 07/35] lockdep: Annotate lockdep assertions for context analysis
Quoted 20 lines · Peter Zijlstra
include/linux/lockdep.h extern void lock_unpin_lock(struct lockdep_map *lock, struct pin_cookie); · line 282
Quoted 9 lines · Marco Elver
include/linux/lockdep.h | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-)include/linux/lockdep.h +0
-0@@ -282,16 +282,16 @@ extern void lock_unpin_lock(struct lockdep_map *lock, struct pin_cookie);do {WARN_ON_ONCE (debug_locks && !(cond)); }while (0 )Since I typically read patches without first reading the Changelog -- because when I read the code later, I also don't see changelogs.
I must admit to getting most terribly confused here -- *again*, as I then search back to previous discussions and found I was previously also confused.
Quoted 6 lines
As such, I think we want a comment here that explains that
assume_ctxthing.It is *NOT* (as the clang naming suggests) an assertion of holding the lock (which is
requires_ctx), but rather an annotation that forces the ctx to be considered held.
Noted. I'll add some appropriate wording above the __assumes_ctx_guard() attribute, so this is not lost in the commit logs.
Peter Zijlstra
maintainerRe: [PATCH v4 07/35] lockdep: Annotate lockdep assertions for context analysis
Quoted 7 lines · Marco Elver
Quoted 3 lines
It is *NOT* (as the clang naming suggests) an assertion of holding the lock (which is
requires_ctx), but rather an annotation that forces the ctx to be considered held.Noted. I'll add some appropriate wording above the
__assumes_ctx_guard()attribute, so this is not lost in the commit logs.
On IRC you stated:
<melver> peterz: 'assume' just forces the compiler to think something is
held, whether or not it is then becomes the programmer's problem. we need it in 2 places at least: for the runtime assertions (to help patterns beyond the compiler's static reasoning abilities), and for initialization (so we can access guarded variables right after initialization; nobody should hold the lock yet)
I'm really not much a fan of that init hack either ;-)
Once we get the scope crap working sanely, I would much rather we move to something like:
scoped_guard (spinlock_init, &foo->lock) {
// init foo fields
}or perhaps:
guard(mutex_init)(&bar->lock); // init until end of current scope
Where this latter form is very similar to the current semantics where mutex_init() will implicitly 'leak' the holding of the lock. But the former gives more control where we need it.
Marco Elver
maintainerRe: [PATCH v4 07/35] lockdep: Annotate lockdep assertions for context analysis
Quoted 29 lines · Peter Zijlstra
Quoted 7 lines · Marco Elver
Quoted 3 lines
It is *NOT* (as the clang naming suggests) an assertion of holding the lock (which is
requires_ctx), but rather an annotation that forces the ctx to be considered held.Noted. I'll add some appropriate wording above the
__assumes_ctx_guard()attribute, so this is not lost in the commit logs.On IRC you stated:
<melver> peterz: 'assume' just forces the compiler to think something is
held, whether or not it is then becomes the programmer's problem. we need it in 2 places at least: for the runtime assertions (to help patterns beyond the compiler's static reasoning abilities), and for initialization (so we can access guarded variables right after initialization; nobody should hold the lock yet)I'm really not much a fan of that init hack either ;-)
Once we get the scope crap working sanely, I would much rather we move to something like:
scoped_guard (spinlock_init, &foo->lock) { // init foo fields }
Quoted 8 lines
or perhaps:
guard(mutex_init)(&bar->lock); // init until end of current scopeWhere this latter form is very similar to the current semantics where
mutex_init()will implicitly 'leak' the holding of the lock. But the former gives more control where we need it.
I like it. It would also more clearly denote where initialization start+ends if not confined to a dedicated function.
Marco Elver
maintainerPATCH v4 8/35 locking/rwlock, spinlock: Support Clang's context analysis
In reply to Marco ElverAdd support for Clang's context analysis for raw_spinlock_t, spinlock_t, and rwlock. This wholesale conversion is required because all three of them are interdependent.
To avoid warnings in constructors, the initialization functions mark a lock as acquired when initialized before guarded variables.
The test verifies that common patterns do not generate false positives.
---
v4:
* Rename capability -> context analysis.
v3:
* Switch to DECLARE_LOCK_GUARD_1_ATTRS() (suggested by Peter)
* __assert -> __assume rename
--- Documentation/dev-tools/context-analysis.rst | 3 +- include/linux/rwlock.h | 25 ++-- include/linux/rwlock_api_smp.h | 29 ++++- include/linux/rwlock_rt.h | 35 +++-- include/linux/rwlock_types.h | 10 +- include/linux/spinlock.h | 70 +++++++--- include/linux/spinlock_api_smp.h | 14 +- include/linux/spinlock_api_up.h | 71 +++++----- include/linux/spinlock_rt.h | 21 +-- include/linux/spinlock_types.h | 10 +- include/linux/spinlock_types_raw.h | 5 +- lib/test_context-analysis.c | 128 +++++++++++++++++++ 12 files changed, 324 insertions(+), 97 deletions(-)
Documentation/dev-tools/context-analysis.rst +2 -1
@@ -79,7 +79,8 @@ More details are also documented `here Supported Kernel Primitives ~~~~~~~~~~~~~~~~~~~~~~~~~~~ -.. Currently the following synchronization primitives are supported: +Currently the following synchronization primitives are supported: +`raw_spinlock_t`, `spinlock_t`, `rwlock_t`. For context guards with an initialization function (e.g., `spin_lock_init()`), calling this function before initializing any guarded members or globals
include/linux/rwlock.h +13 -12
@@ -22,23 +22,24 @@ do { \static struct lock_class_key __key; \ \ __rwlock_init((lock), #lock, &__key); \ + __assume_ctx_guard(lock); \ } while (0)#else # define rwlock_init (lock) \ - do { *(lock) = __RW_LOCK_UNLOCKED(lock); } while (0) + do { *(lock) = __RW_LOCK_UNLOCKED(lock); __assume_ctx_guard(lock); } while (0)#endif #ifdef CONFIG_DEBUG_SPINLOCK - extern void do_raw_read_lock(rwlock_t *lock) __acquires(lock); + extern void do_raw_read_lock(rwlock_t *lock) __acquires_shared(lock);extern int do_raw_read_trylock (rwlock_t *lock); - extern void do_raw_read_unlock(rwlock_t *lock) __releases(lock); + extern void do_raw_read_unlock(rwlock_t *lock) __releases_shared(lock); extern void do_raw_write_lock(rwlock_t *lock) __acquires(lock);extern int do_raw_write_trylock (rwlock_t *lock); extern void do_raw_write_unlock(rwlock_t *lock) __releases(lock);#else -# define do_raw_read_lock (rwlock) do {__acquire(lock); arch_read_lock(&(rwlock)->raw_lock); } while (0) +# define do_raw_read_lock (rwlock) do {__acquire_shared(lock); arch_read_lock(&(rwlock)->raw_lock); } while (0)# define do_raw_read_trylock (rwlock) arch_read_trylock(&(rwlock)->raw_lock) -# define do_raw_read_unlock (rwlock) do {arch_read_unlock(&(rwlock)->raw_lock); __release(lock); } while (0) +# define do_raw_read_unlock (rwlock) do {arch_read_unlock(&(rwlock)->raw_lock); __release_shared(lock); } while (0)# define do_raw_write_lock (rwlock) do {__acquire(lock); arch_write_lock(&(rwlock)->raw_lock); } while (0)# define do_raw_write_trylock (rwlock) arch_write_trylock(&(rwlock)->raw_lock)# define do_raw_write_unlock (rwlock) do {arch_write_unlock(&(rwlock)->raw_lock); __release(lock); } while (0)
@@ -49,7 +50,7 @@ do { \* regardless of whether CONFIG_SMP or CONFIG_PREEMPT are set. The various * methods are defined as nops in the case they are not required. */ -#define read_trylock (lock) __cond_lock(lock, _raw_read_trylock(lock)) +#define read_trylock (lock) __cond_lock_shared(lock, _raw_read_trylock(lock))#define write_trylock (lock) __cond_lock(lock, _raw_write_trylock(lock))#define write_lock (lock) _raw_write_lock(lock)
@@ -112,12 +113,12 @@ do { \ } while (0)#define write_unlock_bh (lock) _raw_write_unlock_bh(lock) -#define write_trylock_irqsave (lock, flags) \ -({ \ - local_irq_save(flags); \ - write_trylock(lock) ? \ - 1 : ({ local_irq_restore(flags); 0; }); \ -}) +#define write_trylock_irqsave (lock, flags) \ + __cond_lock(lock, ({ \ + local_irq_save(flags); \ + _raw_write_trylock(lock) ? \ + 1 : ({ local_irq_restore(flags); 0; }); \ + }))#ifdef arch_rwlock_is_contended#define rwlock_is_contended (lock) \
include/linux/rwlock_api_smp.h +23 -6
@@ -15,12 +15,12 @@* Released under the General Public License (GPL). */ -void __lockfunc _raw_read_lock(rwlock_t *lock) __acquires(lock); +void __lockfunc _raw_read_lock(rwlock_t *lock) __acquires_shared(lock); void __lockfunc _raw_write_lock(rwlock_t *lock) __acquires(lock); void __lockfunc _raw_write_lock_nested(rwlock_t *lock, int subclass) __acquires(lock); -void __lockfunc _raw_read_lock_bh(rwlock_t *lock) __acquires(lock); +void __lockfunc _raw_read_lock_bh(rwlock_t *lock) __acquires_shared(lock); void __lockfunc _raw_write_lock_bh(rwlock_t *lock) __acquires(lock); -void __lockfunc _raw_read_lock_irq(rwlock_t *lock) __acquires(lock); +void __lockfunc _raw_read_lock_irq(rwlock_t *lock) __acquires_shared(lock); void __lockfunc _raw_write_lock_irq(rwlock_t *lock) __acquires(lock); unsigned long __lockfunc _raw_read_lock_irqsave(rwlock_t *lock) __acquires(lock);
@@ -28,11 +28,11 @@ unsigned long __lockfunc _raw_write_lock_irqsave(rwlock_t *lock)__acquires (lock); int __lockfunc _raw_read_trylock(rwlock_t *lock); int __lockfunc _raw_write_trylock(rwlock_t *lock); -void __lockfunc _raw_read_unlock(rwlock_t *lock) __releases(lock); +void __lockfunc _raw_read_unlock(rwlock_t *lock) __releases_shared(lock); void __lockfunc _raw_write_unlock(rwlock_t *lock) __releases(lock); -void __lockfunc _raw_read_unlock_bh(rwlock_t *lock) __releases(lock); +void __lockfunc _raw_read_unlock_bh(rwlock_t *lock) __releases_shared(lock); void __lockfunc _raw_write_unlock_bh(rwlock_t *lock) __releases(lock); -void __lockfunc _raw_read_unlock_irq(rwlock_t *lock) __releases(lock); +void __lockfunc _raw_read_unlock_irq(rwlock_t *lock) __releases_shared(lock); void __lockfunc _raw_write_unlock_irq(rwlock_t *lock) __releases(lock); void __lockfunc_raw_read_unlock_irqrestore (rwlock_t *lock,unsigned long flags)
@@ -145,6 +145,7 @@ static inline int __raw_write_trylock(rwlock_t *lock)#if !defined(CONFIG_GENERIC_LOCKBREAK ) || defined(CONFIG_DEBUG_LOCK_ALLOC )static inline void __raw_read_lock (rwlock_t *lock) +__acquires_shared (lock) __no_context_analysis {preempt_disable ();rwlock_acquire_read (&lock->dep_map,0 ,0 , _RET_IP_);
@@ -152,6 +153,7 @@ static inline void __raw_read_lock(rwlock_t *lock) }static inline unsigned long __raw_read_lock_irqsave (rwlock_t *lock) +__acquires_shared (lock) __no_context_analysis {unsigned long flags;
@@ -163,6 +165,7 @@ static inline unsigned long __raw_read_lock_irqsave(rwlock_t *lock) }static inline void __raw_read_lock_irq (rwlock_t *lock) +__acquires_shared (lock) __no_context_analysis {local_irq_disable ();preempt_disable ();
@@ -171,6 +174,7 @@ static inline void __raw_read_lock_irq(rwlock_t *lock) }static inline void __raw_read_lock_bh (rwlock_t *lock) +__acquires_shared (lock) __no_context_analysis {__local_bh_disable_ip (_RET_IP_,SOFTIRQ_LOCK_OFFSET );rwlock_acquire_read (&lock->dep_map,0 ,0 , _RET_IP_);
@@ -178,6 +182,7 @@ static inline void __raw_read_lock_bh(rwlock_t *lock) }static inline unsigned long __raw_write_lock_irqsave (rwlock_t *lock) +__acquires (lock) __no_context_analysis {unsigned long flags;
@@ -189,6 +194,7 @@ static inline unsigned long __raw_write_lock_irqsave(rwlock_t *lock) }static inline void __raw_write_lock_irq (rwlock_t *lock) +__acquires (lock) __no_context_analysis {local_irq_disable ();preempt_disable ();
@@ -197,6 +203,7 @@ static inline void __raw_write_lock_irq(rwlock_t *lock) }static inline void __raw_write_lock_bh (rwlock_t *lock) +__acquires (lock) __no_context_analysis {__local_bh_disable_ip (_RET_IP_,SOFTIRQ_LOCK_OFFSET );rwlock_acquire (&lock->dep_map,0 ,0 , _RET_IP_);
@@ -204,6 +211,7 @@ static inline void __raw_write_lock_bh(rwlock_t *lock) }static inline void __raw_write_lock (rwlock_t *lock) +__acquires (lock) __no_context_analysis {preempt_disable ();rwlock_acquire (&lock->dep_map,0 ,0 , _RET_IP_);
@@ -211,6 +219,7 @@ static inline void __raw_write_lock(rwlock_t *lock) }static inline void __raw_write_lock_nested (rwlock_t *lock,int subclass) +__acquires (lock) __no_context_analysis {preempt_disable ();rwlock_acquire (&lock->dep_map, subclass,0 , _RET_IP_);
@@ -220,6 +229,7 @@ static inline void __raw_write_lock_nested(rwlock_t *lock, int subclass)#endif /* !CONFIG_GENERIC_LOCKBREAK || CONFIG_DEBUG_LOCK_ALLOC */ static inline void __raw_write_unlock (rwlock_t *lock) +__releases (lock) {rwlock_release (&lock->dep_map, _RET_IP_);do_raw_write_unlock (lock);
@@ -227,6 +237,7 @@ static inline void __raw_write_unlock(rwlock_t *lock) }static inline void __raw_read_unlock (rwlock_t *lock) +__releases_shared (lock) {rwlock_release (&lock->dep_map, _RET_IP_);do_raw_read_unlock (lock);
@@ -235,6 +246,7 @@ static inline void __raw_read_unlock(rwlock_t *lock)static inline void __raw_read_unlock_irqrestore (rwlock_t *lock,unsigned long flags) +__releases_shared (lock) {rwlock_release (&lock->dep_map, _RET_IP_);do_raw_read_unlock (lock);
@@ -243,6 +255,7 @@ __raw_read_unlock_irqrestore(rwlock_t *lock, unsigned long flags) }static inline void __raw_read_unlock_irq (rwlock_t *lock) +__releases_shared (lock) {rwlock_release (&lock->dep_map, _RET_IP_);do_raw_read_unlock (lock);
@@ -251,6 +264,7 @@ static inline void __raw_read_unlock_irq(rwlock_t *lock) }static inline void __raw_read_unlock_bh (rwlock_t *lock) +__releases_shared (lock) {rwlock_release (&lock->dep_map, _RET_IP_);do_raw_read_unlock (lock);
@@ -259,6 +273,7 @@ static inline void __raw_read_unlock_bh(rwlock_t *lock)static inline void __raw_write_unlock_irqrestore (rwlock_t *lock,unsigned long flags) +__releases (lock) {rwlock_release (&lock->dep_map, _RET_IP_);do_raw_write_unlock (lock);
@@ -267,6 +282,7 @@ static inline void __raw_write_unlock_irqrestore(rwlock_t *lock, }static inline void __raw_write_unlock_irq (rwlock_t *lock) +__releases (lock) {rwlock_release (&lock->dep_map, _RET_IP_);do_raw_write_unlock (lock);
@@ -275,6 +291,7 @@ static inline void __raw_write_unlock_irq(rwlock_t *lock) }static inline void __raw_write_unlock_bh (rwlock_t *lock) +__releases (lock) {rwlock_release (&lock->dep_map, _RET_IP_);do_raw_write_unlock (lock);
include/linux/rwlock_rt.h +24 -11
@@ -22,28 +22,32 @@ do { \ \init_rwbase_rt (&(rwl)->rwbase); \ __rt_rwlock_init(rwl, #rwl, &__key); \ +__assume_ctx_guard (rwl); \ }while (0 ) -extern void rt_read_lock(rwlock_t *rwlock) __acquires(rwlock); +extern void rt_read_lock(rwlock_t *rwlock) __acquires_shared(rwlock);extern int rt_read_trylock (rwlock_t *rwlock); -extern void rt_read_unlock(rwlock_t *rwlock) __releases(rwlock); +extern void rt_read_unlock(rwlock_t *rwlock) __releases_shared(rwlock); extern void rt_write_lock(rwlock_t *rwlock) __acquires(rwlock); extern void rt_write_lock_nested(rwlock_t *rwlock, int subclass) __acquires(rwlock);extern int rt_write_trylock (rwlock_t *rwlock); extern void rt_write_unlock(rwlock_t *rwlock) __releases(rwlock); static __always_inline void read_lock(rwlock_t *rwlock) +__acquires_shared (rwlock) {rt_read_lock (rwlock); } static __always_inline void read_lock_bh(rwlock_t *rwlock) +__acquires_shared (rwlock) {local_bh_disable ();rt_read_lock (rwlock); } static __always_inline void read_lock_irq(rwlock_t *rwlock) +__acquires_shared (rwlock) {rt_read_lock (rwlock); }
@@ -55,37 +59,43 @@ static __always_inline void read_lock_irq(rwlock_t *rwlock) flags =0 ; \ } while (0) -#define read_trylock (lock) __cond_lock(lock, rt_read_trylock(lock)) +#define read_trylock (lock) __cond_lock_shared(lock, rt_read_trylock(lock)) static __always_inline void read_unlock(rwlock_t *rwlock) +__releases_shared (rwlock) {rt_read_unlock (rwlock); } static __always_inline void read_unlock_bh(rwlock_t *rwlock) +__releases_shared (rwlock) {rt_read_unlock (rwlock);local_bh_enable (); } static __always_inline void read_unlock_irq(rwlock_t *rwlock) +__releases_shared (rwlock) {rt_read_unlock (rwlock); } static __always_inline void read_unlock_irqrestore(rwlock_t *rwlock,unsigned long flags) +__releases_shared (rwlock) {rt_read_unlock (rwlock); } static __always_inline void write_lock(rwlock_t *rwlock) +__acquires (rwlock) {rt_write_lock (rwlock); }#ifdef CONFIG_DEBUG_LOCK_ALLOC static __always_inline void write_lock_nested(rwlock_t *rwlock, int subclass) +__acquires (rwlock) {rt_write_lock_nested (rwlock, subclass); }
@@ -94,12 +104,14 @@ static __always_inline void write_lock_nested(rwlock_t *rwlock, int subclass)#endif static __always_inline void write_lock_bh(rwlock_t *rwlock) +__acquires (rwlock) {local_bh_disable ();rt_write_lock (rwlock); } static __always_inline void write_lock_irq(rwlock_t *rwlock) +__acquires (rwlock) {rt_write_lock (rwlock); }
@@ -114,33 +126,34 @@ static __always_inline void write_lock_irq(rwlock_t *rwlock)#define write_trylock (lock) __cond_lock(lock, rt_write_trylock(lock))#define write_trylock_irqsave (lock, flags) \ -({ \ - int __locked; \ - \ - typecheck(unsigned long, flags); \ - flags = 0; \ - __locked = write_trylock(lock); \ - __locked; \ -}) + __cond_lock(lock, ({ \ + typecheck(unsigned long, flags); \ + flags = 0; \ + rt_write_trylock(lock); \ + })) static __always_inline void write_unlock(rwlock_t *rwlock) +__releases (rwlock) {rt_write_unlock (rwlock); } static __always_inline void write_unlock_bh(rwlock_t *rwlock) +__releases (rwlock) {rt_write_unlock (rwlock);local_bh_enable (); } static __always_inline void write_unlock_irq(rwlock_t *rwlock) +__releases (rwlock) {rt_write_unlock (rwlock); } static __always_inline void write_unlock_irqrestore(rwlock_t *rwlock,unsigned long flags) +__releases (rwlock) {rt_write_unlock (rwlock); }
include/linux/rwlock_types.h +6 -4
@@ -22,7 +22,7 @@* portions Copyright 2005, Red Hat, Inc., Ingo Molnar * Released under the General Public License (GPL). */ -typedef struct { +context_guard_struct (rwlock) {arch_rwlock_t raw_lock;#ifdef CONFIG_DEBUG_SPINLOCK unsigned int magic, owner_cpu;
@@ -31,7 +31,8 @@ typedef struct {#ifdef CONFIG_DEBUG_LOCK_ALLOC struct lockdep_map dep_map;#endif -} rwlock_t; +}; +typedef struct rwlock rwlock_t ;#define RWLOCK_MAGIC 0xdeaf1eed
@@ -54,13 +55,14 @@ typedef struct {#include <linux/rwbase_rt.h> -typedef struct { +context_guard_struct (rwlock) {struct rwbase_rt rwbase;atomic_t readers;#ifdef CONFIG_DEBUG_LOCK_ALLOC struct lockdep_map dep_map;#endif -}rwlock_t ; +}; +typedef struct rwlock rwlock_t ;#define __RWLOCK_RT_INITIALIZER (name) \ { \
include/linux/spinlock.h +54 -16
258 lines not on this page · raw message
include/linux/spinlock_api_smp.h +12 -2
@@ -34,8 +34,8 @@ unsigned long __lockfunc _raw_spin_lock_irqsave(raw_spinlock_t *lock) unsigned long __lockfunc _raw_spin_lock_irqsave_nested(raw_spinlock_t *lock, int subclass) __acquires(lock); -int __lockfunc _raw_spin_trylock(raw_spinlock_t *lock); -int __lockfunc _raw_spin_trylock_bh(raw_spinlock_t *lock); +int __lockfunc _raw_spin_trylock(raw_spinlock_t *lock) __cond_acquires(lock); +int __lockfunc _raw_spin_trylock_bh(raw_spinlock_t *lock) __cond_acquires(lock); void __lockfunc _raw_spin_unlock(raw_spinlock_t *lock) __releases(lock); void __lockfunc _raw_spin_unlock_bh(raw_spinlock_t *lock) __releases(lock); void __lockfunc _raw_spin_unlock_irq(raw_spinlock_t *lock) __releases(lock);
@@ -84,6 +84,7 @@ _raw_spin_unlock_irqrestore(raw_spinlock_t *lock, unsigned long flags)#endif static inline int __raw_spin_trylock (raw_spinlock_t *lock) +__cond_acquires (lock) {preempt_disable ();if (do_raw_spin_trylock (lock)) {
@@ -102,6 +103,7 @@ static inline int __raw_spin_trylock(raw_spinlock_t *lock)#if !defined(CONFIG_GENERIC_LOCKBREAK ) || defined(CONFIG_DEBUG_LOCK_ALLOC )static inline unsigned long __raw_spin_lock_irqsave (raw_spinlock_t *lock) +__acquires (lock) __no_context_analysis {unsigned long flags;
@@ -113,6 +115,7 @@ static inline unsigned long __raw_spin_lock_irqsave(raw_spinlock_t *lock) }static inline void __raw_spin_lock_irq (raw_spinlock_t *lock) +__acquires (lock) __no_context_analysis {local_irq_disable ();preempt_disable ();
@@ -121,6 +124,7 @@ static inline void __raw_spin_lock_irq(raw_spinlock_t *lock) }static inline void __raw_spin_lock_bh (raw_spinlock_t *lock) +__acquires (lock) __no_context_analysis {__local_bh_disable_ip (_RET_IP_,SOFTIRQ_LOCK_OFFSET );spin_acquire (&lock->dep_map,0 ,0 , _RET_IP_);
@@ -128,6 +132,7 @@ static inline void __raw_spin_lock_bh(raw_spinlock_t *lock) }static inline void __raw_spin_lock (raw_spinlock_t *lock) +__acquires (lock) __no_context_analysis {preempt_disable ();spin_acquire (&lock->dep_map,0 ,0 , _RET_IP_);
@@ -137,6 +142,7 @@ static inline void __raw_spin_lock(raw_spinlock_t *lock)#endif /* !CONFIG_GENERIC_LOCKBREAK || CONFIG_DEBUG_LOCK_ALLOC */ static inline void __raw_spin_unlock (raw_spinlock_t *lock) +__releases (lock) {spin_release (&lock->dep_map, _RET_IP_);do_raw_spin_unlock (lock);
@@ -145,6 +151,7 @@ static inline void __raw_spin_unlock(raw_spinlock_t *lock)static inline void __raw_spin_unlock_irqrestore (raw_spinlock_t *lock,unsigned long flags) +__releases (lock) {spin_release (&lock->dep_map, _RET_IP_);do_raw_spin_unlock (lock);
@@ -153,6 +160,7 @@ static inline void __raw_spin_unlock_irqrestore(raw_spinlock_t *lock, }static inline void __raw_spin_unlock_irq (raw_spinlock_t *lock) +__releases (lock) {spin_release (&lock->dep_map, _RET_IP_);do_raw_spin_unlock (lock);
@@ -161,6 +169,7 @@ static inline void __raw_spin_unlock_irq(raw_spinlock_t *lock) }static inline void __raw_spin_unlock_bh (raw_spinlock_t *lock) +__releases (lock) {spin_release (&lock->dep_map, _RET_IP_);do_raw_spin_unlock (lock);
@@ -168,6 +177,7 @@ static inline void __raw_spin_unlock_bh(raw_spinlock_t *lock) }static inline int __raw_spin_trylock_bh (raw_spinlock_t *lock) +__cond_acquires (lock) {__local_bh_disable_ip (_RET_IP_,SOFTIRQ_LOCK_OFFSET );if (do_raw_spin_trylock (lock)) {
include/linux/spinlock_api_up.h +40 -31
108 lines not on this page · raw message
include/linux/spinlock_rt.h +13 -8
@@ -20,6 +20,7 @@ static inline void __rt_spin_lock_init(spinlock_t *lock, const char *name,do { \rt_mutex_base_init (&(slock)->lock); \__rt_spin_lock_init (slock, name, key, percpu); \ +__assume_ctx_guard (slock); \ } while (0)#define _spin_lock_init (slock, percpu) \
@@ -40,6 +41,7 @@ extern int rt_spin_trylock_bh(spinlock_t *lock);extern int rt_spin_trylock (spinlock_t *lock); static __always_inline void spin_lock(spinlock_t *lock) +__acquires (lock) {rt_spin_lock (lock); }
@@ -82,6 +84,7 @@ static __always_inline void spin_lock(spinlock_t *lock) __spin_lock_irqsave_nested(lock, flags, subclass) static __always_inline void spin_lock_bh(spinlock_t *lock) +__acquires (lock) {/* Investigate: Drop bh when blocking ? */ local_bh_disable ();
@@ -89,6 +92,7 @@ static __always_inline void spin_lock_bh(spinlock_t *lock) } static __always_inline void spin_lock_irq(spinlock_t *lock) +__acquires (lock) {rt_spin_lock (lock); }
@@ -101,23 +105,27 @@ static __always_inline void spin_lock_irq(spinlock_t *lock) }while (0 ) static __always_inline void spin_unlock(spinlock_t *lock) +__releases (lock) {rt_spin_unlock (lock); } static __always_inline void spin_unlock_bh(spinlock_t *lock) +__releases (lock) {rt_spin_unlock (lock);local_bh_enable (); } static __always_inline void spin_unlock_irq(spinlock_t *lock) +__releases (lock) {rt_spin_unlock (lock); } static __always_inline void spin_unlock_irqrestore(spinlock_t *lock,unsigned long flags) +__releases (lock) {rt_spin_unlock (lock); }
@@ -132,14 +140,11 @@ static __always_inline void spin_unlock_irqrestore(spinlock_t *lock, __cond_lock(lock, rt_spin_trylock(lock))#define spin_trylock_irqsave (lock, flags) \ -({ \ - int __locked; \ - \ - typecheck(unsigned long, flags); \ - flags = 0; \ - __locked = spin_trylock(lock); \ - __locked; \ -}) + __cond_lock(lock, ({ \ + typecheck(unsigned long, flags); \ + flags = 0; \ + rt_spin_trylock(lock); \ + }))#define spin_is_contended (lock) (((void)(lock), 0))
include/linux/spinlock_types.h +6 -4
@@ -14,7 +14,7 @@#ifndef CONFIG_PREEMPT_RT /* Non PREEMPT_RT kernels map spinlock to raw_spinlock */ -typedef struct spinlock { +context_guard_struct (spinlock) {union { struct raw_spinlock rlock;
@@ -26,7 +26,8 @@ typedef struct spinlock { };#endif }; -} spinlock_t; +}; +typedef struct spinlock spinlock_t ;#define ___SPIN_LOCK_INITIALIZER (lockname) \ { \
@@ -47,12 +48,13 @@ typedef struct spinlock {/* PREEMPT_RT kernels map spinlock to rt_mutex */ #include <linux/rtmutex.h> -typedef struct spinlock { +context_guard_struct (spinlock) {struct rt_mutex_base lock;#ifdef CONFIG_DEBUG_LOCK_ALLOC struct lockdep_map dep_map;#endif -}spinlock_t ; +}; +typedef struct spinlock spinlock_t ;#define __SPIN_LOCK_UNLOCKED (name) \ { \
include/linux/spinlock_types_raw.h +3 -2
@@ -11,7 +11,7 @@#include <linux/lockdep_types.h> -typedef struct raw_spinlock { +context_guard_struct (raw_spinlock) {arch_spinlock_t raw_lock;#ifdef CONFIG_DEBUG_SPINLOCK unsigned int magic, owner_cpu;
@@ -20,7 +20,8 @@ typedef struct raw_spinlock {#ifdef CONFIG_DEBUG_LOCK_ALLOC struct lockdep_map dep_map;#endif -} raw_spinlock_t; +}; +typedef struct raw_spinlock raw_spinlock_t ;#define SPINLOCK_MAGIC 0xdead4ead
lib/test_context-analysis.c +128 -0
137 lines not on this page · raw message
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Peter Zijlstra
maintainerRe: [PATCH v4 08/35] locking/rwlock, spinlock: Support Clang's context analysis
Quoted 8 lines · Marco Elver
To avoid warnings in constructors, the initialization functions mark a lock as acquired when initialized before guarded variables.
include/linux/rwlock.h +0
-0
include/linux/rwlock.h do { \ · line 30
Quoted 10 lines
include/linux/rwlock.h +2
-1@@ -22,23 +22,24 @@ do { \static struct lock_class_key __key; \ \ __rwlock_init((lock), #lock, &__key); \ + __assume_ctx_guard(lock); \ } while (0)#else # define rwlock_init (lock) \ - do { *(lock) = __RW_LOCK_UNLOCKED(lock); } while (0) + do { *(lock) = __RW_LOCK_UNLOCKED(lock); __assume_ctx_guard(lock); } while (0)#endif
This is again somewhat magical and confused the living daylight out of me. I know (from having looked back on previous discussions) that I was confused about this before, and clearly it didn't stick.
So obviously I'll be confused again when I look at this code in a years time or so :/
Can we get a comment near this __assume_ctx_guard() thing (because putting it all over the lock initializers would probably be duplicating things too much)?
Marco Elver
maintainerPATCH v4 9/35 compiler-context-analysis: Change __cond_acquires to take return value
In reply to Marco ElverWhile Sparse is oblivious to the return value of conditional acquire functions, Clang's context analysis needs to know the return value which indicates successful acquisition.
Add the additional argument, and convert existing uses.
Notably, Clang's interpretation of the value merely relates to the use in a later conditional branch, i.e. 1 ==> context guard acquired in branch taken if condition non-zero, and 0 ==> context guard acquired in branch taken if condition is zero. Given the precise value does not matter, introduce symbolic variants to use instead of either 0 or 1, which should be more intuitive.
No functional change intended.
---
v4:
* Rename capability -> context analysis.
v2:
* Use symbolic values for __cond_acquires() and __cond_acquires_shared() (suggested by Bart).
--- fs/dlm/lock.c | 2 +- include/linux/compiler-context-analysis.h | 31 +++++++++++++++++++---- include/linux/refcount.h | 6 ++--- include/linux/spinlock.h | 6 ++--- include/linux/spinlock_api_smp.h | 8 +++--- net/ipv4/tcp_sigpool.c | 2 +- 6 files changed, 38 insertions(+), 17 deletions(-)
fs/dlm/lock.c +1 -1
@@ -343,7 +343,7 @@ void dlm_hold_rsb(struct dlm_rsb *r)/* TODO move this to lib/refcount.c */ static __must_check bool dlm_refcount_dec_and_write_lock_bh (refcount_t *r,rwlock_t *lock) -__cond_acquires (lock) +__cond_acquires (true, lock) {if (refcount_dec_not_one (r))return false;
include/linux/compiler-context-analysis.h +26 -5
@@ -259,7 +259,7 @@ static inline void _context_unsafe_alias(void **p) { }# define __must_hold (x) __attribute__((context(x,1,1)))# define __must_not_hold (x)# define __acquires (x) __attribute__((context(x,0,1))) -# define __cond_acquires (x) __attribute__((context(x,0,-1))) +# define __cond_acquires (ret, x) __attribute__((context(x,0,-1)))# define __releases (x) __attribute__((context(x,1,0)))# define __acquire (x) __context__(x,1)# define __release (x) __context__(x,-1)
@@ -302,15 +302,32 @@ static inline void _context_unsafe_alias(void **p) { }*/ # define __acquires (x) __acquires_ctx_guard(x) +/* +* Clang's analysis does not care precisely about the value, only that it is +* either zero or non-zero. So the __cond_acquires() interface might be +* misleading if we say that @ret is the value returned if acquired. Instead, +* provide symbolic variants which we translate. +*/ +#define __cond_acquires_impl_true (x, ...) __try_acquires##__VA_ARGS__##_ctx_guard(1, x) +#define __cond_acquires_impl_false (x, ...) __try_acquires##__VA_ARGS__##_ctx_guard(0, x) +#define __cond_acquires_impl_nonzero (x, ...) __try_acquires##__VA_ARGS__##_ctx_guard(1, x) +#define __cond_acquires_impl_0 (x, ...) __try_acquires##__VA_ARGS__##_ctx_guard(0, x) +#define __cond_acquires_impl_nonnull (x, ...) __try_acquires##__VA_ARGS__##_ctx_guard(1, x) +#define __cond_acquires_impl_NULL (x, ...) __try_acquires##__VA_ARGS__##_ctx_guard(0, x) +/** * __cond_acquires() - function attribute, function conditionally * acquires a context guard exclusively +* @ret: abstract value returned by function if context guard acquired * @x: context guard instance pointer * * Function attribute declaring that the function conditionally acquires the -* given context guard instance @x exclusively, but does not release it. +* given context guard instance @x exclusively, but does not release it. The +* function return value @ret denotes when the context guard is acquired. +* +* @ret may be one of: true, false, nonzero, 0, nonnull, NULL. */ -# define __cond_acquires (x) __try_acquires_ctx_guard(1, x) +# define __cond_acquires (ret, x) __cond_acquires_impl_##ret(x)/** * __releases() - function attribute, function releases a context guard exclusively
@@ -377,12 +394,16 @@ static inline void _context_unsafe_alias(void **p) { }/** * __cond_acquires_shared() - function attribute, function conditionally * acquires a context guard shared +* @ret: abstract value returned by function if context guard acquired * @x: context guard instance pointer * * Function attribute declaring that the function conditionally acquires the -* given context guard instance @x with shared access, but does not release it. +* given context guard instance @x with shared access, but does not release it. The +* function return value @ret denotes when the context guard is acquired. +* +* @ret may be one of: true, false, nonzero, 0, nonnull, NULL. */ -# define __cond_acquires_shared (x) __try_acquires_shared_ctx_guard(1, x) +# define __cond_acquires_shared (ret, x) __cond_acquires_impl_##ret(x, _shared)/** * __releases_shared() - function attribute, function releases a
include/linux/refcount.h +3 -3
@@ -478,9 +478,9 @@ static inline void refcount_dec(refcount_t *r)extern __must_check bool refcount_dec_if_one (refcount_t *r);extern __must_check bool refcount_dec_not_one (refcount_t *r); -extern __must_check bool refcount_dec_and_mutex_lock(refcount_t *r, struct mutex *lock) __cond_acquires(lock); -extern __must_check bool refcount_dec_and_lock(refcount_t *r, spinlock_t *lock) __cond_acquires(lock); +extern __must_check bool refcount_dec_and_mutex_lock(refcount_t *r, struct mutex *lock) __cond_acquires(true, lock); +extern __must_check bool refcount_dec_and_lock(refcount_t *r, spinlock_t *lock) __cond_acquires(true, lock); extern __must_check bool refcount_dec_and_lock_irqsave(refcount_t *r, spinlock_t *lock, - unsigned long *flags) __cond_acquires(lock); + unsigned long *flags) __cond_acquires(true, lock);#endif /* _LINUX_REFCOUNT_H */
include/linux/spinlock.h +3 -3
@@ -362,7 +362,7 @@ static __always_inline void spin_lock_bh(spinlock_t *lock) } static __always_inline int spin_trylock(spinlock_t *lock) -__cond_acquires (lock) __no_context_analysis +__cond_acquires (true, lock) __no_context_analysis {return raw_spin_trylock (&lock->rlock); }
@@ -422,13 +422,13 @@ static __always_inline void spin_unlock_irqrestore(spinlock_t *lock, unsigned lo } static __always_inline int spin_trylock_bh(spinlock_t *lock) -__cond_acquires (lock) __no_context_analysis +__cond_acquires (true, lock) __no_context_analysis {return raw_spin_trylock_bh (&lock->rlock); } static __always_inline int spin_trylock_irq(spinlock_t *lock) -__cond_acquires (lock) __no_context_analysis +__cond_acquires (true, lock) __no_context_analysis {return raw_spin_trylock_irq (&lock->rlock); }
include/linux/spinlock_api_smp.h +4 -4
@@ -34,8 +34,8 @@ unsigned long __lockfunc _raw_spin_lock_irqsave(raw_spinlock_t *lock) unsigned long __lockfunc _raw_spin_lock_irqsave_nested(raw_spinlock_t *lock, int subclass) __acquires(lock); -int __lockfunc _raw_spin_trylock(raw_spinlock_t *lock) __cond_acquires(lock); -int __lockfunc _raw_spin_trylock_bh(raw_spinlock_t *lock) __cond_acquires(lock); +int __lockfunc _raw_spin_trylock(raw_spinlock_t *lock) __cond_acquires(true, lock); +int __lockfunc _raw_spin_trylock_bh(raw_spinlock_t *lock) __cond_acquires(true, lock); void __lockfunc _raw_spin_unlock(raw_spinlock_t *lock) __releases(lock); void __lockfunc _raw_spin_unlock_bh(raw_spinlock_t *lock) __releases(lock); void __lockfunc _raw_spin_unlock_irq(raw_spinlock_t *lock) __releases(lock);
@@ -84,7 +84,7 @@ _raw_spin_unlock_irqrestore(raw_spinlock_t *lock, unsigned long flags)#endif static inline int __raw_spin_trylock (raw_spinlock_t *lock) -__cond_acquires (lock) +__cond_acquires (true, lock) {preempt_disable ();if (do_raw_spin_trylock (lock)) {
@@ -177,7 +177,7 @@ static inline void __raw_spin_unlock_bh(raw_spinlock_t *lock) }static inline int __raw_spin_trylock_bh (raw_spinlock_t *lock) -__cond_acquires (lock) +__cond_acquires (true, lock) {__local_bh_disable_ip (_RET_IP_,SOFTIRQ_LOCK_OFFSET );if (do_raw_spin_trylock (lock)) {
net/ipv4/tcp_sigpool.c +1 -1
@@ -257,7 +257,7 @@ void tcp_sigpool_get(unsigned int id) }EXPORT_SYMBOL_GPL (tcp_sigpool_get); -int tcp_sigpool_start (unsigned int id,struct tcp_sigpool *c)__cond_acquires (RCU_BH ) +int tcp_sigpool_start (unsigned int id,struct tcp_sigpool *c)__cond_acquires (0 ,RCU_BH ) {struct crypto_ahash *hash;
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Marco Elver
maintainerPATCH v4 10/35 locking/mutex: Support Clang's context analysis
In reply to Marco ElverAdd support for Clang's context analysis for mutex.
---
v4:
* Rename capability -> context analysis.
v3:
* Switch to DECLARE_LOCK_GUARD_1_ATTRS() (suggested by Peter)
* __assert -> __assume rename
--- Documentation/dev-tools/context-analysis.rst | 2 +- include/linux/mutex.h | 35 ++++++----- include/linux/mutex_types.h | 4 +- lib/test_context-analysis.c | 64 ++++++++++++++++++++ 4 files changed, 87 insertions(+), 18 deletions(-)
Documentation/dev-tools/context-analysis.rst +1 -1
@@ -80,7 +80,7 @@ Supported Kernel Primitives ~~~~~~~~~~~~~~~~~~~~~~~~~~~ Currently the following synchronization primitives are supported: -`raw_spinlock_t`, `spinlock_t`, `rwlock_t`. +`raw_spinlock_t`, `spinlock_t`, `rwlock_t`, `mutex`. For context guards with an initialization function (e.g., `spin_lock_init()`), calling this function before initializing any guarded members or globals
include/linux/mutex.h +20 -15
@@ -62,6 +62,7 @@ do { \static struct lock_class_key __key; \ \ __mutex_init((mutex), #mutex, &__key); \ +__assume_ctx_guard (mutex); \ }while (0 )/**
@@ -157,13 +158,13 @@ static inline int __must_check __devm_mutex_init(struct device *dev, struct mute* Also see Documentation/locking/mutex-design.rst. */ #ifdef CONFIG_DEBUG_LOCK_ALLOC -extern void mutex_lock_nested (struct mutex *lock,unsigned int subclass); +extern void mutex_lock_nested(struct mutex *lock, unsigned int subclass) __acquires(lock);extern void _mutex_lock_nest_lock (struct mutex *lock,struct lockdep_map *nest_lock); extern int __must_check mutex_lock_interruptible_nested(struct mutex *lock, -unsigned int subclass); + unsigned int subclass) __cond_acquires(0, lock); extern int __must_check _mutex_lock_killable(struct mutex *lock, -unsigned int subclass,struct lockdep_map *nest_lock); -extern void mutex_lock_io_nested (struct mutex *lock,unsigned int subclass); + unsigned int subclass, struct lockdep_map *nest_lock) __cond_acquires(0, lock); +extern void mutex_lock_io_nested(struct mutex *lock, unsigned int subclass) __acquires(lock);#define mutex_lock (lock) mutex_lock_nested(lock, 0)#define mutex_lock_interruptible (lock) mutex_lock_interruptible_nested(lock, 0)
@@ -186,10 +187,10 @@ do { \ _mutex_lock_killable(lock, subclass, NULL)#else -extern void mutex_lock (struct mutex *lock); -extern int __must_check mutex_lock_interruptible (struct mutex *lock); -extern int __must_check mutex_lock_killable (struct mutex *lock); -extern void mutex_lock_io (struct mutex *lock); +extern void mutex_lock(struct mutex *lock) __acquires(lock); +extern int __must_check mutex_lock_interruptible(struct mutex *lock) __cond_acquires(0, lock); +extern int __must_check mutex_lock_killable(struct mutex *lock) __cond_acquires(0, lock); +extern void mutex_lock_io(struct mutex *lock) __acquires(lock);# define mutex_lock_nested (lock, subclass) mutex_lock(lock)# define mutex_lock_interruptible_nested (lock, subclass) mutex_lock_interruptible(lock)
@@ -207,7 +208,7 @@ extern void mutex_lock_io(struct mutex *lock);*/ #ifdef CONFIG_DEBUG_LOCK_ALLOC -extern int _mutex_trylock_nest_lock (struct mutex *lock,struct lockdep_map *nest_lock); +extern int _mutex_trylock_nest_lock(struct mutex *lock, struct lockdep_map *nest_lock) __cond_acquires(true, lock);#define mutex_trylock_nest_lock (lock, nest_lock) \ ( \
@@ -217,17 +218,21 @@ extern int _mutex_trylock_nest_lock(struct mutex *lock, struct lockdep_map *nest #define mutex_trylock(lock) _mutex_trylock_nest_lock(lock, NULL) #else -extern int mutex_trylock (struct mutex *lock); +extern int mutex_trylock(struct mutex *lock) __cond_acquires(true, lock); #define mutex_trylock_nest_lock(lock, nest_lock) mutex_trylock(lock) #endif -extern void mutex_unlock (struct mutex *lock); +extern void mutex_unlock(struct mutex *lock) __releases(lock); -extern int atomic_dec_and_mutex_lock (atomic_t *cnt,struct mutex *lock); +extern int atomic_dec_and_mutex_lock(atomic_t *cnt, struct mutex *lock) __cond_acquires(true, lock); -DEFINE_GUARD(mutex, struct mutex *, mutex_lock(_T), mutex_unlock(_T)) -DEFINE_GUARD_COND(mutex, _try, mutex_trylock(_T)) -DEFINE_GUARD_COND(mutex, _intr, mutex_lock_interruptible(_T), _RET == 0) +DEFINE_LOCK_GUARD_1(mutex, struct mutex, mutex_lock(_T->lock), mutex_unlock(_T->lock)) +DEFINE_LOCK_GUARD_1_COND(mutex, _try, mutex_trylock(_T->lock)) +DEFINE_LOCK_GUARD_1_COND(mutex, _intr, mutex_lock_interruptible(_T->lock), _RET == 0) + +DECLARE_LOCK_GUARD_1_ATTRS(mutex, __assumes_ctx_guard(_T), /* */) +DECLARE_LOCK_GUARD_1_ATTRS(mutex_try, __assumes_ctx_guard(_T), /* */) +DECLARE_LOCK_GUARD_1_ATTRS(mutex_intr, __assumes_ctx_guard(_T), /* */) extern unsigned long mutex_get_owner(struct mutex *lock);
include/linux/mutex_types.h +2 -2
@@ -38,7 +38,7 @@* - detects multi-task circular deadlocks and prints out all affected * locks and tasks (and only those tasks) */ -struct mutex { +context_guard_struct (mutex) {atomic_long_t owner;raw_spinlock_t wait_lock;#ifdef CONFIG_MUTEX_SPIN_ON_OWNER
@@ -59,7 +59,7 @@ struct mutex {*/ #include <linux/rtmutex.h> -struct mutex { +context_guard_struct (mutex) {struct rt_mutex_base rtmutex;#ifdef CONFIG_DEBUG_LOCK_ALLOC struct lockdep_map dep_map;
lib/test_context-analysis.c +64 -0
73 lines not on this page · raw message
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Marco Elver
maintainerPATCH v4 11/35 locking/seqlock: Support Clang's context analysis
In reply to Marco ElverAdd support for Clang's context analysis for seqlock_t.
---
v3:
* __assert -> __assume rename
--- Documentation/dev-tools/context-analysis.rst | 2 +- include/linux/seqlock.h | 24 +++++++++++ include/linux/seqlock_types.h | 5 ++- lib/test_context-analysis.c | 43 ++++++++++++++++++++ 4 files changed, 71 insertions(+), 3 deletions(-)
Documentation/dev-tools/context-analysis.rst +1 -1
@@ -80,7 +80,7 @@ Supported Kernel Primitives ~~~~~~~~~~~~~~~~~~~~~~~~~~~ Currently the following synchronization primitives are supported: -`raw_spinlock_t`, `spinlock_t`, `rwlock_t`, `mutex`. +`raw_spinlock_t`, `spinlock_t`, `rwlock_t`, `mutex`, `seqlock_t`. For context guards with an initialization function (e.g., `spin_lock_init()`), calling this function before initializing any guarded members or globals
include/linux/seqlock.h +24 -0
@@ -816,6 +816,7 @@ static __always_inline void write_seqcount_latch_end(seqcount_latch_t *s)do { \spin_lock_init (&(sl)->lock); \seqcount_spinlock_init (&(sl)->seqcount, &(sl)->lock); \ +__assume_ctx_guard (sl); \ }while (0 )/**
@@ -832,6 +833,7 @@ static __always_inline void write_seqcount_latch_end(seqcount_latch_t *s)* Return: count, to be passed to read_seqretry() */ static inline unsigned read_seqbegin (const seqlock_t *sl) +__acquires_shared (sl) __no_context_analysis {return read_seqcount_begin (&sl->seqcount); }
@@ -848,6 +850,7 @@ static inline unsigned read_seqbegin(const seqlock_t *sl)* Return: true if a read section retry is required, else false */ static inline unsigned read_seqretry (const seqlock_t *sl,unsigned start) +__releases_shared (sl) __no_context_analysis {return read_seqcount_retry (&sl->seqcount, start); }
@@ -872,6 +875,7 @@ static inline unsigned read_seqretry(const seqlock_t *sl, unsigned start)* _irqsave or _bh variants of this function instead. */ static inline void write_seqlock (seqlock_t *sl) +__acquires (sl) __no_context_analysis {spin_lock (&sl->lock);do_write_seqcount_begin (&sl->seqcount.seqcount);
@@ -885,6 +889,7 @@ static inline void write_seqlock(seqlock_t *sl)* critical section of given seqlock_t. */ static inline void write_sequnlock (seqlock_t *sl) +__releases (sl) __no_context_analysis {do_write_seqcount_end (&sl->seqcount.seqcount);spin_unlock (&sl->lock);
@@ -898,6 +903,7 @@ static inline void write_sequnlock(seqlock_t *sl)* other write side sections, can be invoked from softirq contexts. */ static inline void write_seqlock_bh (seqlock_t *sl) +__acquires (sl) __no_context_analysis {spin_lock_bh (&sl->lock);do_write_seqcount_begin (&sl->seqcount.seqcount);
@@ -912,6 +918,7 @@ static inline void write_seqlock_bh(seqlock_t *sl)* write_seqlock_bh(). */ static inline void write_sequnlock_bh (seqlock_t *sl) +__releases (sl) __no_context_analysis {do_write_seqcount_end (&sl->seqcount.seqcount);spin_unlock_bh (&sl->lock);
@@ -925,6 +932,7 @@ static inline void write_sequnlock_bh(seqlock_t *sl)* other write sections, can be invoked from hardirq contexts. */ static inline void write_seqlock_irq (seqlock_t *sl) +__acquires (sl) __no_context_analysis {spin_lock_irq (&sl->lock);do_write_seqcount_begin (&sl->seqcount.seqcount);
@@ -938,12 +946,14 @@ static inline void write_seqlock_irq(seqlock_t *sl)* seqlock_t write side section opened with write_seqlock_irq(). */ static inline void write_sequnlock_irq (seqlock_t *sl) +__releases (sl) __no_context_analysis {do_write_seqcount_end (&sl->seqcount.seqcount);spin_unlock_irq (&sl->lock); }static inline unsigned long __write_seqlock_irqsave (seqlock_t *sl) +__acquires (sl) __no_context_analysis {unsigned long flags;
@@ -976,6 +986,7 @@ static inline unsigned long __write_seqlock_irqsave(seqlock_t *sl)*/ static inline void write_sequnlock_irqrestore (seqlock_t *sl,unsigned long flags) +__releases (sl) __no_context_analysis {do_write_seqcount_end (&sl->seqcount.seqcount);spin_unlock_irqrestore (&sl->lock, flags);
@@ -998,6 +1009,7 @@ write_sequnlock_irqrestore(seqlock_t *sl, unsigned long flags)* The opened read section must be closed with read_sequnlock_excl(). */ static inline void read_seqlock_excl (seqlock_t *sl) +__acquires_shared (sl) __no_context_analysis {spin_lock (&sl->lock); }
@@ -1007,6 +1019,7 @@ static inline void read_seqlock_excl(seqlock_t *sl)* @sl: Pointer to seqlock_t */ static inline void read_sequnlock_excl (seqlock_t *sl) +__releases_shared (sl) __no_context_analysis {spin_unlock (&sl->lock); }
@@ -1021,6 +1034,7 @@ static inline void read_sequnlock_excl(seqlock_t *sl)* from softirq contexts. */ static inline void read_seqlock_excl_bh (seqlock_t *sl) +__acquires_shared (sl) __no_context_analysis {spin_lock_bh (&sl->lock); }
@@ -1031,6 +1045,7 @@ static inline void read_seqlock_excl_bh(seqlock_t *sl)* @sl: Pointer to seqlock_t */ static inline void read_sequnlock_excl_bh (seqlock_t *sl) +__releases_shared (sl) __no_context_analysis {spin_unlock_bh (&sl->lock); }
@@ -1045,6 +1060,7 @@ static inline void read_sequnlock_excl_bh(seqlock_t *sl)* hardirq context. */ static inline void read_seqlock_excl_irq (seqlock_t *sl) +__acquires_shared (sl) __no_context_analysis {spin_lock_irq (&sl->lock); }
@@ -1055,11 +1071,13 @@ static inline void read_seqlock_excl_irq(seqlock_t *sl)* @sl: Pointer to seqlock_t */ static inline void read_sequnlock_excl_irq (seqlock_t *sl) +__releases_shared (sl) __no_context_analysis {spin_unlock_irq (&sl->lock); }static inline unsigned long __read_seqlock_excl_irqsave (seqlock_t *sl) +__acquires_shared (sl) __no_context_analysis {unsigned long flags;
@@ -1089,6 +1107,7 @@ static inline unsigned long __read_seqlock_excl_irqsave(seqlock_t *sl)*/ static inline void read_sequnlock_excl_irqrestore (seqlock_t *sl,unsigned long flags) +__releases_shared (sl) __no_context_analysis {spin_unlock_irqrestore (&sl->lock, flags); }
@@ -1125,6 +1144,7 @@ read_sequnlock_excl_irqrestore(seqlock_t *sl, unsigned long flags)* parameter of the next read_seqbegin_or_lock() iteration. */ static inline void read_seqbegin_or_lock (seqlock_t *lock,int *seq) +__acquires_shared (lock) __no_context_analysis {if (!(*seq &1 ))/* Even */ *seq =read_seqbegin (lock);
@@ -1140,6 +1160,7 @@ static inline void read_seqbegin_or_lock(seqlock_t *lock, int *seq)* Return: true if a read section retry is required, false otherwise */ static inline int need_seqretry (seqlock_t *lock,int seq) +__releases_shared (lock) __no_context_analysis {return !(seq &1 ) &&read_seqretry (lock, seq); }
@@ -1153,6 +1174,7 @@ static inline int need_seqretry(seqlock_t *lock, int seq)* with read_seqbegin_or_lock() and validated by need_seqretry(). */ static inline void done_seqretry (seqlock_t *lock,int seq) + __no_context_analysis {if (seq &1 )read_sequnlock_excl (lock);
@@ -1180,6 +1202,7 @@ static inline void done_seqretry(seqlock_t *lock, int seq)*/ static inline unsigned long read_seqbegin_or_lock_irqsave (seqlock_t *lock,int *seq) +__acquires_shared (lock) __no_context_analysis {unsigned long flags =0 ;
@@ -1205,6 +1228,7 @@ read_seqbegin_or_lock_irqsave(seqlock_t *lock, int *seq)*/ static inline void done_seqretry_irqrestore (seqlock_t *lock,int seq,unsigned long flags) + __no_context_analysis {if (seq &1 )read_sequnlock_excl_irqrestore (lock, flags);
include/linux/seqlock_types.h +3 -2
@@ -81,13 +81,14 @@ SEQCOUNT_LOCKNAME(mutex, struct mutex, true, mutex)* - Comments on top of seqcount_t * - Documentation/locking/seqlock.rst */ -typedef struct { +context_guard_struct (seqlock) {/* * Make sure that readers don't starve writers on PREEMPT_RT: use * seqcount_spinlock_t instead of seqcount_t. Check __SEQ_LOCK(). */ seqcount_spinlock_t seqcount;spinlock_t lock; -}seqlock_t ; +}; +typedef struct seqlock seqlock_t ;#endif /* __LINUX_SEQLOCK_TYPES_H */
lib/test_context-analysis.c +43 -0
52 lines not on this page · raw message
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Marco Elver
maintainerPATCH v4 12/35 bit_spinlock: Include missing <asm/processor.h>
In reply to Marco ElverIncluding <linux/bit_spinlock.h> into an empty TU will result in the compiler complaining:
./include/linux/bit_spinlock.h:34:4: error: call to undeclared function 'cpu_relax'; <...>
34 | cpu_relax();
| ^1 error generated.
Include <asm/processor.h> to allow including bit_spinlock.h where <asm/processor.h> is not otherwise included.
--- include/linux/bit_spinlock.h | 2 ++ 1 file changed, 2 insertions(+)
include/linux/bit_spinlock.h +2 -0
@@ -7,6 +7,8 @@#include <linux/atomic.h> #include <linux/bug.h> +#include <asm/processor.h> /* for cpu_relax() */ +/* * bit-based spin_lock() *
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Marco Elver
maintainerPATCH v4 13/35 bit_spinlock: Support Clang's context analysis
In reply to Marco ElverThe annotations for bit_spinlock.h have simply been using "bitlock" as the token. For Sparse, that was likely sufficient in most cases. But Clang's context analysis is more precise, and we need to ensure we can distinguish different bitlocks.
To do so, add a token context, and a macro __bitlock(bitnum, addr) that is used to construct unique per-bitlock tokens.
Add the appropriate test.
<linux/list_bl.h> is implicitly included through other includes, and requires 2 annotations to indicate that acquisition (without release) and release (without prior acquisition) of its bitlock is intended.
---
v4:
* Rename capability -> context analysis.
--- Documentation/dev-tools/context-analysis.rst | 3 ++- include/linux/bit_spinlock.h | 22 ++++++++++++++--- include/linux/list_bl.h | 2 ++ lib/test_context-analysis.c | 26 ++++++++++++++++++++ 4 files changed, 48 insertions(+), 5 deletions(-)
Documentation/dev-tools/context-analysis.rst +2 -1
@@ -80,7 +80,8 @@ Supported Kernel Primitives ~~~~~~~~~~~~~~~~~~~~~~~~~~~ Currently the following synchronization primitives are supported: -`raw_spinlock_t`, `spinlock_t`, `rwlock_t`, `mutex`, `seqlock_t`. +`raw_spinlock_t`, `spinlock_t`, `rwlock_t`, `mutex`, `seqlock_t`, +`bit_spinlock`. For context guards with an initialization function (e.g., `spin_lock_init()`), calling this function before initializing any guarded members or globals
include/linux/bit_spinlock.h +18 -4
@@ -9,6 +9,16 @@#include <asm/processor.h> /* for cpu_relax() */ +/* +* For static context analysis, we need a unique token for each possible bit +* that can be used as a bit_spinlock. The easiest way to do that is to create a +* fake context that we can cast to with the __bitlock(bitnum, addr) macro +* below, which will give us unique instances for each (bit, addr) pair that the +* static analysis can use. +*/ +context_guard_struct (__context_bitlock) { }; +#define __bitlock (bitnum, addr) (struct __context_bitlock *)(bitnum + (addr)) +/* * bit-based spin_lock() *
@@ -16,6 +26,7 @@* are significantly faster. */ static __always_inline void bit_spin_lock(int bitnum, unsigned long *addr) +__acquires (__bitlock (bitnum, addr)) {/* * Assuming the lock is uncontended, this never enters
@@ -34,13 +45,14 @@ static __always_inline void bit_spin_lock(int bitnum, unsigned long *addr)preempt_disable (); }#endif -__acquire (bitlock); +__acquire (__bitlock (bitnum, addr)); }/* * Return true if it was acquired */ static __always_inline int bit_spin_trylock(int bitnum, unsigned long *addr) +__cond_acquires (true,__bitlock (bitnum, addr)) {preempt_disable ();#if defined(CONFIG_SMP ) || defined(CONFIG_DEBUG_SPINLOCK )
@@ -49,7 +61,7 @@ static __always_inline int bit_spin_trylock(int bitnum, unsigned long *addr) return 0; }#endif -__acquire (bitlock); +__acquire (__bitlock (bitnum ,addr ));return 1 ; }
@@ -57,6 +69,7 @@ static __always_inline int bit_spin_trylock(int bitnum, unsigned long *addr)* bit-based spin_unlock() */ static __always_inline void bit_spin_unlock(int bitnum, unsigned long *addr) +__releases (__bitlock (bitnum, addr)) {#ifdef CONFIG_DEBUG_SPINLOCK BUG_ON (!test_bit (bitnum, addr));
@@ -65,7 +78,7 @@ static __always_inline void bit_spin_unlock(int bitnum, unsigned long *addr)clear_bit_unlock (bitnum, addr);#endif preempt_enable (); -__release (bitlock); +__release (__bitlock (bitnum, addr)); }/*
@@ -74,6 +87,7 @@ static __always_inline void bit_spin_unlock(int bitnum, unsigned long *addr)* protecting the rest of the flags in the word. */ static __always_inline void __bit_spin_unlock(int bitnum, unsigned long *addr) +__releases (__bitlock (bitnum, addr)) {#ifdef CONFIG_DEBUG_SPINLOCK BUG_ON (!test_bit (bitnum, addr));
@@ -82,7 +96,7 @@ static __always_inline void __bit_spin_unlock(int bitnum, unsigned long *addr)__clear_bit_unlock (bitnum, addr);#endif preempt_enable (); -__release (bitlock); +__release (__bitlock (bitnum, addr)); }/*
include/linux/list_bl.h +2 -0
@@ -144,11 +144,13 @@ static inline void hlist_bl_del_init(struct hlist_bl_node *n) }static inline void hlist_bl_lock (struct hlist_bl_head *b) +__acquires (__bitlock (0 , b)) {bit_spin_lock (0 , (unsigned long *)b); }static inline void hlist_bl_unlock (struct hlist_bl_head *b) +__releases (__bitlock (0 , b)) {__bit_spin_unlock (0 , (unsigned long *)b); }
lib/test_context-analysis.c +26 -0
@@ -4,6 +4,7 @@* positive errors when compiled with Clang's context analysis. */ +#include <linux/bit_spinlock.h> #include <linux/build_bug.h> #include <linux/mutex.h> #include <linux/seqlock.h>
@@ -251,3 +252,28 @@ static void __used test_seqlock_writer(struct test_seqlock_data *d) d->counter++;write_sequnlock_irqrestore (&d->sl, flags); } + +struct test_bit_spinlock_data { +unsigned long bits; + int counter __guarded_by(__bitlock(3, &bits)); +}; + +static void __used test_bit_spin_lock (struct test_bit_spinlock_data *d) +{ +/* +* Note, the analysis seems to have false negatives, because it won't +* precisely recognize the bit of the fake __bitlock() token. +*/ +bit_spin_lock (3 , &d->bits); + d->counter++; +bit_spin_unlock (3 , &d->bits); + +bit_spin_lock (3 , &d->bits); + d->counter++; +__bit_spin_unlock (3 , &d->bits); + +if (bit_spin_trylock (3 , &d->bits)) { + d->counter++; +bit_spin_unlock (3 , &d->bits); + } +}
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Marco Elver
maintainerPATCH v4 14/35 rcu: Support Clang's context analysis
In reply to Marco ElverImprove the existing annotations to properly support Clang's context analysis.
The old annotations distinguished between RCU, RCU_BH, and RCU_SCHED; however, to more easily be able to express that "hold the RCU read lock" without caring if the normal, _bh(), or _sched() variant was used we'd have to remove the distinction of the latter variants: change the _bh() and _sched() variants to also acquire "RCU".
When (and if) we introduce context guards to denote more generally that "IRQ", "BH", "PREEMPT" contexts are disabled, it would make sense to acquire these instead of RCU_BH and RCU_SCHED respectively.
The above change also simplified introducing __guarded_by support, where only the "RCU" context guard needs to be held: introduce __rcu_guarded, where Clang's context analysis warns if a pointer is dereferenced without any of the RCU locks held, or updated without the appropriate helpers.
The primitives rcu_assign_pointer() and friends are wrapped with context_unsafe(), which enforces using them to update RCU-protected pointers marked with __rcu_guarded.
---
v3:
* Properly support reentrancy via new compiler support.
v2:
* Reword commit message and point out reentrancy caveat.
--- Documentation/dev-tools/context-analysis.rst | 2 +- include/linux/rcupdate.h | 77 ++++++++++++------ lib/test_context-analysis.c | 85 ++++++++++++++++++++ 3 files changed, 139 insertions(+), 25 deletions(-)
Documentation/dev-tools/context-analysis.rst +1 -1
@@ -81,7 +81,7 @@ Supported Kernel Primitives Currently the following synchronization primitives are supported: `raw_spinlock_t`, `spinlock_t`, `rwlock_t`, `mutex`, `seqlock_t`, -`bit_spinlock`. +`bit_spinlock`, RCU. For context guards with an initialization function (e.g., `spin_lock_init()`), calling this function before initializing any guarded members or globals
include/linux/rcupdate.h +53 -24
229 lines not on this page · raw message
lib/test_context-analysis.c +85 -0
94 lines not on this page · raw message
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Paul E. McKenney
maintainerRe: [PATCH v4 14/35] rcu: Support Clang's context analysis
Quoted 19 lines · Marco Elver
Improve the existing annotations to properly support Clang's context analysis.
The old annotations distinguished between RCU,
RCU_BH, andRCU_SCHED; however, to more easily be able to express that "hold the RCU read lock" without caring if the normal,_bh(), or_sched()variant was used we'd have to remove the distinction of the latter variants: change the_bh()and_sched()variants to also acquire "RCU".When (and if) we introduce context guards to denote more generally that "IRQ", "BH", "PREEMPT" contexts are disabled, it would make sense to acquire these instead of
RCU_BHandRCU_SCHEDrespectively.The above change also simplified introducing
__guarded_bysupport, where only the "RCU" context guard needs to be held: introduce__rcu_guarded, where Clang's context analysis warns if a pointer is dereferenced without any of the RCU locks held, or updated without the appropriate helpers.
Quoted 5 lines
The primitives
rcu_assign_pointer()and friends are wrapped withcontext_unsafe(), which enforces using them to update RCU-protected pointers marked with__rcu_guarded.Signed-off-by Marco Elver <[email protected]>
Good reminder! I had lost track of this series.
My big questions here are:
o What about RCU readers using (say) preempt_disable() instead
of rcu_read_lock_sched()?
o What about RCU readers using local_bh_disable() instead of
rcu_read_lock_sched()?
And keeping in mind that such readers might start in assembly language.
One reasonable approach is to require such readers to use something like rcu_dereference_all() or rcu_dereference_all_check(), which could then have special dispensation to instead rely on run-time checks.
Another more powerful approach would be to make this facility also track preemption, interrupt, NMI, and BH contexts.
Either way could be a significant improvement over what we have now.
Thoughts?
Thanx, Paul
Quoted 380 lines
---
v3:
* Properly support reentrancy via new compiler support.v2:
* Reword commit message and point out reentrancy caveat.--- Documentation/dev-tools/context-analysis.rst | 2 +- include/linux/rcupdate.h | 77 ++++++++++++------ lib/test_context-analysis.c | 85 ++++++++++++++++++++ 3 files changed, 139 insertions(+), 25 deletions(-)Documentation/dev-tools/context-analysis.rst +1
-1@@ -81,7 +81,7 @@ Supported Kernel Primitives Currently the following synchronization primitives are supported: `raw_spinlock_t`, `spinlock_t`, `rwlock_t`, `mutex`, `seqlock_t`, -`bit_spinlock`. +`bit_spinlock`, RCU. For context guards with an initialization function (e.g., `spin_lock_init()`), calling this function before initializing any guarded members or globalsinclude/linux/rcupdate.h +53
-24@@ -31,6 +31,16 @@#include <asm/processor.h> #include <linux/context_tracking_irq.h> +token_context_guard (RCU , __reentrant_ctx_guard); +token_context_guard_instance (RCU ,RCU_SCHED ); +token_context_guard_instance (RCU ,RCU_BH ); + +/* +* A convenience macro that can be used for RCU-protected globals or struct +* members; adds type qualifier __rcu, and also enforces __guarded_by(RCU). +*/ +#define __rcu_guarded __rcu __guarded_by(RCU) +#define ULONG_CMP_GE (a, b) (ULONG_MAX / 2 >= (a) - (b))#define ULONG_CMP_LT (a, b) (ULONG_MAX / 2 < (a) - (b))@@ -425,7 +435,8 @@ static inline void rcu_preempt_sleep_check(void) { }// See RCU_LOCKDEP_WARN() for an explanation of the double call to // debug_lockdep_rcu_enabled(). -static inline bool lockdep_assert_rcu_helper (bool c) +static inline bool lockdep_assert_rcu_helper (bool c,const struct __ctx_guard_RCU *ctx) +__assumes_shared_ctx_guard (RCU )__assumes_shared_ctx_guard (ctx) {return debug_lockdep_rcu_enabled () && (c || !rcu_is_watching() || !rcu_lockdep_current_cpu_online()) &&@@ -438,7 +449,7 @@ static inline bool lockdep_assert_rcu_helper(bool c)* Splats if lockdep is enabled and there is no rcu_read_lock() in effect. */ #define lockdep_assert_in_rcu_read_lock () \ - WARN_ON_ONCE(lockdep_assert_rcu_helper(!lock_is_held(&rcu_lock_map))) + WARN_ON_ONCE(lockdep_assert_rcu_helper(!lock_is_held(&rcu_lock_map), RCU))/** * lockdep_assert_in_rcu_read_lock_bh - WARN if not protected by rcu_read_lock_bh() @@ -448,7 +459,7 @@ static inline bool lockdep_assert_rcu_helper(bool c)* actual rcu_read_lock_bh() is required. */ #define lockdep_assert_in_rcu_read_lock_bh () \ - WARN_ON_ONCE(lockdep_assert_rcu_helper(!lock_is_held(&rcu_bh_lock_map))) + WARN_ON_ONCE(lockdep_assert_rcu_helper(!lock_is_held(&rcu_bh_lock_map), RCU_BH))/** * lockdep_assert_in_rcu_read_lock_sched - WARN if not protected by rcu_read_lock_sched() @@ -458,7 +469,7 @@ static inline bool lockdep_assert_rcu_helper(bool c)* instead an actual rcu_read_lock_sched() is required. */ #define lockdep_assert_in_rcu_read_lock_sched () \ - WARN_ON_ONCE(lockdep_assert_rcu_helper(!lock_is_held(&rcu_sched_lock_map))) + WARN_ON_ONCE(lockdep_assert_rcu_helper(!lock_is_held(&rcu_sched_lock_map), RCU_SCHED))/** * lockdep_assert_in_rcu_reader - WARN if not within some type of RCU reader @@ -476,17 +487,17 @@ static inline bool lockdep_assert_rcu_helper(bool c)WARN_ON_ONCE (lockdep_assert_rcu_helper (!lock_is_held (&rcu_lock_map) && \ !lock_is_held (&rcu_bh_lock_map) && \ !lock_is_held (&rcu_sched_lock_map) && \ - preemptible())) + preemptible(), RCU))#else /* #ifdef CONFIG_PROVE_RCU */ #define RCU_LOCKDEP_WARN (c, s) do { } while (0 && (c))#define rcu_sleep_check () do { } while (0) -#define lockdep_assert_in_rcu_read_lock () do { } while (0) -#define lockdep_assert_in_rcu_read_lock_bh () do { } while (0) -#define lockdep_assert_in_rcu_read_lock_sched () do { } while (0) -#define lockdep_assert_in_rcu_reader () do { } while (0) +#define lockdep_assert_in_rcu_read_lock () __assume_shared_ctx_guard(RCU) +#define lockdep_assert_in_rcu_read_lock_bh () __assume_shared_ctx_guard(RCU_BH) +#define lockdep_assert_in_rcu_read_lock_sched () __assume_shared_ctx_guard(RCU_SCHED) +#define lockdep_assert_in_rcu_reader () __assume_shared_ctx_guard(RCU)#endif /* #else #ifdef CONFIG_PROVE_RCU */ @@ -506,11 +517,11 @@ static inline bool lockdep_assert_rcu_helper(bool c)#endif /* #else #ifdef __CHECKER__ */ #define __unrcu_pointer (p, local) \ -({ \ +context_unsafe( \ typeof(*p) *local = (typeof(*p) *__force)(p); \ rcu_check_sparse(p, __rcu); \ - ((typeof(*p) __force __kernel *)(local)); \ -}) + ((typeof(*p) __force __kernel *)(local)) \ +)/** * unrcu_pointer - mark a pointer as not being RCU protected * @p: pointer needing to lose its __rcu property @@ -586,7 +597,7 @@ static inline bool lockdep_assert_rcu_helper(bool c)* other macros that it invokes. */ #define rcu_assign_pointer (p, v) \ -do { \ +context_unsafe( \ uintptr_t _r_a_p__v = (uintptr_t)(v); \ rcu_check_sparse(p, __rcu); \ \@@ -594,7 +605,7 @@ do { \WRITE_ONCE ((p), (typeof (p))(_r_a_p__v)); \ else \ smp_store_release(&p, RCU_INITIALIZER((typeof(p))_r_a_p__v)); \ -}while (0 ) +)/** * rcu_replace_pointer() - replace an RCU pointer, returning its old value @@ -861,9 +872,10 @@ do { \* only when acquiring spinlocks that are subject to priority inheritance. */ static __always_inline void rcu_read_lock(void) +__acquires_shared (RCU ) {__rcu_read_lock (); -__acquire (RCU ); +__acquire_shared (RCU );rcu_lock_acquire (&rcu_lock_map);RCU_LOCKDEP_WARN (!rcu_is_watching (),"rcu_read_lock() used illegally while idle" );@@ -891,11 +903,12 @@ static __always_inline void rcu_read_lock(void)* See rcu_read_lock() for more information. */ static inline void rcu_read_unlock (void ) +__releases_shared (RCU ) {RCU_LOCKDEP_WARN (!rcu_is_watching (),"rcu_read_unlock() used illegally while idle" );rcu_lock_release (&rcu_lock_map);/* Keep acq info for rls diags. */ -__release (RCU ); +__release_shared (RCU );__rcu_read_unlock (); }@@ -914,9 +927,11 @@ static inline void rcu_read_unlock(void)* was invoked from some other task. */ static inline void rcu_read_lock_bh (void ) +__acquires_shared (RCU )__acquires_shared (RCU_BH ) {local_bh_disable (); -__acquire (RCU_BH ); +__acquire_shared (RCU ); +__acquire_shared (RCU_BH );rcu_lock_acquire (&rcu_bh_lock_map);RCU_LOCKDEP_WARN (!rcu_is_watching (),"rcu_read_lock_bh() used illegally while idle" );@@ -928,11 +943,13 @@ static inline void rcu_read_lock_bh(void)* See rcu_read_lock_bh() for more information. */ static inline void rcu_read_unlock_bh (void ) +__releases_shared (RCU )__releases_shared (RCU_BH ) {RCU_LOCKDEP_WARN (!rcu_is_watching (),"rcu_read_unlock_bh() used illegally while idle" );rcu_lock_release (&rcu_bh_lock_map); -__release (RCU_BH ); +__release_shared (RCU_BH ); +__release_shared (RCU );local_bh_enable (); }@@ -952,9 +969,11 @@ static inline void rcu_read_unlock_bh(void)* rcu_read_lock_sched() was invoked from an NMI handler. */ static inline void rcu_read_lock_sched (void ) +__acquires_shared (RCU )__acquires_shared (RCU_SCHED ) {preempt_disable (); -__acquire (RCU_SCHED ); +__acquire_shared (RCU ); +__acquire_shared (RCU_SCHED );rcu_lock_acquire (&rcu_sched_lock_map);RCU_LOCKDEP_WARN (!rcu_is_watching (),"rcu_read_lock_sched() used illegally while idle" );@@ -962,9 +981,11 @@ static inline void rcu_read_lock_sched(void)/* Used by lockdep and tracing: cannot be traced, cannot call lockdep. */ static inline notrace void rcu_read_lock_sched_notrace(void) +__acquires_shared (RCU )__acquires_shared (RCU_SCHED ) {preempt_disable_notrace (); -__acquire (RCU_SCHED ); +__acquire_shared (RCU ); +__acquire_shared (RCU_SCHED ); }/** @@ -973,22 +994,27 @@ static inline notrace void rcu_read_lock_sched_notrace(void)* See rcu_read_lock_sched() for more information. */ static inline void rcu_read_unlock_sched (void ) +__releases_shared (RCU )__releases_shared (RCU_SCHED ) {RCU_LOCKDEP_WARN (!rcu_is_watching (),"rcu_read_unlock_sched() used illegally while idle" );rcu_lock_release (&rcu_sched_lock_map); -__release (RCU_SCHED ); +__release_shared (RCU_SCHED ); +__release_shared (RCU );preempt_enable (); }/* Used by lockdep and tracing: cannot be traced, cannot call lockdep. */ static inline notrace void rcu_read_unlock_sched_notrace(void) +__releases_shared (RCU )__releases_shared (RCU_SCHED ) { -__release (RCU_SCHED ); +__release_shared (RCU_SCHED ); +__release_shared (RCU );preempt_enable_notrace (); } static __always_inline void rcu_read_lock_dont_migrate(void) +__acquires_shared (RCU ) {if (IS_ENABLED (CONFIG_PREEMPT_RCU ))migrate_disable ();@@ -996,6 +1022,7 @@ static __always_inline void rcu_read_lock_dont_migrate(void) }static inline void rcu_read_unlock_migrate (void ) +__releases_shared (RCU ) {rcu_read_unlock ();if (IS_ENABLED (CONFIG_PREEMPT_RCU ))@@ -1041,10 +1068,10 @@ static inline void rcu_read_unlock_migrate(void)* ordering guarantees for either the CPU or the compiler. */ #define RCU_INIT_POINTER (p, v) \ - do { \ + context_unsafe( \ rcu_check_sparse(p, __rcu); \ WRITE_ONCE(p, RCU_INITIALIZER(v)); \ - } while (0) + )/** * RCU_POINTER_INITIALIZER() - statically initialize an RCU protected pointer @@ -1206,4 +1233,6 @@ DEFINE_LOCK_GUARD_0(rcu, } while (0), rcu_read_unlock()) +DECLARE_LOCK_GUARD_0_ATTRS(rcu, __acquires_shared(RCU), __releases_shared(RCU)) +#endif /* __LINUX_RCUPDATE_H */ lib/test_context-analysis.c +85
-0@@ -7,6 +7,7 @@#include <linux/bit_spinlock.h> #include <linux/build_bug.h> #include <linux/mutex.h> +#include <linux/rcupdate.h> #include <linux/seqlock.h> #include <linux/spinlock.h> @@ -277,3 +278,87 @@ static void __used test_bit_spin_lock(struct test_bit_spinlock_data *d)bit_spin_unlock (3 , &d->bits); } } + +/* +* Test that we can mark a variable guarded by RCU, and we can dereference and +* write to the pointer with RCU's primitives. +*/ +struct test_rcu_data { +long __rcu_guarded *data; +}; + +static void __used test_rcu_guarded_reader (struct test_rcu_data *d) +{ +rcu_read_lock (); + (void )rcu_dereference (d->data); +rcu_read_unlock (); + +rcu_read_lock_bh (); + (void )rcu_dereference (d->data); +rcu_read_unlock_bh (); + +rcu_read_lock_sched (); + (void )rcu_dereference (d->data); +rcu_read_unlock_sched (); +} + +static void __used test_rcu_guard (struct test_rcu_data *d) +{ +guard (rcu)(); + (void )rcu_dereference (d->data); +} + +static void __used test_rcu_guarded_updater (struct test_rcu_data *d) +{ +rcu_assign_pointer (d->data,NULL ); +RCU_INIT_POINTER (d->data,NULL ); + (void )unrcu_pointer (d->data); +} + +static void wants_rcu_held (void )__must_hold_shared (RCU ) { } +static void wants_rcu_held_bh (void )__must_hold_shared (RCU_BH ) { } +static void wants_rcu_held_sched (void )__must_hold_shared (RCU_SCHED ) { } + +static void __used test_rcu_lock_variants (void ) +{ +rcu_read_lock (); +wants_rcu_held (); +rcu_read_unlock (); + +rcu_read_lock_bh (); +wants_rcu_held_bh (); +rcu_read_unlock_bh (); + +rcu_read_lock_sched (); +wants_rcu_held_sched (); +rcu_read_unlock_sched (); +} + +static void __used test_rcu_lock_reentrant (void ) +{ +rcu_read_lock (); +rcu_read_lock (); +rcu_read_lock_bh (); +rcu_read_lock_bh (); +rcu_read_lock_sched (); +rcu_read_lock_sched (); + +rcu_read_unlock_sched (); +rcu_read_unlock_sched (); +rcu_read_unlock_bh (); +rcu_read_unlock_bh (); +rcu_read_unlock (); +rcu_read_unlock (); +} + +static void __used test_rcu_assert_variants (void ) +{ +lockdep_assert_in_rcu_read_lock (); +wants_rcu_held (); + +lockdep_assert_in_rcu_read_lock_bh (); +wants_rcu_held_bh (); + +lockdep_assert_in_rcu_read_lock_sched (); +wants_rcu_held_sched (); +}Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Marco Elver
maintainerRe: [PATCH v4 14/35] rcu: Support Clang's context analysis
Quoted 10 lines · Paul E. McKenney
Quoted 9 lines · Marco Elver
Improve the existing annotations to properly support Clang's context analysis.
The old annotations distinguished between RCU,
RCU_BH, andRCU_SCHED; however, to more easily be able to express that "hold the RCU read lock" without caring if the normal,_bh(), or_sched()variant was used we'd have to remove the distinction of the latter variants: change the_bh()and_sched()variants to also acquire "RCU".
Quoted 3 lines
Quoted 3 lines
When (and if) we introduce context guards to denote more generally that "IRQ", "BH", "PREEMPT" contexts are disabled, it would make sense to acquire these instead of
RCU_BHandRCU_SCHEDrespectively.
^
Quoted 10 lines
Quoted 10 lines
The above change also simplified introducing
__guarded_bysupport, where only the "RCU" context guard needs to be held: introduce__rcu_guarded, where Clang's context analysis warns if a pointer is dereferenced without any of the RCU locks held, or updated without the appropriate helpers.The primitives
rcu_assign_pointer()and friends are wrapped withcontext_unsafe(), which enforces using them to update RCU-protected pointers marked with__rcu_guarded.
Quoted 8 lines
Quoted 1 line
Signed-off-by Marco Elver <[email protected]>Good reminder! I had lost track of this series.
My big questions here are:
o What about RCU readers using (say)
preempt_disable()instead
ofrcu_read_lock_sched()?
The infrastructure that is being built up in this series will be able to support this, it's "just" a matter of enhancing our various interfaces/macros to use the right annotations, and working out which kinds of contexts we want to support. There are the obvious candidates, which this series is being applied to, as a starting point, but longer-term there are other kinds of context rules that can be checked with this context analysis. However, I think we have to start somewhere.
Quoted 2 lines
o What about RCU readers using
local_bh_disable()instead ofrcu_read_lock_sched()?
Same as above; this requires adding the necessary annotations to the BH-disabling/enabling primitives.
Quoted 1 line
And keeping in mind that such readers might start in assembly language.
We can handle this by annotating the C functions invoked from assembly with attributes like __must_hold_shared(RCU) or __releases_shared(RCU) (if the callee is expected to release the RCU read lock / re-enable preemption / etc.) or similar.
Quoted 3 lines
One reasonable approach is to require such readers to use something like
rcu_dereference_all()orrcu_dereference_all_check(), which could then have special dispensation to instead rely on run-time checks.
Agree. The current infrastructure encourages run-time checks where the static analysis cannot be helped sufficiently otherwise (see patch:
"lockdep: Annotate lockdep assertions for context analysis").
Quoted 6 lines
Another more powerful approach would be to make this facility also track preemption, interrupt, NMI, and BH contexts.
Either way could be a significant improvement over what we have now.
Thoughts?
The current infrastructure is powerful enough to allow for tracking more contexts, such as interrupt, NMI, and BH contexts, and as I hinted above, would be nice to eventually get to! But I think this is also a question of how much do we want to front-load for this to be useful, and what should incrementally be enhanced while the baseline infrastructure is already available.
I think the current series is the baseline required support to be useful to a large fraction of "normal" code in the kernel.
On a whole, my strategy was to get to a point where maintainers and developers can start using context analysis where appropriate, but at the same time build up and incrementally add more supported contexts in parallel. There's also a good chance that, once baseline support lands, more interested parties contribute and things progress faster (or so I'd hope :-)).
Thanks,
-- Marco
Re: [PATCH v4 14/35] rcu: Support Clang's context analysis
Quoted 11 lines · Marco Elver
Quoted 10 lines · Paul E. McKenney
Quoted 9 lines · Marco Elver
Improve the existing annotations to properly support Clang's context analysis.
The old annotations distinguished between RCU,
RCU_BH, andRCU_SCHED; however, to more easily be able to express that "hold the RCU read lock" without caring if the normal,_bh(), or_sched()variant was used we'd have to remove the distinction of the latter variants: change the_bh()and_sched()variants to also acquire "RCU".
Quoted 5 lines
Quoted 3 lines
Quoted 3 lines
When (and if) we introduce context guards to denote more generally that "IRQ", "BH", "PREEMPT" contexts are disabled, it would make sense to acquire these instead of
RCU_BHandRCU_SCHEDrespectively.^
"I can't read!" ;-)
Quoted 41 lines
Quoted 10 lines
Quoted 10 lines
The above change also simplified introducing
__guarded_bysupport, where only the "RCU" context guard needs to be held: introduce__rcu_guarded, where Clang's context analysis warns if a pointer is dereferenced without any of the RCU locks held, or updated without the appropriate helpers.The primitives
rcu_assign_pointer()and friends are wrapped withcontext_unsafe(), which enforces using them to update RCU-protected pointers marked with__rcu_guarded.Quoted 8 lines
Quoted 1 line
Signed-off-by Marco Elver <[email protected]>Good reminder! I had lost track of this series.
My big questions here are:
o What about RCU readers using (say)
preempt_disable()instead
ofrcu_read_lock_sched()?The infrastructure that is being built up in this series will be able to support this, it's "just" a matter of enhancing our various interfaces/macros to use the right annotations, and working out which kinds of contexts we want to support. There are the obvious candidates, which this series is being applied to, as a starting point, but longer-term there are other kinds of context rules that can be checked with this context analysis. However, I think we have to start somewhere.
Quoted 2 lines
o What about RCU readers using
local_bh_disable()instead ofrcu_read_lock_sched()?Same as above; this requires adding the necessary annotations to the BH-disabling/enabling primitives.
Quoted 1 line
And keeping in mind that such readers might start in assembly language.
We can handle this by annotating the C functions invoked from assembly with attributes like
__must_hold_shared(RCU)or__releases_shared(RCU)(if the callee is expected to release the RCU read lock / re-enable preemption / etc.) or similar.
Quoted 7 lines
Quoted 3 lines
One reasonable approach is to require such readers to use something like
rcu_dereference_all()orrcu_dereference_all_check(), which could then have special dispensation to instead rely on run-time checks.Agree. The current infrastructure encourages run-time checks where the static analysis cannot be helped sufficiently otherwise (see patch:
"lockdep: Annotate lockdep assertions for context analysis").
OK, very good.
Quoted 14 lines
Quoted 6 lines
Another more powerful approach would be to make this facility also track preemption, interrupt, NMI, and BH contexts.
Either way could be a significant improvement over what we have now.
Thoughts?
The current infrastructure is powerful enough to allow for tracking more contexts, such as interrupt, NMI, and BH contexts, and as I hinted above, would be nice to eventually get to! But I think this is also a question of how much do we want to front-load for this to be useful, and what should incrementally be enhanced while the baseline infrastructure is already available.
Quoted 2 lines
I think the current series is the baseline required support to be useful to a large fraction of "normal" code in the kernel.
Makes sense to me!
Quoted 6 lines
On a whole, my strategy was to get to a point where maintainers and developers can start using context analysis where appropriate, but at the same time build up and incrementally add more supported contexts in parallel. There's also a good chance that, once baseline support lands, more interested parties contribute and things progress faster (or so I'd hope :-)).
I know that feelling! ;-)
OK, for this patch and the SRCU patch based on a quick once-over:
Thanx, Paul
Marco Elver
maintainerPATCH v4 15/35 srcu: Support Clang's context analysis
In reply to Marco ElverAdd support for Clang's context analysis for SRCU.
---
v4:
* Rename capability -> context analysis.
v3:
* Switch to DECLARE_LOCK_GUARD_1_ATTRS() (suggested by Peter)
* Support SRCU being reentrant.
--- Documentation/dev-tools/context-analysis.rst | 2 +- include/linux/srcu.h | 64 +++++++++++++------- include/linux/srcutiny.h | 4 ++ include/linux/srcutree.h | 6 +- lib/test_context-analysis.c | 24 ++++++++ 5 files changed, 77 insertions(+), 23 deletions(-)
Documentation/dev-tools/context-analysis.rst +1 -1
@@ -81,7 +81,7 @@ Supported Kernel Primitives Currently the following synchronization primitives are supported: `raw_spinlock_t`, `spinlock_t`, `rwlock_t`, `mutex`, `seqlock_t`, -`bit_spinlock`, RCU. +`bit_spinlock`, RCU, SRCU (`srcu_struct`). For context guards with an initialization function (e.g., `spin_lock_init()`), calling this function before initializing any guarded members or globals
include/linux/srcu.h +43 -21
190 lines not on this page · raw message
include/linux/srcutiny.h +4 -0
@@ -61,6 +61,7 @@ void synchronize_srcu(struct srcu_struct *ssp);* index that must be passed to the matching srcu_read_unlock(). */ static inline int __srcu_read_lock (struct srcu_struct *ssp) +__acquires_shared (ssp) {int idx;
@@ -68,6 +69,7 @@ static inline int __srcu_read_lock(struct srcu_struct *ssp) idx = ((READ_ONCE (ssp->srcu_idx) +1 ) &0x2 ) >>1 ;WRITE_ONCE (ssp->srcu_lock_nesting[idx],READ_ONCE (ssp->srcu_lock_nesting[idx]) +1 );preempt_enable (); +__acquire_shared (ssp);return idx; }
@@ -84,11 +86,13 @@ static inline struct srcu_ctr __percpu *__srcu_ctr_to_ptr(struct srcu_struct *ss }static inline struct srcu_ctr __percpu *__srcu_read_lock_fast (struct srcu_struct *ssp) +__acquires_shared (ssp) {return __srcu_ctr_to_ptr (ssp,__srcu_read_lock (ssp)); }static inline void __srcu_read_unlock_fast (struct srcu_struct *ssp,struct srcu_ctr __percpu *scp) +__releases_shared (ssp) {__srcu_read_unlock (ssp,__srcu_ptr_to_ctr (ssp, scp)); }
include/linux/srcutree.h +5 -1
@@ -207,7 +207,7 @@ struct srcu_struct { #define DEFINE_SRCU(name) __DEFINE_SRCU(name, /* not static */)#define DEFINE_STATIC_SRCU (name) __DEFINE_SRCU(name, static) -int __srcu_read_lock(struct srcu_struct *ssp) __acquires(ssp); +int __srcu_read_lock(struct srcu_struct *ssp) __acquires_shared(ssp);void synchronize_srcu_expedited (struct srcu_struct *ssp);void srcu_barrier (struct srcu_struct *ssp);void srcu_torture_stats_print (struct srcu_struct *ssp,char *tt,char *tf);
@@ -259,6 +259,7 @@ static inline struct srcu_ctr __percpu *__srcu_ctr_to_ptr(struct srcu_struct *ss* implementations of this_cpu_inc(). */ static inline struct srcu_ctr __percpu notrace *__srcu_read_lock_fast(struct srcu_struct *ssp) +__acquires_shared (ssp) {struct srcu_ctr __percpu *scp =READ_ONCE (ssp->srcu_ctrp);
@@ -267,6 +268,7 @@ static inline struct srcu_ctr __percpu notrace *__srcu_read_lock_fast(struct srcelse atomic_long_inc (raw_cpu_ptr (&scp->srcu_locks));// Y, and implicit RCU reader. barrier ();/* Avoid leaking the critical section. */ +__acquire_shared (ssp);return scp; }
@@ -281,7 +283,9 @@ static inline struct srcu_ctr __percpu notrace *__srcu_read_lock_fast(struct src*/ static inline void notrace__srcu_read_unlock_fast (struct srcu_struct *ssp,struct srcu_ctr __percpu *scp) +__releases_shared (ssp) { +__release_shared (ssp);barrier ();/* Avoid leaking the critical section. */ if (!IS_ENABLED (CONFIG_NEED_SRCU_NMI_SAFE ))this_cpu_inc (scp->srcu_unlocks.counter);// Z, and implicit RCU reader.
lib/test_context-analysis.c +24 -0
@@ -10,6 +10,7 @@#include <linux/rcupdate.h> #include <linux/seqlock.h> #include <linux/spinlock.h> +#include <linux/srcu.h> /* * Test that helper macros work as expected.
@@ -362,3 +363,26 @@ static void __used test_rcu_assert_variants(void)lockdep_assert_in_rcu_read_lock_sched ();wants_rcu_held_sched (); } + +struct test_srcu_data { +struct srcu_struct srcu; +long __rcu_guarded *data; +}; + +static void __used test_srcu (struct test_srcu_data *d) +{ +init_srcu_struct (&d->srcu); + +int idx =srcu_read_lock (&d->srcu); +long *data =srcu_dereference (d->data, &d->srcu); + (void )data; +srcu_read_unlock (&d->srcu, idx); + +rcu_assign_pointer (d->data,NULL ); +} + +static void __used test_srcu_guard (struct test_srcu_data *d) +{ +guard (srcu)(&d->srcu); + (void )srcu_dereference (d->data, &d->srcu); +}
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Marco Elver
maintainerPATCH v4 16/35 kref: Add context-analysis annotations
In reply to Marco ElverMark functions that conditionally acquire the passed lock.
--- include/linux/kref.h | 2 ++ 1 file changed, 2 insertions(+)
include/linux/kref.h +2 -0
@@ -81,6 +81,7 @@ static inline int kref_put(struct kref *kref, void (*release)(struct kref *kref)static inline int kref_put_mutex (struct kref *kref,void (*release)(struct kref *kref),struct mutex *mutex) +__cond_acquires (true, mutex) {if (refcount_dec_and_mutex_lock (&kref->refcount, mutex)) {release (kref);
@@ -102,6 +103,7 @@ static inline int kref_put_mutex(struct kref *kref,static inline int kref_put_lock (struct kref *kref,void (*release)(struct kref *kref),spinlock_t *lock) +__cond_acquires (true, lock) {if (refcount_dec_and_lock (&kref->refcount, lock)) {release (kref);
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Peter Zijlstra
maintainerRe: [PATCH v4 16/35] kref: Add context-analysis annotations
Quoted 30 lines · Marco Elver
Mark functions that conditionally acquire the passed lock.
Signed-off-by Marco Elver <[email protected]>--- include/linux/kref.h | 2 ++ 1 file changed, 2 insertions(+)include/linux/kref.h +2
-0@@ -81,6 +81,7 @@ static inline int kref_put(struct kref *kref, void (*release)(struct kref *kref)static inline int kref_put_mutex (struct kref *kref,void (*release)(struct kref *kref),struct mutex *mutex) +__cond_acquires (true, mutex) {if (refcount_dec_and_mutex_lock (&kref->refcount, mutex)) {release (kref);@@ -102,6 +103,7 @@ static inline int kref_put_mutex(struct kref *kref,static inline int kref_put_lock (struct kref *kref,void (*release)(struct kref *kref),spinlock_t *lock) +__cond_acquires (true, lock) {if (refcount_dec_and_lock (&kref->refcount, lock)) {release (kref);Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Note that both use the underlying refcount_dec_and_*lock() functions. Its a bit sad that annotation those isn't sufficient. These are inline functions after all, the compiler should be able to see through all that.
Marco Elver
maintainerRe: [PATCH v4 16/35] kref: Add context-analysis annotations
Quoted 28 lines · Peter Zijlstra
Quoted 26 lines · Marco Elver
Mark functions that conditionally acquire the passed lock.
Signed-off-by Marco Elver <[email protected]>--- include/linux/kref.h | 2 ++ 1 file changed, 2 insertions(+)include/linux/kref.h +2
-0@@ -81,6 +81,7 @@ static inline int kref_put(struct kref *kref, void (*release)(struct kref *kref)static inline int kref_put_mutex (struct kref *kref,void (*release)(struct kref *kref),struct mutex *mutex) +__cond_acquires (true, mutex) {if (refcount_dec_and_mutex_lock (&kref->refcount, mutex)) {release (kref);@@ -102,6 +103,7 @@ static inline int kref_put_mutex(struct kref *kref,static inline int kref_put_lock (struct kref *kref,void (*release)(struct kref *kref),spinlock_t *lock) +__cond_acquires (true, lock) {if (refcount_dec_and_lock (&kref->refcount, lock)) {
Quoted 8 lines
Quoted 4 lines
include/linux/kref.h +0
-1release (kref); --2.52.0.rc1.455.g30608eb744-goog
Note that both use the underlying refcount_dec_and_*lock() functions. Its a bit sad that annotation those isn't sufficient. These are inline functions after all, the compiler should be able to see through all that.
Wrappers will need their own annotations; for this kind of static analysis (built-in warning diagnostic), inferring things like __cond_acquires(true, lock) is far too complex (requires intra-procedural control-flow analysis), and would likely be incomplete too.
It might also be reasonable to argue that the explicit annotation is good for documentation.
Aside: There's other static analysis tooling, like clang-analyzer that can afford to do more complex flow-sensitive intra-procedural analysis. But that has its own limitations, requires separate invocation, and is pretty slow in comparison.
Peter Zijlstra
maintainerRe: [PATCH v4 16/35] kref: Add context-analysis annotations
Quoted 6 lines · Marco Elver
Wrappers will need their own annotations; for this kind of static analysis (built-in warning diagnostic), inferring things like
__cond_acquires(true, lock)is far too complex (requires intra-procedural control-flow analysis), and would likely be incomplete too.
Quoted 7 lines
It might also be reasonable to argue that the explicit annotation is good for documentation.
Aside: There's other static analysis tooling, like clang-analyzer that can afford to do more complex flow-sensitive intra-procedural analysis. But that has its own limitations, requires separate invocation, and is pretty slow in comparison.
I was sorta hoping that (perhaps only for __always_inline) the thing would indeed do an early inline pass on the AST such that these cases would not in fact require inter-procedural analysis.
Marco Elver
maintainerPATCH v4 17/35 locking/rwsem: Support Clang's context analysis
In reply to Marco ElverAdd support for Clang's context analysis for rw_semaphore.
---
v4:
* Rename capability -> context analysis.
v3:
* Switch to DECLARE_LOCK_GUARD_1_ATTRS() (suggested by Peter)
* __assert -> __assume rename
--- Documentation/dev-tools/context-analysis.rst | 2 +- include/linux/rwsem.h | 66 ++++++++++++-------- lib/test_context-analysis.c | 64 +++++++++++++++++++ 3 files changed, 106 insertions(+), 26 deletions(-)
Documentation/dev-tools/context-analysis.rst +1 -1
@@ -81,7 +81,7 @@ Supported Kernel Primitives Currently the following synchronization primitives are supported: `raw_spinlock_t`, `spinlock_t`, `rwlock_t`, `mutex`, `seqlock_t`, -`bit_spinlock`, RCU, SRCU (`srcu_struct`). +`bit_spinlock`, RCU, SRCU (`srcu_struct`), `rw_semaphore`. For context guards with an initialization function (e.g., `spin_lock_init()`), calling this function before initializing any guarded members or globals
include/linux/rwsem.h +41 -25
168 lines not on this page · raw message
lib/test_context-analysis.c +64 -0
76 lines not on this page · raw message
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Marco Elver
maintainerPATCH v4 18/35 locking/local_lock: Include missing headers
In reply to Marco ElverIncluding <linux/local_lock.h> into an empty TU will result in the compiler complaining:
./include/linux/local_lock.h: In function ‘class_local_lock_irqsave_constructor’:./include/linux/local_lock_internal.h:95:17: error: implicit declaration of function ‘local_irq_save’; <...>
95 | local_irq_save(flags); \
| ^~~~~~~~~~~~~~As well as (some architectures only, such as 'sh'):
./include/linux/local_lock_internal.h: In function ‘local_lock_acquire’:./include/linux/local_lock_internal.h:33:20: error: ‘current’ undeclared (first use in this function)
33 | l->owner = current;
Include missing headers to allow including local_lock.h where the required headers are not otherwise included.
--- include/linux/local_lock_internal.h | 2 ++ 1 file changed, 2 insertions(+)
include/linux/local_lock_internal.h +2 -0
@@ -4,7 +4,9 @@#endif #include <linux/percpu-defs.h> +#include <linux/irqflags.h> #include <linux/lockdep.h> +#include <asm/current.h> #ifndef CONFIG_PREEMPT_RT
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Marco Elver
maintainerPATCH v4 19/35 locking/local_lock: Support Clang's context analysis
In reply to Marco ElverAdd support for Clang's context analysis for local_lock_t and local_trylock_t.
---
v4:
* Rename capability -> context analysis.
v3:
* Switch to DECLARE_LOCK_GUARD_1_ATTRS() (suggested by Peter)
* __assert -> __assume rename
* Rework __this_cpu_local_lock helper
* Support local_trylock_t
--- Documentation/dev-tools/context-analysis.rst | 2 +- include/linux/local_lock.h | 45 ++++++------ include/linux/local_lock_internal.h | 71 +++++++++++++++---- lib/test_context-analysis.c | 73 ++++++++++++++++++++ 4 files changed, 156 insertions(+), 35 deletions(-)
Documentation/dev-tools/context-analysis.rst +1 -1
@@ -81,7 +81,7 @@ Supported Kernel Primitives Currently the following synchronization primitives are supported: `raw_spinlock_t`, `spinlock_t`, `rwlock_t`, `mutex`, `seqlock_t`, -`bit_spinlock`, RCU, SRCU (`srcu_struct`), `rw_semaphore`. +`bit_spinlock`, RCU, SRCU (`srcu_struct`), `rw_semaphore`, `local_lock_t`. For context guards with an initialization function (e.g., `spin_lock_init()`), calling this function before initializing any guarded members or globals
include/linux/local_lock.h +25 -20
98 lines not on this page · raw message
include/linux/local_lock_internal.h +57 -14
187 lines not on this page · raw message
lib/test_context-analysis.c +73 -0
83 lines not on this page · raw message
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Marco Elver
maintainerPATCH v4 20/35 locking/ww_mutex: Support Clang's context analysis
In reply to Marco ElverAdd support for Clang's context analysis for ww_mutex.
The programming model for ww_mutex is subtly more complex than other locking primitives when using ww_acquire_ctx. Encoding the respective pre-conditions for ww_mutex lock/unlock based on ww_acquire_ctx state using Clang's context analysis makes incorrect use of the API harder.
---
v4:
* Rename capability -> context analysis.
v3:
* __assert -> __assume rename
v2:
* New patch.
--- Documentation/dev-tools/context-analysis.rst | 3 +- include/linux/ww_mutex.h | 22 +++++-- lib/test_context-analysis.c | 69 ++++++++++++++++++++ 3 files changed, 87 insertions(+), 7 deletions(-)
Documentation/dev-tools/context-analysis.rst +2 -1
@@ -81,7 +81,8 @@ Supported Kernel Primitives Currently the following synchronization primitives are supported: `raw_spinlock_t`, `spinlock_t`, `rwlock_t`, `mutex`, `seqlock_t`, -`bit_spinlock`, RCU, SRCU (`srcu_struct`), `rw_semaphore`, `local_lock_t`. +`bit_spinlock`, RCU, SRCU (`srcu_struct`), `rw_semaphore`, `local_lock_t`, +`ww_mutex`. For context guards with an initialization function (e.g., `spin_lock_init()`), calling this function before initializing any guarded members or globals
include/linux/ww_mutex.h +16 -6
@@ -44,7 +44,7 @@ struct ww_class {unsigned int is_wait_die; }; -struct ww_mutex { +context_guard_struct (ww_mutex) {struct WW_MUTEX_BASE base;struct ww_acquire_ctx *ctx;#ifdef DEBUG_WW_MUTEXES
@@ -52,7 +52,7 @@ struct ww_mutex {#endif }; -struct ww_acquire_ctx { +context_guard_struct (ww_acquire_ctx) {struct task_struct *task;unsigned long stamp;unsigned int acquired;
@@ -107,6 +107,7 @@ struct ww_acquire_ctx {*/ static inline void ww_mutex_init (struct ww_mutex *lock,struct ww_class *ww_class) +__assumes_ctx_guard (lock) {ww_mutex_base_init (&lock->base, ww_class->mutex_name, &ww_class->mutex_key); lock->ctx =NULL ;
@@ -141,6 +142,7 @@ static inline void ww_mutex_init(struct ww_mutex *lock,*/ static inline void ww_acquire_init (struct ww_acquire_ctx *ctx,struct ww_class *ww_class) +__acquires (ctx) __no_context_analysis { ctx->task = current; ctx->stamp =atomic_long_inc_return_relaxed (&ww_class->stamp);
@@ -179,6 +181,7 @@ static inline void ww_acquire_init(struct ww_acquire_ctx *ctx,* data structures. */ static inline void ww_acquire_done (struct ww_acquire_ctx *ctx) +__releases (ctx)__acquires_shared (ctx) __no_context_analysis {#ifdef DEBUG_WW_MUTEXES lockdep_assert_held (ctx);
@@ -196,6 +199,7 @@ static inline void ww_acquire_done(struct ww_acquire_ctx *ctx)* mutexes have been released with ww_mutex_unlock. */ static inline void ww_acquire_fini (struct ww_acquire_ctx *ctx) +__releases_shared (ctx) __no_context_analysis {#ifdef CONFIG_DEBUG_LOCK_ALLOC mutex_release (&ctx->first_lock_dep_map, _THIS_IP_);
@@ -245,7 +249,8 @@ static inline void ww_acquire_fini(struct ww_acquire_ctx *ctx)* * A mutex acquired with this function must be released with ww_mutex_unlock. */ -extern int /* __must_check */ ww_mutex_lock (struct ww_mutex *lock,struct ww_acquire_ctx *ctx); +extern int /* __must_check */ ww_mutex_lock(struct ww_mutex *lock, struct ww_acquire_ctx *ctx) + __cond_acquires(0, lock) __must_hold(ctx);/** * ww_mutex_lock_interruptible - acquire the w/w mutex, interruptible
@@ -278,7 +283,8 @@ extern int /* __must_check */ ww_mutex_lock(struct ww_mutex *lock, struct ww_acq* A mutex acquired with this function must be released with ww_mutex_unlock. */ extern int __must_check ww_mutex_lock_interruptible(struct ww_mutex *lock, -struct ww_acquire_ctx *ctx); + struct ww_acquire_ctx *ctx) + __cond_acquires(0, lock) __must_hold(ctx);/** * ww_mutex_lock_slow - slowpath acquiring of the w/w mutex
@@ -305,6 +311,7 @@ extern int __must_check ww_mutex_lock_interruptible(struct ww_mutex *lock,*/ static inline void ww_mutex_lock_slow (struct ww_mutex *lock,struct ww_acquire_ctx *ctx) +__acquires (lock)__must_hold (ctx) __no_context_analysis {int ret;#ifdef DEBUG_WW_MUTEXES
@@ -342,6 +349,7 @@ ww_mutex_lock_slow(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)static inline int __must_check ww_mutex_lock_slow_interruptible (struct ww_mutex *lock,struct ww_acquire_ctx *ctx) +__cond_acquires (0 , lock)__must_hold (ctx) {#ifdef DEBUG_WW_MUTEXES DEBUG_LOCKS_WARN_ON (!ctx->contending_lock);
@@ -349,10 +357,11 @@ ww_mutex_lock_slow_interruptible(struct ww_mutex *lock,return ww_mutex_lock_interruptible (lock, ctx); } -extern void ww_mutex_unlock (struct ww_mutex *lock); +extern void ww_mutex_unlock(struct ww_mutex *lock) __releases(lock); extern int __must_check ww_mutex_trylock(struct ww_mutex *lock, -struct ww_acquire_ctx *ctx); + struct ww_acquire_ctx *ctx) + __cond_acquires(true, lock) __must_hold(ctx);/*** * ww_mutex_destroy - mark a w/w mutex unusable
@@ -363,6 +372,7 @@ extern int __must_check ww_mutex_trylock(struct ww_mutex *lock,* this function is called. */ static inline void ww_mutex_destroy (struct ww_mutex *lock) +__must_not_hold (lock) {#ifndef CONFIG_PREEMPT_RT mutex_destroy (&lock->base);
lib/test_context-analysis.c +69 -0
78 lines not on this page · raw message
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Marco Elver
maintainerPATCH v4 21/35 debugfs: Make debugfs_cancellation a context guard struct
In reply to Marco ElverWhen compiling include/linux/debugfs.h with CONTEXT_ANALYSIS enabled, we can see this error:
./include/linux/debugfs.h:239:17: error: use of undeclared identifier 'cancellation'
239 | void __acquires(cancellation)
Move the __acquires(..) attribute after the declaration, so that the compiler can see the cancellation function argument, as well as making struct debugfs_cancellation a real context guard to benefit from Clang's context analysis.
---
v4:
* Rename capability -> context analysis.
--- include/linux/debugfs.h | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-)
include/linux/debugfs.h +5 -7
@@ -239,18 +239,16 @@ ssize_t debugfs_read_file_str(struct file *file, char __user *user_buf,* @cancel: callback to call * @cancel_data: extra data for the callback to call */ -struct debugfs_cancellation { +context_guard_struct (debugfs_cancellation) {struct list_head list;void (*cancel)(struct dentry *,void *);void *cancel_data; }; -void __acquires(cancellation) -debugfs_enter_cancellation(struct file *file, - struct debugfs_cancellation *cancellation); -void __releases(cancellation) -debugfs_leave_cancellation(struct file *file, - struct debugfs_cancellation *cancellation); +void debugfs_enter_cancellation(struct file *file, + struct debugfs_cancellation *cancellation) __acquires(cancellation); +void debugfs_leave_cancellation(struct file *file, + struct debugfs_cancellation *cancellation) __releases(cancellation);#else
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Marco Elver
maintainerPATCH v4 22/35 compiler-context-analysis: Remove Sparse support
In reply to Marco ElverRemove Sparse support as discussed at [1].
The kernel codebase is still scattered with numerous places that try to appease Sparse's context tracking ("annotation for sparse", "fake out sparse", "work around sparse", etc.). Eventually, as more subsystems enable Clang's context analysis, these places will show up and need adjustment or removal of the workarounds altogether.
---
v4:
* Rename capability -> context analysis.
v2:
* New patch.
--- Documentation/dev-tools/sparse.rst | 19 ----- include/linux/compiler-context-analysis.h | 85 +++++++---------------- include/linux/rcupdate.h | 15 +--- 3 files changed, 28 insertions(+), 91 deletions(-)
Documentation/dev-tools/sparse.rst +0 -19
@@ -53,25 +53,6 @@ sure that bitwise types don't get mixed up (little-endian vs big-endian vs cpu-endian vs whatever), and there the constant "0" really _is_ special. -Using sparse for lock checking ------------------------------- - -The following macros are undefined for gcc and defined during a sparse -run to use the "context" tracking feature of sparse, applied to -locking. These annotations tell sparse when a lock is held, with -regard to the annotated function's entry and exit. - -__must_hold - The specified lock is held on function entry and exit. - -__acquires - The specified lock is held on function exit, but not entry. - -__releases - The specified lock is held on function entry, but not exit. - -If the function enters and exits without the lock held, acquiring and -releasing the lock inside the function in a balanced way, no -annotation is needed. The three annotations above are for cases where -sparse would otherwise report a context imbalance. - Getting sparse --------------
include/linux/compiler-context-analysis.h +27 -58
186 lines not on this page · raw message
include/linux/rcupdate.h +1 -14
@@ -1219,20 +1219,7 @@ rcu_head_after_call_rcu(struct rcu_head *rhp, rcu_callback_t f)extern int rcu_expedited;extern int rcu_normal; -DEFINE_LOCK_GUARD_0(rcu, - do { - rcu_read_lock(); - /* - * sparse doesn't call the cleanup function, - * so just release immediately and don't track - * the context. We don't need to anyway, since - * the whole point of the guard is to not need - * the explicit unlock. - */ - __release(RCU); - } while (0), - rcu_read_unlock()) - +DEFINE_LOCK_GUARD_0(rcu, rcu_read_lock(), rcu_read_unlock()) DECLARE_LOCK_GUARD_0_ATTRS(rcu, __acquires_shared(RCU), __releases_shared(RCU))#endif /* __LINUX_RCUPDATE_H */
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Marco Elver
maintainerPATCH v4 23/35 compiler-context-analysis: Remove __cond_lock() function-like helper
In reply to Marco ElverAs discussed in [1], removing __cond_lock() will improve the readability of trylock code. Now that Sparse context tracking support has been removed, we can also remove __cond_lock().
Change existing APIs to either drop __cond_lock() completely, or make use of the __cond_acquires() function attribute instead.
In particular, spinlock and rwlock implementations required switching over to inline helpers rather than statement-expressions for their trylock_* variants.
---
v2:
* New patch.
--- Documentation/dev-tools/context-analysis.rst | 2 - Documentation/mm/process_addrs.rst | 6 +- .../net/wireless/intel/iwlwifi/iwl-trans.c | 4 +- .../net/wireless/intel/iwlwifi/iwl-trans.h | 6 +- .../intel/iwlwifi/pcie/gen1_2/internal.h | 5 +- .../intel/iwlwifi/pcie/gen1_2/trans.c | 4 +- include/linux/compiler-context-analysis.h | 31 ---------- include/linux/mm.h | 33 ++-------- include/linux/rwlock.h | 11 +--- include/linux/rwlock_api_smp.h | 14 ++++- include/linux/rwlock_rt.h | 21 ++++--- include/linux/sched/signal.h | 14 +---- include/linux/spinlock.h | 45 +++++--------- include/linux/spinlock_api_smp.h | 20 ++++++ include/linux/spinlock_api_up.h | 61 ++++++++++++++++--- include/linux/spinlock_rt.h | 26 ++++---- kernel/signal.c | 4 +- kernel/time/posix-timers.c | 13 +--- lib/dec_and_lock.c | 8 +-- mm/memory.c | 4 +- mm/pgtable-generic.c | 19 +++--- tools/include/linux/compiler_types.h | 2 - 22 files changed, 162 insertions(+), 191 deletions(-)
Documentation/dev-tools/context-analysis.rst +0 -2
@@ -113,10 +113,8 @@ Keywords __releases_shared __acquire __release - __cond_lock __acquire_shared __release_shared - __cond_lock_shared __acquire_ret __acquire_shared_ret context_unsafe
Documentation/mm/process_addrs.rst +3 -3
@@ -582,7 +582,7 @@ To access PTE-level page tables, a helper like :c:func:`!pte_offset_map_lock` or :c:func:`!pte_offset_map` can be used depending on stability requirements. These map the page table into kernel memory if required, take the RCU lock, and depending on variant, may also look up or acquire the PTE lock. -See the comment on :c:func:`!__pte_offset_map_lock`. +See the comment on :c:func:`!pte_offset_map_lock`. Atomicity ^^^^^^^^^
@@ -666,7 +666,7 @@ must be released via :c:func:`!pte_unmap_unlock`. .. note:: There are some variants on this, such as :c:func:`!pte_offset_map_rw_nolock` when we know we hold the PTE stable but for brevity we do not explore this. See the comment for - :c:func:`!__pte_offset_map_lock` for more details. + :c:func:`!pte_offset_map_lock` for more details. When modifying data in ranges we typically only wish to allocate higher page tables as necessary, using these locks to avoid races or overwriting anything,
@@ -685,7 +685,7 @@ At the leaf page table, that is the PTE, we can't entirely rely on this pattern as we have separate PMD and PTE locks and a THP collapse for instance might have eliminated the PMD entry as well as the PTE from under us. -This is why :c:func:`!__pte_offset_map_lock` locklessly retrieves the PMD entry +This is why :c:func:`!pte_offset_map_lock` locklessly retrieves the PMD entry for the PTE, carefully checking it is as expected, before acquiring the PTE-specific lock, and then *again* checking that the PMD entry is as expected.
drivers/net/wireless/intel/iwlwifi/iwl-trans.c +2 -2
@@ -548,11 +548,11 @@ int iwl_trans_read_config32(struct iwl_trans *trans, u32 ofs,return iwl_trans_pcie_read_config32 (trans, ofs, val); } -bool _iwl_trans_grab_nic_access (struct iwl_trans *trans) +bool iwl_trans_grab_nic_access (struct iwl_trans *trans) {return iwl_trans_pcie_grab_nic_access (trans); } -IWL_EXPORT_SYMBOL (_iwl_trans_grab_nic_access); +IWL_EXPORT_SYMBOL (iwl_trans_grab_nic_access); void __releases(nic_access) iwl_trans_release_nic_access(struct iwl_trans *trans)
drivers/net/wireless/intel/iwlwifi/iwl-trans.h +1 -5
@@ -1063,11 +1063,7 @@ int iwl_trans_sw_reset(struct iwl_trans *trans);void iwl_trans_set_bits_mask (struct iwl_trans *trans,u32 reg,u32 mask,u32 value); -bool _iwl_trans_grab_nic_access (struct iwl_trans *trans); - -#define iwl_trans_grab_nic_access (trans) \ - __cond_lock(nic_access, \ - likely(_iwl_trans_grab_nic_access(trans))) +bool iwl_trans_grab_nic_access (struct iwl_trans *trans); void __releases(nic_access) iwl_trans_release_nic_access(struct iwl_trans *trans);
drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/internal.h +1 -4
@@ -553,10 +553,7 @@ void iwl_trans_pcie_free(struct iwl_trans *trans);void iwl_trans_pcie_free_pnvm_dram_regions (struct iwl_dram_regions *dram_regions,struct device *dev); -bool __iwl_trans_pcie_grab_nic_access (struct iwl_trans *trans,bool silent); -#define _iwl_trans_pcie_grab_nic_access (trans, silent) \ - __cond_lock(nic_access_nobh, \ - likely(__iwl_trans_pcie_grab_nic_access(trans, silent))) +bool _iwl_trans_pcie_grab_nic_access (struct iwl_trans *trans,bool silent);void iwl_trans_pcie_check_product_reset_status (struct pci_dev *pdev);void iwl_trans_pcie_check_product_reset_mode (struct pci_dev *pdev);
drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/trans.c +2 -2
@@ -2327,7 +2327,7 @@ EXPORT_SYMBOL(iwl_trans_pcie_reset);* This version doesn't disable BHs but rather assumes they're * already disabled. */ -bool __iwl_trans_pcie_grab_nic_access (struct iwl_trans *trans,bool silent) +bool _iwl_trans_pcie_grab_nic_access (struct iwl_trans *trans,bool silent) {int ret;struct iwl_trans_pcie *trans_pcie =IWL_TRANS_GET_PCIE_TRANS (trans);
@@ -2415,7 +2415,7 @@ bool iwl_trans_pcie_grab_nic_access(struct iwl_trans *trans)bool ret;local_bh_disable (); - ret =__iwl_trans_pcie_grab_nic_access (trans, false); + ret =_iwl_trans_pcie_grab_nic_access (trans, false);if (ret) {/* keep BHs disabled until iwl_trans_pcie_release_nic_access */ return ret;
include/linux/compiler-context-analysis.h +0 -31
@@ -329,24 +329,6 @@ static inline void _context_unsafe_alias(void **p) { }*/ #define __release (x) __release_ctx_guard(x) -/** -* __cond_lock() - function that conditionally acquires a context guard -* exclusively -* @x: context guard instance pinter -* @c: boolean expression -* -* Return: result of @c -* -* No-op function that conditionally acquires context guard instance @x -* exclusively, if the boolean expression @c is true. The result of @c is the -* return value; for example: -* -* .. code-block:: c -* -* #define spin_trylock(l) __cond_lock(&lock, _spin_trylock(&lock)) -*/ -#define __cond_lock (x, c) __try_acquire_ctx_guard(x, c) -/** * __must_hold_shared() - function attribute, caller must hold shared context guard *
@@ -405,19 +387,6 @@ static inline void _context_unsafe_alias(void **p) { }*/ #define __release_shared (x) __release_shared_ctx_guard(x) -/** -* __cond_lock_shared() - function that conditionally acquires a context guard shared -* @x: context guard instance pinter -* @c: boolean expression -* -* Return: result of @c -* -* No-op function that conditionally acquires context guard instance @x with -* shared access, if the boolean expression @c is true. The result of @c is the -* return value. -*/ -#define __cond_lock_shared (x, c) __try_acquire_shared_ctx_guard(x, c) -/** * __acquire_ret() - helper to acquire context guard of return value * @call: call expression
include/linux/mm.h +5 -28
@@ -2813,15 +2813,8 @@ static inline pud_t pud_mkspecial(pud_t pud) }#endif /* CONFIG_ARCH_SUPPORTS_PUD_PFNMAP */ -extern pte_t *__get_locked_pte (struct mm_struct *mm,unsigned long addr, -spinlock_t **ptl); -static inline pte_t *get_locked_pte (struct mm_struct *mm,unsigned long addr, -spinlock_t **ptl) -{ -pte_t *ptep; -__cond_lock (*ptl, ptep =__get_locked_pte (mm, addr, ptl)); -return ptep; -} +extern pte_t *get_locked_pte (struct mm_struct *mm,unsigned long addr, +spinlock_t **ptl);#ifdef __PAGETABLE_P4D_FOLDED static inline int __p4d_alloc(struct mm_struct *mm, pgd_t *pgd,
@@ -3116,31 +3109,15 @@ static inline bool pagetable_pte_ctor(struct mm_struct *mm,return true; } -pte_t *___pte_offset_map (pmd_t *pmd,unsigned long addr,pmd_t *pmdvalp); -static inline pte_t *__pte_offset_map (pmd_t *pmd,unsigned long addr, -pmd_t *pmdvalp) -{ -pte_t *pte; +pte_t *__pte_offset_map (pmd_t *pmd,unsigned long addr,pmd_t *pmdvalp); -__cond_lock (RCU , pte =___pte_offset_map (pmd, addr, pmdvalp)); -return pte; -}static inline pte_t *pte_offset_map (pmd_t *pmd,unsigned long addr) {return __pte_offset_map (pmd, addr,NULL ); } -pte_t *__pte_offset_map_lock (struct mm_struct *mm,pmd_t *pmd, -unsigned long addr,spinlock_t **ptlp); -static inline pte_t *pte_offset_map_lock (struct mm_struct *mm,pmd_t *pmd, -unsigned long addr,spinlock_t **ptlp) -{ -pte_t *pte; - -__cond_lock (RCU ,__cond_lock (*ptlp, - pte =__pte_offset_map_lock (mm, pmd, addr, ptlp))); -return pte; -} +pte_t *pte_offset_map_lock (struct mm_struct *mm,pmd_t *pmd, +unsigned long addr,spinlock_t **ptlp);pte_t *pte_offset_map_ro_nolock (struct mm_struct *mm,pmd_t *pmd,unsigned long addr,spinlock_t **ptlp);
include/linux/rwlock.h +3 -8
@@ -50,8 +50,8 @@ do { \* regardless of whether CONFIG_SMP or CONFIG_PREEMPT are set. The various * methods are defined as nops in the case they are not required. */ -#define read_trylock (lock) __cond_lock_shared(lock, _raw_read_trylock(lock)) -#define write_trylock (lock) __cond_lock(lock, _raw_write_trylock(lock)) +#define read_trylock (lock) _raw_read_trylock(lock) +#define write_trylock (lock) _raw_write_trylock(lock)#define write_lock (lock) _raw_write_lock(lock)#define read_lock (lock) _raw_read_lock(lock)
@@ -113,12 +113,7 @@ do { \ } while (0)#define write_unlock_bh (lock) _raw_write_unlock_bh(lock) -#define write_trylock_irqsave (lock, flags) \ - __cond_lock(lock, ({ \ - local_irq_save(flags); \ - _raw_write_trylock(lock) ? \ - 1 : ({ local_irq_restore(flags); 0; }); \ - })) +#define write_trylock_irqsave (lock, flags) _raw_write_trylock_irqsave(lock, &(flags))#ifdef arch_rwlock_is_contended#define rwlock_is_contended (lock) \
include/linux/rwlock_api_smp.h +12 -2
@@ -26,8 +26,8 @@ unsigned long __lockfunc _raw_read_lock_irqsave(rwlock_t *lock)__acquires (lock); unsigned long __lockfunc _raw_write_lock_irqsave(rwlock_t *lock) __acquires(lock); -int __lockfunc _raw_read_trylock(rwlock_t *lock); -int __lockfunc _raw_write_trylock(rwlock_t *lock); +int __lockfunc _raw_read_trylock(rwlock_t *lock) __cond_acquires_shared(true, lock); +int __lockfunc _raw_write_trylock(rwlock_t *lock) __cond_acquires(true, lock); void __lockfunc _raw_read_unlock(rwlock_t *lock) __releases_shared(lock); void __lockfunc _raw_write_unlock(rwlock_t *lock) __releases(lock); void __lockfunc _raw_read_unlock_bh(rwlock_t *lock) __releases_shared(lock);
@@ -41,6 +41,16 @@ void __lockfunc _raw_write_unlock_irqrestore(rwlock_t *lock, unsigned long flags)__releases (lock); +static inline bool _raw_write_trylock_irqsave (rwlock_t *lock,unsigned long *flags) +__cond_acquires (true, lock) +{ +local_irq_save (*flags); +if (_raw_write_trylock (lock)) +return true; +local_irq_restore (*flags); +return false; +} +#ifdef CONFIG_INLINE_READ_LOCK #define _raw_read_lock (lock) __raw_read_lock(lock)#endif
include/linux/rwlock_rt.h +11 -10
@@ -26,11 +26,11 @@ do { \ }while (0 ) extern void rt_read_lock(rwlock_t *rwlock) __acquires_shared(rwlock); -extern int rt_read_trylock (rwlock_t *rwlock); +extern int rt_read_trylock(rwlock_t *rwlock) __cond_acquires_shared(true, rwlock); extern void rt_read_unlock(rwlock_t *rwlock) __releases_shared(rwlock); extern void rt_write_lock(rwlock_t *rwlock) __acquires(rwlock); extern void rt_write_lock_nested(rwlock_t *rwlock, int subclass) __acquires(rwlock); -extern int rt_write_trylock (rwlock_t *rwlock); +extern int rt_write_trylock(rwlock_t *rwlock) __cond_acquires(true, rwlock); extern void rt_write_unlock(rwlock_t *rwlock) __releases(rwlock); static __always_inline void read_lock(rwlock_t *rwlock)
@@ -59,7 +59,7 @@ static __always_inline void read_lock_irq(rwlock_t *rwlock) flags =0 ; \ } while (0) -#define read_trylock (lock) __cond_lock_shared(lock, rt_read_trylock(lock)) +#define read_trylock (lock) rt_read_trylock(lock) static __always_inline void read_unlock(rwlock_t *rwlock) __releases_shared(rwlock)
@@ -123,14 +123,15 @@ static __always_inline void write_lock_irq(rwlock_t *rwlock) flags =0 ; \ } while (0) -#define write_trylock (lock) __cond_lock(lock, rt_write_trylock(lock)) +#define write_trylock (lock) rt_write_trylock(lock) -#define write_trylock_irqsave (lock, flags) \ - __cond_lock(lock, ({ \ - typecheck(unsigned long, flags); \ - flags = 0; \ - rt_write_trylock(lock); \ - })) +static __always_inline bool _write_trylock_irqsave(rwlock_t *rwlock, unsigned long *flags) +__cond_acquires (true, rwlock) +{ + *flags =0 ; +return rt_write_trylock (rwlock); +} +#define write_trylock_irqsave (lock, flags) _write_trylock_irqsave(lock, &(flags)) static __always_inline void write_unlock(rwlock_t *rwlock) __releases(rwlock)
include/linux/sched/signal.h +2 -12
@@ -737,18 +737,8 @@ static inline int thread_group_empty(struct task_struct *p)#define delay_group_leader (p) \ (thread_group_leader(p) && !thread_group_empty(p)) -extern struct sighand_struct *__lock_task_sighand (struct task_struct *task, -unsigned long *flags); - -static inline struct sighand_struct *lock_task_sighand (struct task_struct *task, -unsigned long *flags) -{ -struct sighand_struct *ret; - - ret =__lock_task_sighand (task, flags); - (void )__cond_lock (&task->sighand->siglock, ret); -return ret; -} +extern struct sighand_struct *lock_task_sighand (struct task_struct *task, +unsigned long *flags);static inline void unlock_task_sighand (struct task_struct *task,unsigned long *flags)
include/linux/spinlock.h +16 -29
76 lines not on this page · raw message
include/linux/spinlock_api_smp.h +20 -0
@@ -95,6 +95,26 @@ static inline int __raw_spin_trylock(raw_spinlock_t *lock)return 0 ; } +static __always_inline bool _raw_spin_trylock_irq(raw_spinlock_t *lock) +__cond_acquires (true, lock) +{ +local_irq_disable (); +if (_raw_spin_trylock (lock)) +return true; +local_irq_enable (); +return false; +} + +static __always_inline bool _raw_spin_trylock_irqsave(raw_spinlock_t *lock, unsigned long *flags) +__cond_acquires (true, lock) +{ +local_irq_save (*flags); +if (_raw_spin_trylock (lock)) +return true; +local_irq_restore (*flags); +return false; +} +/* * If lockdep is enabled then we use the non-preemption spin-ops * even on CONFIG_PREEMPTION, because lockdep assumes that interrupts are
include/linux/spinlock_api_up.h +52 -9
76 lines not on this page · raw message
include/linux/spinlock_rt.h +12 -14
@@ -37,8 +37,8 @@ extern void rt_spin_lock_nested(spinlock_t *lock, int subclass) __acquires(lock) extern void rt_spin_lock_nest_lock(spinlock_t *lock, struct lockdep_map *nest_lock) __acquires(lock); extern void rt_spin_unlock(spinlock_t *lock) __releases(lock);extern void rt_spin_lock_unlock (spinlock_t *lock); -extern int rt_spin_trylock_bh (spinlock_t *lock); -extern int rt_spin_trylock (spinlock_t *lock); +extern int rt_spin_trylock_bh(spinlock_t *lock) __cond_acquires(true, lock); +extern int rt_spin_trylock(spinlock_t *lock) __cond_acquires(true, lock); static __always_inline void spin_lock(spinlock_t *lock) __acquires(lock)
@@ -130,21 +130,19 @@ static __always_inline void spin_unlock_irqrestore(spinlock_t *lock,rt_spin_unlock (lock); } -#define spin_trylock (lock) \ - __cond_lock(lock, rt_spin_trylock(lock)) +#define spin_trylock (lock) rt_spin_trylock(lock) -#define spin_trylock_bh (lock) \ - __cond_lock(lock, rt_spin_trylock_bh(lock)) +#define spin_trylock_bh (lock) rt_spin_trylock_bh(lock) -#define spin_trylock_irq (lock) \ - __cond_lock(lock, rt_spin_trylock(lock)) +#define spin_trylock_irq (lock) rt_spin_trylock(lock) -#define spin_trylock_irqsave (lock, flags) \ - __cond_lock(lock, ({ \ - typecheck(unsigned long, flags); \ - flags = 0; \ - rt_spin_trylock(lock); \ - })) +static __always_inline bool _spin_trylock_irqsave(spinlock_t *lock, unsigned long *flags) +__cond_acquires (true, lock) +{ + *flags =0 ; +return rt_spin_trylock (lock); +} +#define spin_trylock_irqsave (lock, flags) _spin_trylock_irqsave(lock, &(flags))#define spin_is_contended (lock) (((void)(lock), 0))
kernel/signal.c +2 -2
@@ -1355,8 +1355,8 @@ int zap_other_threads(struct task_struct *p)return count; } -struct sighand_struct *__lock_task_sighand (struct task_struct *tsk, -unsigned long *flags) +struct sighand_struct *lock_task_sighand (struct task_struct *tsk, +unsigned long *flags) {struct sighand_struct *sighand;
kernel/time/posix-timers.c +3 -10
@@ -66,14 +66,7 @@ static const struct k_clock clock_realtime, clock_monotonic;#error "SIGEV_THREAD_ID must not share bit with other SIGEV values!"#endif -static struct k_itimer *__lock_timer (timer_t timer_id); - -#define lock_timer (tid) \ -({ struct k_itimer *__timr; \ - __cond_lock(&__timr->it_lock, __timr = __lock_timer(tid)); \ - __timr; \ -}) - +static struct k_itimer *lock_timer (timer_t timer_id);static inline void unlock_timer (struct k_itimer *timr) {if (likely ((timr)))
@@ -85,7 +78,7 @@ static inline void unlock_timer(struct k_itimer *timr)#define scoped_timer (scope) -DEFINE_CLASS(lock_timer, struct k_itimer *, unlock_timer(_T), __lock_timer(id), timer_t id); +DEFINE_CLASS(lock_timer, struct k_itimer *, unlock_timer(_T), lock_timer(id), timer_t id);DEFINE_CLASS_IS_COND_GUARD (lock_timer);static struct timer_hash_bucket *hash_bucket (struct signal_struct *sig,unsigned int nr)
@@ -600,7 +593,7 @@ COMPAT_SYSCALL_DEFINE3(timer_create, clockid_t, which_clock, }#endif -static struct k_itimer *__lock_timer (timer_t timer_id) +static struct k_itimer *lock_timer (timer_t timer_id) {struct k_itimer *timr;
lib/dec_and_lock.c +4 -4
@@ -18,7 +18,7 @@* because the spin-lock and the decrement must be * "atomic". */ -int _atomic_dec_and_lock (atomic_t *atomic,spinlock_t *lock) +int atomic_dec_and_lock (atomic_t *atomic,spinlock_t *lock) {/* Subtract 1 from counter unless that drops it to 0 (ie. it was 1) */ if (atomic_add_unless (atomic,-1 ,1 ))
@@ -32,7 +32,7 @@ int _atomic_dec_and_lock(atomic_t *atomic, spinlock_t *lock)return 0 ; } -EXPORT_SYMBOL (_atomic_dec_and_lock); +EXPORT_SYMBOL (atomic_dec_and_lock);int _atomic_dec_and_lock_irqsave (atomic_t *atomic,spinlock_t *lock,unsigned long *flags)
@@ -50,7 +50,7 @@ int _atomic_dec_and_lock_irqsave(atomic_t *atomic, spinlock_t *lock, }EXPORT_SYMBOL (_atomic_dec_and_lock_irqsave); -int _atomic_dec_and_raw_lock (atomic_t *atomic,raw_spinlock_t *lock) +int atomic_dec_and_raw_lock (atomic_t *atomic,raw_spinlock_t *lock) {/* Subtract 1 from counter unless that drops it to 0 (ie. it was 1) */ if (atomic_add_unless (atomic,-1 ,1 ))
@@ -63,7 +63,7 @@ int _atomic_dec_and_raw_lock(atomic_t *atomic, raw_spinlock_t *lock)raw_spin_unlock (lock);return 0 ; } -EXPORT_SYMBOL (_atomic_dec_and_raw_lock); +EXPORT_SYMBOL (atomic_dec_and_raw_lock);int _atomic_dec_and_raw_lock_irqsave (atomic_t *atomic,raw_spinlock_t *lock,unsigned long *flags)
mm/memory.c +2 -2
@@ -2215,8 +2215,8 @@ static pmd_t *walk_to_pmd(struct mm_struct *mm, unsigned long addr)return pmd; } -pte_t *__get_locked_pte (struct mm_struct *mm,unsigned long addr, -spinlock_t **ptl) +pte_t *get_locked_pte (struct mm_struct *mm,unsigned long addr, +spinlock_t **ptl) {pmd_t *pmd =walk_to_pmd (mm, addr);
mm/pgtable-generic.c +9 -10
@@ -278,7 +278,7 @@ static unsigned long pmdp_get_lockless_start(void) { return 0; }static void pmdp_get_lockless_end (unsigned long irqflags) { }#endif -pte_t *___pte_offset_map (pmd_t *pmd,unsigned long addr,pmd_t *pmdvalp) +pte_t *__pte_offset_map (pmd_t *pmd,unsigned long addr,pmd_t *pmdvalp) {unsigned long irqflags;pmd_t pmdval;
@@ -330,13 +330,12 @@ pte_t *pte_offset_map_rw_nolock(struct mm_struct *mm, pmd_t *pmd, }/* -* pte_offset_map_lock(mm, pmd, addr, ptlp), and its internal implementation -* __pte_offset_map_lock() below, is usually called with the pmd pointer for -* addr, reached by walking down the mm's pgd, p4d, pud for addr: either while -* holding mmap_lock or vma lock for read or for write; or in truncate or rmap -* context, while holding file's i_mmap_lock or anon_vma lock for read (or for -* write). In a few cases, it may be used with pmd pointing to a pmd_t already -* copied to or constructed on the stack. +* pte_offset_map_lock(mm, pmd, addr, ptlp) is usually called with the pmd +* pointer for addr, reached by walking down the mm's pgd, p4d, pud for addr: +* either while holding mmap_lock or vma lock for read or for write; or in +* truncate or rmap context, while holding file's i_mmap_lock or anon_vma lock +* for read (or for write). In a few cases, it may be used with pmd pointing to +* a pmd_t already copied to or constructed on the stack. * * When successful, it returns the pte pointer for addr, with its page table * kmapped if necessary (when CONFIG_HIGHPTE), and locked against concurrent
@@ -387,8 +386,8 @@ pte_t *pte_offset_map_rw_nolock(struct mm_struct *mm, pmd_t *pmd,* table, and may not use RCU at all: "outsiders" like khugepaged should avoid * pte_offset_map() and co once the vma is detached from mm or mm_users is zero. */ -pte_t *__pte_offset_map_lock (struct mm_struct *mm,pmd_t *pmd, -unsigned long addr,spinlock_t **ptlp) +pte_t *pte_offset_map_lock (struct mm_struct *mm,pmd_t *pmd, +unsigned long addr,spinlock_t **ptlp) {spinlock_t *ptl;pmd_t pmdval;
tools/include/linux/compiler_types.h +0 -2
@@ -20,7 +20,6 @@# define __releases (x) __attribute__((context(x,1,0)))# define __acquire (x) __context__(x,1)# define __release (x) __context__(x,-1) -# define __cond_lock (x,c) ((c) ? ({ __acquire(x); 1; }) : 0)#else /* __CHECKER__ */ /* context/locking */ # define __must_hold (x)
@@ -28,7 +27,6 @@# define __releases (x)# define __acquire (x) (void)0# define __release (x) (void)0 -# define __cond_lock (x,c) (c)#endif /* __CHECKER__ */ /* Compiler specific macros. */
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Marco Elver
maintainerPATCH v4 24/35 compiler-context-analysis: Introduce header suppressions
In reply to Marco ElverWhile we can opt in individual subsystems which add the required annotations, such subsystems inevitably include headers from other subsystems which may not yet have the right annotations, which then result in false positive warnings.
Making compatible by adding annotations across all common headers currently requires an excessive number of __no_context_analysis annotations, or carefully analyzing non-trivial cases to add the correct annotations. While this is desirable long-term, providing an incremental path causes less churn and headaches for maintainers not yet interested in dealing with such warnings.
Rather than clutter headers unnecessary and mandate all subsystem maintainers to keep their headers working with context analysis, suppress all -Wthread-safety warnings in headers. Explicitly opt in headers with context-enabled primitives.
With this in place, we can start enabling the analysis on more complex subsystems in subsequent changes.
---
v4:
* Rename capability -> context analysis.
--- scripts/Makefile.context-analysis | 4 +++ scripts/context-analysis-suppression.txt | 32 ++++++++++++++++++++++++ 2 files changed, 36 insertions(+) create mode 100644 scripts/context-analysis-suppression.txt
scripts/Makefile.context-analysis +4 -0
@@ -4,4 +4,8 @@ context-analysis-cflags := -DWARN_CONTEXT_ANALYSIS \ -fexperimental-late-parse-attributes -Wthread-safety \ -Wthread-safety-pointer -Wthread-safety-beta +ifndef CONFIG_WARN_CONTEXT_ANALYSIS_ALL +context-analysis-cflags += --warning-suppression-mappings=$(srctree)/scripts/context-analysis-suppression.txt +endif + export CFLAGS_CONTEXT_ANALYSIS := $(context-analysis-cflags)
scripts/context-analysis-suppression.txt new file +32 -0
@@ -0,0 +1,32 @@ +# SPDX-License-Identifier: GPL-2.0 +# +# The suppressions file should only match common paths such as header files. +# For individual subsytems use Makefile directive CONTEXT_ANALYSIS := [yn]. +# +# The suppressions are ignored when CONFIG_WARN_CONTEXT_ANALYSIS_ALL is +# selected. + +[thread-safety] +src:*arch/*/include/* +src:*include/acpi/* +src:*include/asm-generic/* +src:*include/linux/* +src:*include/net/* + +# Opt-in headers: +src:*include/linux/bit_spinlock.h=emit +src:*include/linux/cleanup.h=emit +src:*include/linux/kref.h=emit +src:*include/linux/list*.h=emit +src:*include/linux/local_lock*.h=emit +src:*include/linux/lockdep.h=emit +src:*include/linux/mutex*.h=emit +src:*include/linux/rcupdate.h=emit +src:*include/linux/refcount.h=emit +src:*include/linux/rhashtable.h=emit +src:*include/linux/rwlock*.h=emit +src:*include/linux/rwsem.h=emit +src:*include/linux/seqlock*.h=emit +src:*include/linux/spinlock*.h=emit +src:*include/linux/srcu*.h=emit +src:*include/linux/ww_mutex.h=emit
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Marco Elver
maintainerPATCH v4 25/35 compiler: Let data_race() imply disabled context analysis
In reply to Marco ElverMany patterns that involve data-racy accesses often deliberately ignore normal synchronization rules to avoid taking a lock.
If we have a lock-guarded variable on which we do a lock-less data-racy access, rather than having to write context_unsafe(data_race(..)), simply make the data_race(..) macro imply context-unsafety. The data_race() macro already denotes the intent that something subtly unsafe is about to happen, so it should be clear enough as-is.
---
v4:
* Rename capability -> context analysis.
v2:
* New patch.
--- include/linux/compiler.h | 2 ++ lib/test_context-analysis.c | 2 ++ 2 files changed, 4 insertions(+)
include/linux/compiler.h +2 -0
@@ -186,7 +186,9 @@ void ftrace_likely_update(struct ftrace_likely_data *f, int val,#define data_race (expr) \ ({ \ __kcsan_disable_current(); \ + disable_context_analysis(); \ __auto_type __v = (expr); \ + enable_context_analysis(); \ __kcsan_enable_current(); \ __v; \ })
lib/test_context-analysis.c +2 -0
@@ -92,6 +92,8 @@ static void __used test_raw_spinlock_trylock_extra(struct test_raw_spinlock_data {unsigned long flags; +data_race (d->counter++);/* no warning */ +if (raw_spin_trylock_irq (&d->lock)) { d->counter++;raw_spin_unlock_irq (&d->lock);
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Marco Elver
maintainerPATCH v4 26/35 MAINTAINERS: Add entry for Context Analysis
In reply to Marco ElverAdd entry for all new files added for Clang's context analysis.
---
v4:
* Rename capability -> context analysis.
--- MAINTAINERS | 11 +++++++++++ 1 file changed, 11 insertions(+)
MAINTAINERS +11 -0
@@ -6029,6 +6029,17 @@ M: Nelson Escobar <[email protected]> S: Supported F: drivers/infiniband/hw/usnic/ +CLANG CONTEXT ANALYSIS +M: Marco Elver <[email protected]> +R: Bart Van Assche <[email protected]> +L: [email protected] +S: Maintained +F: Documentation/dev-tools/context-analysis.rst +F: include/linux/compiler-context-analysis.h +F: lib/test_context-analysis.c +F: scripts/Makefile.context-analysis +F: scripts/context-analysis-suppression.txt + CLANG CONTROL FLOW INTEGRITY SUPPORT M: Sami Tolvanen <[email protected]> M: Kees Cook <[email protected]>
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Marco Elver
maintainerPATCH v4 27/35 kfence: Enable context analysis
In reply to Marco ElverEnable context analysis for the KFENCE subsystem.
Notable, kfence_handle_page_fault() required minor restructure, which also fixed a subtle race; arguably that function is more readable now.
---
v4:
* Rename capability -> context analysis.
v2:
* Remove disable/enable_context_analysis() around headers.
* Use __context_unsafe() instead of __no_context_analysis.
--- mm/kfence/Makefile | 2 ++ mm/kfence/core.c | 20 +++++++++++++------- mm/kfence/kfence.h | 14 ++++++++------ mm/kfence/report.c | 4 ++-- 4 files changed, 25 insertions(+), 15 deletions(-)
mm/kfence/Makefile +2 -0
@@ -1,5 +1,7 @@ # SPDX-License-Identifier: GPL-2.0 +CONTEXT_ANALYSIS := y + obj-y := core.o report.o CFLAGS_kfence_test.o := -fno-omit-frame-pointer -fno-optimize-sibling-calls
mm/kfence/core.c +13 -7
@@ -132,8 +132,8 @@ struct kfence_metadata *kfence_metadata __read_mostly;static struct kfence_metadata *kfence_metadata_init__read_mostly ;/* Freelist with available objects. */ -static struct list_head kfence_freelist =LIST_HEAD_INIT (kfence_freelist); -static DEFINE_RAW_SPINLOCK (kfence_freelist_lock);/* Lock protecting freelist. */ +DEFINE_RAW_SPINLOCK (kfence_freelist_lock);/* Lock protecting freelist. */ +static struct list_head kfence_freelist __guarded_by(&kfence_freelist_lock) = LIST_HEAD_INIT(kfence_freelist);/* * The static key to set up a KFENCE allocation; or if static keys are not used
@@ -253,6 +253,7 @@ static bool kfence_unprotect(unsigned long addr) }static inline unsigned long metadata_to_pageaddr (const struct kfence_metadata *meta) + __must_hold(&meta->lock) {unsigned long offset = (meta - kfence_metadata +1 ) *PAGE_SIZE *2 ;unsigned long pageaddr = (unsigned long )&__kfence_pool[offset];
@@ -288,6 +289,7 @@ static inline bool kfence_obj_allocated(const struct kfence_metadata *meta) static noinline voidmetadata_update_state (struct kfence_metadata *meta,enum kfence_object_state next,unsigned long *stack_entries,size_t num_stack_entries) + __must_hold(&meta->lock) {struct kfence_track *track = next ==KFENCE_OBJECT_ALLOCATED ? &meta->alloc_track : &meta->free_track;
@@ -485,7 +487,7 @@ static void *kfence_guarded_alloc(struct kmem_cache *cache, size_t size, gfp_t galloc_covered_add (alloc_stack_hash,1 );/* Set required slab fields. */ - slab =virt_to_slab ((void *)meta->addr); + slab =virt_to_slab (addr); slab->slab_cache = cache; slab->objects =1 ;
@@ -514,6 +516,7 @@ static void *kfence_guarded_alloc(struct kmem_cache *cache, size_t size, gfp_t gstatic void kfence_guarded_free (void *addr,struct kfence_metadata *meta,bool zombie) {struct kcsan_scoped_access assert_page_exclusive; +u32 alloc_stack_hash;unsigned long flags;bool init;
@@ -546,9 +549,10 @@ static void kfence_guarded_free(void *addr, struct kfence_metadata *meta, bool z/* Mark the object as freed. */ metadata_update_state (meta,KFENCE_OBJECT_FREED ,NULL ,0 ); init =slab_want_init_on_free (meta->cache); + alloc_stack_hash = meta->alloc_stack_hash;raw_spin_unlock_irqrestore (&meta->lock, flags); -alloc_covered_add (meta->alloc_stack_hash,-1 ); +alloc_covered_add (alloc_stack_hash,-1 );/* Check canary bytes for memory corruption. */ check_canary (meta);
@@ -593,6 +597,7 @@ static void rcu_guarded_free(struct rcu_head *h)* which partial initialization succeeded. */ static unsigned long kfence_init_pool (void ) +__context_unsafe (/* constructor */ ) {unsigned long addr, start_pfn;int i;
@@ -1194,6 +1199,7 @@ bool kfence_handle_page_fault(unsigned long addr, bool is_write, struct pt_regs {const int page_index = (addr - (unsigned long )__kfence_pool) /PAGE_SIZE ;struct kfence_metadata *to_report =NULL ; +unsigned long unprotected_page =0 ;enum kfence_error_type error_type;unsigned long flags;
@@ -1227,9 +1233,8 @@ bool kfence_handle_page_fault(unsigned long addr, bool is_write, struct pt_regsif (!to_report) goto out; -raw_spin_lock_irqsave (&to_report->lock, flags); - to_report->unprotected_page = addr; error_type =KFENCE_ERROR_OOB ; + unprotected_page = addr;/* * If the object was freed before we took the look we can still
@@ -1241,7 +1246,6 @@ bool kfence_handle_page_fault(unsigned long addr, bool is_write, struct pt_regsif (!to_report) goto out; -raw_spin_lock_irqsave (&to_report->lock, flags); error_type =KFENCE_ERROR_UAF ;/* * We may race with __kfence_alloc(), and it is possible that a
@@ -1253,6 +1257,8 @@ bool kfence_handle_page_fault(unsigned long addr, bool is_write, struct pt_regs out:if (to_report) { +raw_spin_lock_irqsave (&to_report->lock, flags); + to_report->unprotected_page = unprotected_page;kfence_report_error (addr, is_write, regs, to_report, error_type);raw_spin_unlock_irqrestore (&to_report->lock, flags); }else {
mm/kfence/kfence.h +8 -6
@@ -34,6 +34,8 @@/* Maximum stack depth for reports. */ #define KFENCE_STACK_DEPTH 64 +extern raw_spinlock_t kfence_freelist_lock; +/* KFENCE object states. */ enum kfence_object_state {KFENCE_OBJECT_UNUSED ,/* Object is unused. */
@@ -53,7 +55,7 @@ struct kfence_track {/* KFENCE metadata per guarded allocation. */ struct kfence_metadata { -struct list_head list;/* Freelist node; access under kfence_freelist_lock. */ + struct list_head list __guarded_by(&kfence_freelist_lock); /* Freelist node. */struct rcu_head rcu_head;/* For delayed freeing. */ /*
@@ -91,13 +93,13 @@ struct kfence_metadata {* In case of an invalid access, the page that was unprotected; we * optimistically only store one address. */ -unsigned long unprotected_page; + unsigned long unprotected_page __guarded_by(&lock);/* Allocation and free stack information. */ -struct kfence_track alloc_track; -struct kfence_track free_track; + struct kfence_track alloc_track __guarded_by(&lock); + struct kfence_track free_track __guarded_by(&lock);/* For updating alloc_covered on frees. */ -u32 alloc_stack_hash; + u32 alloc_stack_hash __guarded_by(&lock);#ifdef CONFIG_MEMCG struct slabobj_ext obj_exts;#endif
@@ -141,6 +143,6 @@ enum kfence_error_type {void kfence_report_error (unsigned long address,bool is_write,struct pt_regs *regs,const struct kfence_metadata *meta,enum kfence_error_type type); -void kfence_print_object (struct seq_file *seq,const struct kfence_metadata *meta); +void kfence_print_object(struct seq_file *seq, const struct kfence_metadata *meta) __must_hold(&meta->lock);#endif /* MM_KFENCE_KFENCE_H */
mm/kfence/report.c +2 -2
@@ -106,6 +106,7 @@ static int get_stack_skipnr(const unsigned long stack_entries[], int num_entriesstatic void kfence_print_stack (struct seq_file *seq,const struct kfence_metadata *meta,bool show_alloc) + __must_hold(&meta->lock) {const struct kfence_track *track = show_alloc ? &meta->alloc_track : &meta->free_track;u64 ts_sec = track->ts_nsec;
@@ -207,8 +208,6 @@ void kfence_report_error(unsigned long address, bool is_write, struct pt_regs *rif (WARN_ON (type !=KFENCE_ERROR_INVALID && !meta))return ; -if (meta) -lockdep_assert_held (&meta->lock);/* * Because we may generate reports in printk-unfriendly parts of the * kernel, such as scheduler code, the use of printk() could deadlock.
@@ -263,6 +262,7 @@ void kfence_report_error(unsigned long address, bool is_write, struct pt_regs *rstack_trace_print (stack_entries + skipnr, num_stack_entries - skipnr,0 );if (meta) { +lockdep_assert_held (&meta->lock);pr_err ("\n" );kfence_print_object (NULL , meta); }
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Marco Elver
maintainerPATCH v4 28/35 kcov: Enable context analysis
In reply to Marco ElverEnable context analysis for the KCOV subsystem.
---
v4:
* Fix new temporary variable type.
* Rename capability -> context analysis.
v2:
* Remove disable/enable_context_analysis() around headers.
--- kernel/Makefile | 2 ++ kernel/kcov.c | 36 +++++++++++++++++++++++++----------- 2 files changed, 27 insertions(+), 11 deletions(-)
kernel/Makefile +2 -0
@@ -43,6 +43,8 @@ KASAN_SANITIZE_kcov.o := n KCSAN_SANITIZE_kcov.o := n UBSAN_SANITIZE_kcov.o := n KMSAN_SANITIZE_kcov.o := n + +CONTEXT_ANALYSIS_kcov.o := y CFLAGS_kcov.o := $(call cc-option, -fno-conserve-stack) -fno-stack-protector obj-y += sched/
kernel/kcov.c +25 -11
@@ -55,13 +55,13 @@ struct kcov {refcount_t refcount;/* The lock protects mode, size, area and t. */ spinlock_t lock; -enum kcov_mode mode; + enum kcov_mode mode __guarded_by(&lock);/* Size of arena (in long's). */ -unsigned int size; + unsigned int size __guarded_by(&lock);/* Coverage buffer shared with user space. */ -void *area; + void *area __guarded_by(&lock);/* Task for which we collect coverage, or NULL. */ -struct task_struct *t; + struct task_struct *t __guarded_by(&lock);/* Collecting coverage from remote (background) threads. */ bool remote;/* Size of remote area (in long's). */
@@ -391,6 +391,7 @@ void kcov_task_init(struct task_struct *t) }static void kcov_reset (struct kcov *kcov) + __must_hold(&kcov->lock) { kcov->t =NULL ; kcov->mode =KCOV_MODE_INIT ;
@@ -400,6 +401,7 @@ static void kcov_reset(struct kcov *kcov) }static void kcov_remote_reset (struct kcov *kcov) + __must_hold(&kcov->lock) {int bkt;struct kcov_remote *remote;
@@ -419,6 +421,7 @@ static void kcov_remote_reset(struct kcov *kcov) }static void kcov_disable (struct task_struct *t,struct kcov *kcov) + __must_hold(&kcov->lock) {kcov_task_reset (t);if (kcov->remote)
@@ -435,8 +438,11 @@ static void kcov_get(struct kcov *kcov)static void kcov_put (struct kcov *kcov) {if (refcount_dec_and_test (&kcov->refcount)) { -kcov_remote_reset (kcov); -vfree (kcov->area); +/* Context-safety: no references left, object being destroyed. */ +context_unsafe ( + kcov_remote_reset(kcov); +vfree (kcov->area); + );kfree (kcov); } }
@@ -491,6 +497,7 @@ static int kcov_mmap(struct file *filep, struct vm_area_struct *vma)unsigned long size, off;struct page *page;unsigned long flags; +void *area;spin_lock_irqsave (&kcov->lock, flags); size = kcov->size *sizeof (unsigned long );
@@ -499,10 +506,11 @@ static int kcov_mmap(struct file *filep, struct vm_area_struct *vma) res = -EINVAL ; goto exit; } + area = kcov->area;spin_unlock_irqrestore (&kcov->lock, flags);vm_flags_set (vma,VM_DONTEXPAND );for (off =0 ; off < size; off +=PAGE_SIZE ) { - page =vmalloc_to_page (kcov->area + off); + page =vmalloc_to_page (area + off); res =vm_insert_page (vma, vma->vm_start + off, page);if (res) {pr_warn_once ("kcov: vm_insert_page() failed\n" );
@@ -522,10 +530,10 @@ static int kcov_open(struct inode *inode, struct file *filep) kcov =kzalloc (sizeof (*kcov),GFP_KERNEL );if (!kcov)return -ENOMEM ; +spin_lock_init (&kcov->lock); kcov->mode =KCOV_MODE_DISABLED ; kcov->sequence =1 ;refcount_set (&kcov->refcount,1 ); -spin_lock_init (&kcov->lock); filep->private_data = kcov;return nonseekable_open (inode, filep); }
@@ -556,6 +564,7 @@ static int kcov_get_mode(unsigned long arg)* vmalloc fault handling path is instrumented. */ static void kcov_fault_in_area (struct kcov *kcov) + __must_hold(&kcov->lock) {unsigned long stride =PAGE_SIZE /sizeof (unsigned long );unsigned long *area = kcov->area;
@@ -584,6 +593,7 @@ static inline bool kcov_check_handle(u64 handle, bool common_valid,static int kcov_ioctl_locked (struct kcov *kcov,unsigned int cmd,unsigned long arg) + __must_hold(&kcov->lock) {struct task_struct *t;unsigned long flags, unused;
@@ -814,6 +824,7 @@ static inline bool kcov_mode_enabled(unsigned int mode) }static void kcov_remote_softirq_start (struct task_struct *t) + __must_hold(&kcov_percpu_data.lock) {struct kcov_percpu_data *data =this_cpu_ptr (&kcov_percpu_data);unsigned int mode;
@@ -831,6 +842,7 @@ static void kcov_remote_softirq_start(struct task_struct *t) }static void kcov_remote_softirq_stop (struct task_struct *t) + __must_hold(&kcov_percpu_data.lock) {struct kcov_percpu_data *data =this_cpu_ptr (&kcov_percpu_data);
@@ -896,10 +908,12 @@ void kcov_remote_start(u64 handle)/* Put in kcov_remote_stop(). */ kcov_get (kcov);/* -* Read kcov fields before unlock to prevent races with -* KCOV_DISABLE / kcov_remote_reset(). +* Read kcov fields before unlocking kcov_remote_lock to prevent races +* with KCOV_DISABLE and kcov_remote_reset(); cannot acquire kcov->lock +* here, because it might lead to deadlock given kcov_remote_lock is +* acquired _after_ kcov->lock elsewhere. */ - mode = kcov->mode; + mode =context_unsafe (kcov->mode); sequence = kcov->sequence;if (in_task ()) { size = kcov->remote_size;
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Marco Elver
maintainerPATCH v4 29/35 kcsan: Enable context analysis
In reply to Marco ElverEnable context analysis for the KCSAN subsystem.
---
v4:
* Rename capability -> context analysis.
v3:
* New patch.
--- kernel/kcsan/Makefile | 2 ++ kernel/kcsan/report.c | 11 ++++++++--- 2 files changed, 10 insertions(+), 3 deletions(-)
kernel/kcsan/Makefile +2 -0
@@ -1,4 +1,6 @@ # SPDX-License-Identifier: GPL-2.0 +CONTEXT_ANALYSIS := y + KCSAN_SANITIZE := n KCOV_INSTRUMENT := n UBSAN_SANITIZE := n
kernel/kcsan/report.c +8 -3
@@ -116,6 +116,7 @@ static DEFINE_RAW_SPINLOCK(report_lock);* been reported since (now - KCSAN_REPORT_ONCE_IN_MS). */ static bool rate_limit_report (unsigned long frame1,unsigned long frame2) + __must_hold(&report_lock) {struct report_time *use_entry = &report_times[0 ];unsigned long invalid_before;
@@ -366,6 +367,7 @@ static int sym_strcmp(void *addr1, void *addr2)static void print_stack_trace (unsigned long stack_entries[],int num_entries,unsigned long reordered_to) + __must_hold(&report_lock) {stack_trace_print (stack_entries, num_entries,0 );if (reordered_to)
@@ -373,6 +375,7 @@ print_stack_trace(unsigned long stack_entries[], int num_entries, unsigned long }static void print_verbose_info (struct task_struct *task) + __must_hold(&report_lock) {if (!task)return ;
@@ -389,6 +392,7 @@ static void print_report(enum kcsan_value_change value_change,const struct access_info *ai, struct other_info *other_info, u64 old, u64 new, u64 mask) + __must_hold(&report_lock) { unsigned long reordered_to = 0;unsigned long stack_entries[NUM_STACK_ENTRIES ] = {0 };
@@ -496,6 +500,7 @@ static void print_report(enum kcsan_value_change value_change, }static void release_report (unsigned long *flags,struct other_info *other_info) + __releases(&report_lock) {/* * Use size to denote valid/invalid, since KCSAN entirely ignores
@@ -507,13 +512,11 @@ static void release_report(unsigned long *flags, struct other_info *other_info)/* * Sets @other_info->task and awaits consumption of @other_info. -* -* Precondition: report_lock is held. -* Postcondition: report_lock is held. */ static void set_other_info_task_blocking (unsigned long *flags,const struct access_info *ai,struct other_info *other_info) + __must_hold(&report_lock) {/* * We may be instrumenting a code-path where current->state is already
@@ -572,6 +575,7 @@ static void set_other_info_task_blocking(unsigned long *flags,static void prepare_report_producer (unsigned long *flags,const struct access_info *ai,struct other_info *other_info) + __must_not_hold(&report_lock) {raw_spin_lock_irqsave (&report_lock, *flags);
@@ -603,6 +607,7 @@ static void prepare_report_producer(unsigned long *flags,static bool prepare_report_consumer (unsigned long *flags,const struct access_info *ai,struct other_info *other_info) + __cond_acquires(true, &report_lock) {raw_spin_lock_irqsave (&report_lock, *flags);
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Marco Elver
maintainerPATCH v4 30/35 stackdepot: Enable context analysis
In reply to Marco ElverEnable context analysis for stackdepot.
---
v4:
* Rename capability -> context analysis.
v2:
* Remove disable/enable_context_analysis() around headers.
--- lib/Makefile | 1 + lib/stackdepot.c | 20 ++++++++++++++------ 2 files changed, 15 insertions(+), 6 deletions(-)
lib/Makefile +1 -0
@@ -248,6 +248,7 @@ obj-$(CONFIG_POLYNOMIAL) += polynomial.o # Prevent the compiler from calling builtins like memcmp() or bcmp() from this # file. CFLAGS_stackdepot.o += -fno-builtin +CONTEXT_ANALYSIS_stackdepot.o := y obj-$(CONFIG_STACKDEPOT) += stackdepot.o KASAN_SANITIZE_stackdepot.o := n # In particular, instrumenting stackdepot.c with KMSAN will result in infinite
lib/stackdepot.c +14 -6
@@ -61,18 +61,18 @@ static unsigned int stack_bucket_number_order;/* Hash mask for indexing the table. */ static unsigned int stack_hash_mask; +/* The lock must be held when performing pool or freelist modifications. */ +static DEFINE_RAW_SPINLOCK (pool_lock);/* Array of memory regions that store stack records. */ -static void **stack_pools; +static void **stack_pools __pt_guarded_by(&pool_lock);/* Newly allocated pool that is not yet added to stack_pools. */ static void *new_pool;/* Number of pools in stack_pools. */ static int pools_num;/* Offset to the unused space in the currently used pool. */ -static size_t pool_offset =DEPOT_POOL_SIZE ; +static size_t pool_offset __guarded_by(&pool_lock) = DEPOT_POOL_SIZE;/* Freelist of stack records within stack_pools. */ -static LIST_HEAD (free_stacks); -/* The lock must be held when performing pool or freelist modifications. */ -static DEFINE_RAW_SPINLOCK (pool_lock); +static __guarded_by(&pool_lock) LIST_HEAD(free_stacks);/* Statistics counters for debugfs. */ enum depot_counter_id {
@@ -291,6 +291,7 @@ EXPORT_SYMBOL_GPL(stack_depot_init);* Initializes new stack pool, and updates the list of pools. */ static bool depot_init_pool (void **prealloc) + __must_hold(&pool_lock) {lockdep_assert_held (&pool_lock);
@@ -338,6 +339,7 @@ static bool depot_init_pool(void **prealloc)/* Keeps the preallocated memory to be used for a new stack depot pool. */ static void depot_keep_new_pool (void **prealloc) + __must_hold(&pool_lock) {lockdep_assert_held (&pool_lock);
@@ -357,6 +359,7 @@ static void depot_keep_new_pool(void **prealloc)* the current pre-allocation. */ static struct stack_record *depot_pop_free_pool (void **prealloc,size_t size) + __must_hold(&pool_lock) {struct stack_record *stack;void *current_pool;
@@ -391,6 +394,7 @@ static struct stack_record *depot_pop_free_pool(void **prealloc, size_t size)/* Try to find next free usable entry from the freelist. */ static struct stack_record *depot_pop_free (void ) + __must_hold(&pool_lock) {struct stack_record *stack;
@@ -428,6 +432,7 @@ static inline size_t depot_stack_record_size(struct stack_record *s, unsigned in/* Allocates a new stack in a stack depot pool. */ static struct stack_record *depot_alloc_stack (unsigned long *entries,unsigned int nr_entries,u32 hash,depot_flags_t flags,void **prealloc) + __must_hold(&pool_lock) {struct stack_record *stack =NULL ;size_t record_size;
@@ -486,6 +491,7 @@ depot_alloc_stack(unsigned long *entries, unsigned int nr_entries, u32 hash, dep }static struct stack_record *depot_fetch_stack (depot_stack_handle_t handle) + __must_not_hold(&pool_lock) {const int pools_num_cached =READ_ONCE (pools_num);union handle_parts parts = { .handle = handle };
@@ -502,7 +508,8 @@ static struct stack_record *depot_fetch_stack(depot_stack_handle_t handle)return NULL ; } - pool = stack_pools[pool_index]; +/* @pool_index either valid, or user passed in corrupted value. */ + pool =context_unsafe (stack_pools[pool_index]);if (WARN_ON (!pool))return NULL ;
@@ -515,6 +522,7 @@ static struct stack_record *depot_fetch_stack(depot_stack_handle_t handle)/* Links stack into the freelist. */ static void depot_free_stack (struct stack_record *stack) + __must_not_hold(&pool_lock) {unsigned long flags;
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Marco Elver
maintainerPATCH v4 31/35 rhashtable: Enable context analysis
In reply to Marco ElverEnable context analysis for rhashtable, which was used as an initial test as it contains a combination of RCU, mutex, and bit_spinlock usage.
Users of rhashtable now also benefit from annotations on the API, which will now warn if the RCU read lock is not held where required.
---
v4:
* Rename capability -> context analysis.
v2:
* Remove disable/enable_context_analysis() around headers.
--- include/linux/rhashtable.h | 14 +++++++++++--- lib/Makefile | 2 ++ lib/rhashtable.c | 5 +++-- 3 files changed, 16 insertions(+), 5 deletions(-)
include/linux/rhashtable.h +11 -3
@@ -245,16 +245,17 @@ void *rhashtable_insert_slow(struct rhashtable *ht, const void *key,void rhashtable_walk_enter (struct rhashtable *ht,struct rhashtable_iter *iter);void rhashtable_walk_exit (struct rhashtable_iter *iter); -int rhashtable_walk_start_check(struct rhashtable_iter *iter) __acquires(RCU); +int rhashtable_walk_start_check(struct rhashtable_iter *iter) __acquires_shared(RCU);static inline void rhashtable_walk_start (struct rhashtable_iter *iter) +__acquires_shared (RCU ) { (void )rhashtable_walk_start_check (iter); }void *rhashtable_walk_next (struct rhashtable_iter *iter);void *rhashtable_walk_peek (struct rhashtable_iter *iter); -void rhashtable_walk_stop(struct rhashtable_iter *iter) __releases(RCU); +void rhashtable_walk_stop(struct rhashtable_iter *iter) __releases_shared(RCU); void rhashtable_free_and_destroy(struct rhashtable *ht, void (*free_fn)(void *ptr, void *arg),
@@ -325,6 +326,7 @@ static inline struct rhash_lock_head __rcu **rht_bucket_insert(static inline unsigned long rht_lock (struct bucket_table *tbl,struct rhash_lock_head __rcu **bkt) +__acquires (__bitlock (0 , bkt)) {unsigned long flags;
@@ -337,6 +339,7 @@ static inline unsigned long rht_lock(struct bucket_table *tbl,static inline unsigned long rht_lock_nested (struct bucket_table *tbl,struct rhash_lock_head __rcu **bucket,unsigned int subclass) +__acquires (__bitlock (0 , bucket)) {unsigned long flags;
@@ -349,6 +352,7 @@ static inline unsigned long rht_lock_nested(struct bucket_table *tbl,static inline void rht_unlock (struct bucket_table *tbl,struct rhash_lock_head __rcu **bkt,unsigned long flags) +__releases (__bitlock (0 , bkt)) {lock_map_release (&tbl->dep_map);bit_spin_unlock (0 , (unsigned long *)bkt);
@@ -402,13 +406,14 @@ static inline void rht_assign_unlock(struct bucket_table *tbl,struct rhash_lock_head __rcu **bkt, struct rhash_head *obj, unsigned long flags) + __releases(__bitlock(0, bkt)) { if (rht_is_a_nulls(obj)) obj =NULL ;lock_map_release (&tbl->dep_map);rcu_assign_pointer (*bkt, (void *)obj);preempt_enable (); -__release (bitlock); +__release (__bitlock (0 , bkt));local_irq_restore (flags); }
@@ -589,6 +594,7 @@ static inline int rhashtable_compare(struct rhashtable_compare_arg *arg, static __always_inline struct rhash_head *__rhashtable_lookup(struct rhashtable *ht,const void *key,const struct rhashtable_params params) +__must_hold_shared (RCU ) {struct rhashtable_compare_arg arg = { .ht = ht,
@@ -642,6 +648,7 @@ static __always_inline struct rhash_head *__rhashtable_lookup( static __always_inline void *rhashtable_lookup(struct rhashtable *ht,const void *key,const struct rhashtable_params params) +__must_hold_shared (RCU ) {struct rhash_head *he =__rhashtable_lookup (ht, key, params);
@@ -692,6 +699,7 @@ static __always_inline void *rhashtable_lookup_fast( static __always_inline struct rhlist_head *rhltable_lookup(struct rhltable *hlt,const void *key,const struct rhashtable_params params) +__must_hold_shared (RCU ) {struct rhash_head *he =__rhashtable_lookup (&hlt->ht, key, params);
lib/Makefile +2 -0
@@ -50,6 +50,8 @@ lib-$(CONFIG_MIN_HEAP) += min_heap.o lib-y += kobject.o klist.o obj-y += lockref.o +CONTEXT_ANALYSIS_rhashtable.o := y + obj-y += bcd.o sort.o parser.o debug_locks.o random32.o \ bust_spinlocks.o kasprintf.o bitmap.o scatterlist.o \ list_sort.o uuid.o iov_iter.o clz_ctz.o \
lib/rhashtable.c +3 -2
@@ -358,6 +358,7 @@ static int rhashtable_rehash_table(struct rhashtable *ht)static int rhashtable_rehash_alloc (struct rhashtable *ht,struct bucket_table *old_tbl,unsigned int size) + __must_hold(&ht->mutex) {struct bucket_table *new_tbl;int err;
@@ -392,6 +393,7 @@ static int rhashtable_rehash_alloc(struct rhashtable *ht,* bucket locks or concurrent RCU protected lookups and traversals. */ static int rhashtable_shrink (struct rhashtable *ht) + __must_hold(&ht->mutex) {struct bucket_table *old_tbl =rht_dereference (ht->tbl, ht);unsigned int nelems =atomic_read (&ht->nelems);
@@ -724,7 +726,7 @@ EXPORT_SYMBOL_GPL(rhashtable_walk_exit);* resize events and always continue. */ int rhashtable_walk_start_check (struct rhashtable_iter *iter) -__acquires (RCU ) +__acquires_shared (RCU ) {struct rhashtable *ht = iter->ht;bool rhlist = ht->rhlist;
@@ -940,7 +942,6 @@ EXPORT_SYMBOL_GPL(rhashtable_walk_peek);* hash table. */ void rhashtable_walk_stop (struct rhashtable_iter *iter) -__releases (RCU ) {struct rhashtable *ht;struct bucket_table *tbl = iter->walker.tbl;
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Marco Elver
maintainerPATCH v4 32/35 printk: Move locking annotation to printk.c
In reply to Marco ElverWith Sparse support gone, Clang is a bit more strict and warns:
./include/linux/console.h:492:50: error: use of undeclared identifier 'console_mutex'
492 | extern void console_list_unlock(void) __releases(console_mutex);
Since it does not make sense to make console_mutex itself global, move the annotation to printk.c. Context analysis remains disabled for printk.c.
This is needed to enable context analysis for modules that include <linux/console.h>.
---
v2:
* New patch.
--- include/linux/console.h | 4 ++-- kernel/printk/printk.c | 2 ++ 2 files changed, 4 insertions(+), 2 deletions(-)
include/linux/console.h +2 -2
@@ -488,8 +488,8 @@ static inline bool console_srcu_read_lock_is_held(void)extern int console_srcu_read_lock (void );extern void console_srcu_read_unlock (int cookie); -extern void console_list_lock(void) __acquires(console_mutex); -extern void console_list_unlock(void) __releases(console_mutex); +extern void console_list_lock (void ); +extern void console_list_unlock (void );extern struct hlist_head console_list;
kernel/printk/printk.c +2 -0
@@ -245,6 +245,7 @@ int devkmsg_sysctl_set_loglvl(const struct ctl_table *table, int write,* For console list or console->flags updates */ void console_list_lock (void ) + __acquires(&console_mutex) {/* * In unregister_console() and console_force_preferred_locked(),
@@ -269,6 +270,7 @@ EXPORT_SYMBOL(console_list_lock);* Counterpart to console_list_lock() */ void console_list_unlock (void ) + __releases(&console_mutex) {mutex_unlock (&console_mutex); }
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Marco Elver
maintainerPATCH v4 33/35 security/tomoyo: Enable context analysis
In reply to Marco ElverEnable context analysis for security/tomoyo.
This demonstrates a larger conversion to use Clang's context analysis. The benefit is additional static checking of locking rules, along with better documentation.
Tomoyo makes use of several synchronization primitives, yet its clear design made it relatively straightforward to enable context analysis.
One notable finding was:
security/tomoyo/gc.c:664:20: error: reading variable 'write_buf' requires holding mutex '&tomoyo_io_buffer::io_sem'
664 | is_write = head->write_buf != NULL;
For which Tetsuo writes:
"Good catch. This should be data_race(), for tomoyo_write_control()
might concurrently update head->write_buf from non-NULL to non-NULL with head->io_sem held."
---
v4:
* Rename capability -> context analysis.
v2:
* New patch.
--- security/tomoyo/Makefile | 2 + security/tomoyo/common.c | 52 ++++++++++++++++++++++++-- security/tomoyo/common.h | 77 ++++++++++++++++++++------------------- security/tomoyo/domain.c | 1 + security/tomoyo/environ.c | 1 + security/tomoyo/file.c | 5 +++ security/tomoyo/gc.c | 28 ++++++++++---- security/tomoyo/mount.c | 2 + security/tomoyo/network.c | 3 ++ 9 files changed, 122 insertions(+), 49 deletions(-)
security/tomoyo/Makefile +2 -0
@@ -1,4 +1,6 @@ # SPDX-License-Identifier: GPL-2.0 +CONTEXT_ANALYSIS := y + obj-y = audit.o common.o condition.o domain.o environ.o file.o gc.o group.o load_policy.o memory.o mount.o network.o realpath.o securityfs_if.o tomoyo.o util.o targets += builtin-policy.h
security/tomoyo/common.c +48 -4
250 lines not on this page · raw message
security/tomoyo/common.h +40 -37
129 lines not on this page · raw message
security/tomoyo/domain.c +1 -0
@@ -611,6 +611,7 @@ struct tomoyo_domain_info *tomoyo_assign_domain(const char *domainname,* Returns 0 on success, negative value otherwise. */ static int tomoyo_environ (struct tomoyo_execve *ee) + __must_hold_shared(&tomoyo_ss) {struct tomoyo_request_info *r = &ee->r;struct linux_binprm *bprm = ee->bprm;
security/tomoyo/environ.c +1 -0
@@ -32,6 +32,7 @@ static bool tomoyo_check_env_acl(struct tomoyo_request_info *r,* Returns 0 on success, negative value otherwise. */ static int tomoyo_audit_env_log (struct tomoyo_request_info *r) + __must_hold_shared(&tomoyo_ss) {return tomoyo_supervisor (r,"misc env %s\n" , r->param.environ.name->name);
security/tomoyo/file.c +5 -0
@@ -164,6 +164,7 @@ static bool tomoyo_get_realpath(struct tomoyo_path_info *buf, const struct path* Returns 0 on success, negative value otherwise. */ static int tomoyo_audit_path_log (struct tomoyo_request_info *r) + __must_hold_shared(&tomoyo_ss) { return tomoyo_supervisor(r, "file %s %s\n", tomoyo_path_keyword [r->param.path.operation],
@@ -178,6 +179,7 @@ static int tomoyo_audit_path_log(struct tomoyo_request_info *r)* Returns 0 on success, negative value otherwise. */ static int tomoyo_audit_path2_log (struct tomoyo_request_info *r) + __must_hold_shared(&tomoyo_ss) { return tomoyo_supervisor(r, "file %s %s %s\n", tomoyo_mac_keywords [tomoyo_pp2mac[r->param.path2.operation]],
@@ -193,6 +195,7 @@ static int tomoyo_audit_path2_log(struct tomoyo_request_info *r)* Returns 0 on success, negative value otherwise. */ static int tomoyo_audit_mkdev_log (struct tomoyo_request_info *r) + __must_hold_shared(&tomoyo_ss) {return tomoyo_supervisor (r,"file %s %s 0%o %u %u\n" , tomoyo_mac_keywords
@@ -210,6 +213,7 @@ static int tomoyo_audit_mkdev_log(struct tomoyo_request_info *r)* Returns 0 on success, negative value otherwise. */ static int tomoyo_audit_path_number_log (struct tomoyo_request_info *r) + __must_hold_shared(&tomoyo_ss) {const u8 type = r->param.path_number.operation;u8 radix;
@@ -572,6 +576,7 @@ static int tomoyo_update_path2_acl(const u8 perm,*/ static int tomoyo_path_permission (struct tomoyo_request_info *r,u8 operation,const struct tomoyo_path_info *filename) + __must_hold_shared(&tomoyo_ss) {int error;
security/tomoyo/gc.c +20 -8
@@ -23,11 +23,10 @@ static inline void tomoyo_memory_free(void *ptr) tomoyo_memory_used[TOMOYO_MEMORY_POLICY ] -=ksize (ptr);kfree (ptr); } - -/* The list for "struct tomoyo_io_buffer". */ -static LIST_HEAD (tomoyo_io_buffer_list);/* Lock for protecting tomoyo_io_buffer_list. */ static DEFINE_SPINLOCK (tomoyo_io_buffer_list_lock); +/* The list for "struct tomoyo_io_buffer". */ +static __guarded_by(&tomoyo_io_buffer_list_lock) LIST_HEAD(tomoyo_io_buffer_list);/** * tomoyo_struct_used_by_io_buffer - Check whether the list element is used by /sys/kernel/security/tomoyo/ users or not.
@@ -385,6 +384,7 @@ static inline void tomoyo_del_number_group(struct list_head *element)*/ static void tomoyo_try_to_gc (const enum tomoyo_policy_id type,struct list_head *element) + __must_hold(&tomoyo_policy_lock) {/* * __list_del_entry() guarantees that the list element became no longer
@@ -484,6 +484,7 @@ static void tomoyo_try_to_gc(const enum tomoyo_policy_id type,*/ static void tomoyo_collect_member (const enum tomoyo_policy_id id,struct list_head *member_list) + __must_hold(&tomoyo_policy_lock) {struct tomoyo_acl_head *member;struct tomoyo_acl_head *tmp;
@@ -504,6 +505,7 @@ static void tomoyo_collect_member(const enum tomoyo_policy_id id,* Returns nothing. */ static void tomoyo_collect_acl (struct list_head *list) + __must_hold(&tomoyo_policy_lock) {struct tomoyo_acl_info *acl;struct tomoyo_acl_info *tmp;
@@ -627,8 +629,11 @@ static int tomoyo_gc_thread(void *unused)if (head->users)continue ;list_del (&head->list); -kfree (head->read_buf); -kfree (head->write_buf); +/* Safe destruction because no users are left. */ +context_unsafe ( + kfree(head->read_buf); +kfree (head->write_buf); + );kfree (head); }spin_unlock (&tomoyo_io_buffer_list_lock);
@@ -656,11 +661,18 @@ void tomoyo_notify_gc(struct tomoyo_io_buffer *head, const bool is_register) head->users =1 ;list_add (&head->list, &tomoyo_io_buffer_list); }else { - is_write = head->write_buf !=NULL ; +/* +* tomoyo_write_control() can concurrently update write_buf from +* a non-NULL to new non-NULL pointer with io_sem held. +*/ + is_write =data_race (head->write_buf !=NULL );if (!--head->users) {list_del (&head->list); -kfree (head->read_buf); -kfree (head->write_buf); +/* Safe destruction because no users are left. */ +context_unsafe ( + kfree(head->read_buf); +kfree (head->write_buf); + );kfree (head); } }
security/tomoyo/mount.c +2 -0
@@ -28,6 +28,7 @@ static const char * const tomoyo_mounts[TOMOYO_MAX_SPECIAL_MOUNT] = {* Returns 0 on success, negative value otherwise. */ static int tomoyo_audit_mount_log (struct tomoyo_request_info *r) + __must_hold_shared(&tomoyo_ss) { return tomoyo_supervisor(r, "file mount %s %s %s 0x%lX\n", r->param.mount.dev->name,
@@ -78,6 +79,7 @@ static int tomoyo_mount_acl(struct tomoyo_request_info *r,const char *dev_name, const struct path *dir, const char *type, unsigned long flags) + __must_hold_shared(&tomoyo_ss) { struct tomoyo_obj_info obj = { };struct path path;
security/tomoyo/network.c +3 -0
@@ -363,6 +363,7 @@ int tomoyo_write_unix_network(struct tomoyo_acl_param *param)static int tomoyo_audit_net_log (struct tomoyo_request_info *r,const char *family,const u8 protocol,const u8 operation,const char *address) + __must_hold_shared(&tomoyo_ss) { return tomoyo_supervisor(r, "network %s %s %s %s\n", family, tomoyo_proto_keyword[protocol],
@@ -377,6 +378,7 @@ static int tomoyo_audit_net_log(struct tomoyo_request_info *r,* Returns 0 on success, negative value otherwise. */ static int tomoyo_audit_inet_log (struct tomoyo_request_info *r) + __must_hold_shared(&tomoyo_ss) {char buf[128 ];int len;
@@ -402,6 +404,7 @@ static int tomoyo_audit_inet_log(struct tomoyo_request_info *r)* Returns 0 on success, negative value otherwise. */ static int tomoyo_audit_unix_log (struct tomoyo_request_info *r) + __must_hold_shared(&tomoyo_ss) { return tomoyo_audit_net_log(r, "unix", r->param.unix_network.protocol, r->param.unix_network.operation,
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Marco Elver
maintainerPATCH v4 34/35 crypto: Enable context analysis
In reply to Marco ElverEnable context analysis for crypto subsystem.
This demonstrates a larger conversion to use Clang's context analysis. The benefit is additional static checking of locking rules, along with better documentation.
Note the use of the __acquire_ret macro how to define an API where a function returns a pointer to an object (struct scomp_scratch) with a lock held. Additionally, the analysis only resolves aliases where the analysis unambiguously sees that a variable was not reassigned after initialization, requiring minor code changes.
---
v4:
* Rename capability -> context analysis.
v3:
* Rebase - make use of __acquire_ret macro for new functions.
* Initialize variables once where we want the analysis to recognize aliases.
v2:
* New patch.
--- crypto/Makefile | 2 ++ crypto/acompress.c | 6 +++--- crypto/algapi.c | 2 ++ crypto/api.c | 1 + crypto/crypto_engine.c | 2 +- crypto/drbg.c | 5 +++++ crypto/internal.h | 2 +- crypto/proc.c | 3 +++ crypto/scompress.c | 24 ++++++++++++------------ include/crypto/internal/acompress.h | 7 ++++--- include/crypto/internal/engine.h | 2 +- 11 files changed, 35 insertions(+), 21 deletions(-)
crypto/Makefile +2 -0
@@ -3,6 +3,8 @@ # Cryptographic API # +CONTEXT_ANALYSIS := y + obj-$(CONFIG_CRYPTO) += crypto.o crypto-y := api.o cipher.o
crypto/acompress.c +3 -3
@@ -449,8 +449,8 @@ int crypto_acomp_alloc_streams(struct crypto_acomp_streams *s) }EXPORT_SYMBOL_GPL (crypto_acomp_alloc_streams); -struct crypto_acomp_stream *crypto_acomp_lock_stream_bh ( -struct crypto_acomp_streams *s)__acquires (stream) +struct crypto_acomp_stream *_crypto_acomp_lock_stream_bh ( +struct crypto_acomp_streams *s) {struct crypto_acomp_stream __percpu *streams = s->streams;int cpu =raw_smp_processor_id ();
@@ -469,7 +469,7 @@ struct crypto_acomp_stream *crypto_acomp_lock_stream_bh(spin_lock (&ps->lock);return ps; } -EXPORT_SYMBOL_GPL (crypto_acomp_lock_stream_bh); +EXPORT_SYMBOL_GPL (_crypto_acomp_lock_stream_bh);void acomp_walk_done_src (struct acomp_walk *walk,int used) {
crypto/algapi.c +2 -0
@@ -244,6 +244,7 @@ EXPORT_SYMBOL_GPL(crypto_remove_spawns);static void crypto_alg_finish_registration (struct crypto_alg *alg,struct list_head *algs_to_put) + __must_hold(&crypto_alg_sem) {struct crypto_alg *q;
@@ -299,6 +300,7 @@ static struct crypto_larval *crypto_alloc_test_larval(struct crypto_alg *alg)static struct crypto_larval *__crypto_register_alg (struct crypto_alg *alg,struct list_head *algs_to_put) + __must_hold(&crypto_alg_sem) {struct crypto_alg *q;struct crypto_larval *larval;
crypto/api.c +1 -0
@@ -57,6 +57,7 @@ EXPORT_SYMBOL_GPL(crypto_mod_put);static struct crypto_alg *__crypto_alg_lookup (const char *name,u32 type,u32 mask) + __must_hold_shared(&crypto_alg_sem) {struct crypto_alg *q, *alg =NULL ;int best =-2 ;
crypto/crypto_engine.c +1 -1
@@ -453,8 +453,8 @@ struct crypto_engine *crypto_engine_alloc_init_and_set(struct device *dev,snprintf (engine->name,sizeof (engine->name),"%s-engine" ,dev_name (dev)); -crypto_init_queue (&engine->queue, qlen);spin_lock_init (&engine->queue_lock); +crypto_init_queue (&engine->queue, qlen); engine->kworker =kthread_run_worker (0 ,"%s" , engine->name);if (IS_ERR (engine->kworker)) {
crypto/drbg.c +5 -0
@@ -231,6 +231,7 @@ static inline unsigned short drbg_sec_strength(drbg_flag_t flags)*/ static int drbg_fips_continuous_test (struct drbg_state *drbg,const unsigned char *entropy) + __must_hold(&drbg->drbg_mutex) {unsigned short entropylen =drbg_sec_strength (drbg->core->flags);int ret =0 ;
@@ -1061,6 +1062,7 @@ static inline int __drbg_seed(struct drbg_state *drbg, struct list_head *seed,static inline int drbg_get_random_bytes (struct drbg_state *drbg,unsigned char *entropy,unsigned int entropylen) + __must_hold(&drbg->drbg_mutex) {int ret;
@@ -1075,6 +1077,7 @@ static inline int drbg_get_random_bytes(struct drbg_state *drbg, }static int drbg_seed_from_random (struct drbg_state *drbg) + __must_hold(&drbg->drbg_mutex) {struct drbg_string data;LIST_HEAD (seedlist);
@@ -1132,6 +1135,7 @@ static bool drbg_nopr_reseed_interval_elapsed(struct drbg_state *drbg)*/ static int drbg_seed (struct drbg_state *drbg,struct drbg_string *pers,bool reseed) + __must_hold(&drbg->drbg_mutex) {int ret;unsigned char entropy[((32 +16 ) *2 )];
@@ -1368,6 +1372,7 @@ static inline int drbg_alloc_state(struct drbg_state *drbg)static int drbg_generate (struct drbg_state *drbg,unsigned char *buf,unsigned int buflen,struct drbg_string *addtl) + __must_hold(&drbg->drbg_mutex) {int len =0 ;LIST_HEAD (addtllist);
crypto/internal.h +1 -1
@@ -61,8 +61,8 @@ enum {/* Maximum number of (rtattr) parameters for each template. */ #define CRYPTO_MAX_ATTRS 32 -extern struct list_head crypto_alg_list;extern struct rw_semaphore crypto_alg_sem; +extern struct list_head crypto_alg_list __guarded_by(&crypto_alg_sem);extern struct blocking_notifier_head crypto_chain;int alg_test (const char *driver,const char *alg,u32 type,u32 mask);
crypto/proc.c +3 -0
@@ -19,17 +19,20 @@#include "internal.h" static void *c_start (struct seq_file *m,loff_t *pos) + __acquires_shared(&crypto_alg_sem) {down_read (&crypto_alg_sem);return seq_list_start (&crypto_alg_list, *pos); }static void *c_next (struct seq_file *m,void *p,loff_t *pos) + __must_hold_shared(&crypto_alg_sem) {return seq_list_next (p, &crypto_alg_list, pos); }static void c_stop (struct seq_file *m,void *p) + __releases_shared(&crypto_alg_sem) {up_read (&crypto_alg_sem); }
crypto/scompress.c +12 -12
@@ -28,8 +28,8 @@struct scomp_scratch {spinlock_t lock;union { -void *src; -unsigned long saddr; + void *src __guarded_by(&lock); + unsigned long saddr __guarded_by(&lock); }; };
@@ -38,8 +38,8 @@ static DEFINE_PER_CPU(struct scomp_scratch, scomp_scratch) = { };static const struct crypto_type crypto_scomp_type; -static int scomp_scratch_users;static DEFINE_MUTEX (scomp_lock); +static int scomp_scratch_users __guarded_by(&scomp_lock);static cpumask_t scomp_scratch_want;static void scomp_scratch_workfn (struct work_struct *work);
@@ -67,6 +67,7 @@ static void crypto_scomp_show(struct seq_file *m, struct crypto_alg *alg) }static void crypto_scomp_free_scratches (void ) +__context_unsafe (/* frees @scratch */ ) {struct scomp_scratch *scratch;int i;
@@ -101,7 +102,7 @@ static void scomp_scratch_workfn(struct work_struct *work)struct scomp_scratch *scratch; scratch =per_cpu_ptr (&scomp_scratch, cpu); -if (scratch->src) +if (context_unsafe (scratch->src))continue ;if (scomp_alloc_scratch (scratch, cpu))break ;
@@ -111,6 +112,7 @@ static void scomp_scratch_workfn(struct work_struct *work) }static int crypto_scomp_alloc_scratches (void ) +__context_unsafe (/* allocates @scratch */ ) {unsigned int i =cpumask_first (cpu_possible_mask);struct scomp_scratch *scratch;
@@ -139,7 +141,8 @@ static int crypto_scomp_init_tfm(struct crypto_tfm *tfm)return ret; } -static struct scomp_scratch *scomp_lock_scratch (void )__acquires (scratch) +#define scomp_lock_scratch (...) __acquire_ret(_scomp_lock_scratch(__VA_ARGS__), &__ret->lock) +static struct scomp_scratch *_scomp_lock_scratch (void ) __acquires_ret {int cpu =raw_smp_processor_id ();struct scomp_scratch *scratch;
@@ -159,7 +162,7 @@ static struct scomp_scratch *scomp_lock_scratch(void) __acquires(scratch) }static inline void scomp_unlock_scratch (struct scomp_scratch *scratch) -__releases (scratch) + __releases(&scratch->lock) {spin_unlock (&scratch->lock); }
@@ -171,8 +174,6 @@ static int scomp_acomp_comp_decomp(struct acomp_req *req, int dir)bool src_isvirt =acomp_request_src_isvirt (req);bool dst_isvirt =acomp_request_dst_isvirt (req);struct crypto_scomp *scomp = *tfm_ctx; -struct crypto_acomp_stream *stream; -struct scomp_scratch *scratch;unsigned int slen = req->slen;unsigned int dlen = req->dlen;struct page *spage, *dpage;
@@ -232,13 +233,12 @@ static int scomp_acomp_comp_decomp(struct acomp_req *req, int dir) }while (0 ); } - stream =crypto_acomp_lock_stream_bh (&crypto_scomp_alg (scomp)->streams); +struct crypto_acomp_stream *stream =crypto_acomp_lock_stream_bh (&crypto_scomp_alg (scomp)->streams);if (!src_isvirt && !src) { -const u8 *src; +struct scomp_scratch *scratch =scomp_lock_scratch (); +const u8 *src = scratch->src; - scratch =scomp_lock_scratch (); - src = scratch->src;memcpy_from_sglist (scratch->src, req->src,0 , slen);if (dir)
include/crypto/internal/acompress.h +4 -3
@@ -191,11 +191,12 @@ static inline bool crypto_acomp_req_virt(struct crypto_acomp *tfm)void crypto_acomp_free_streams (struct crypto_acomp_streams *s);int crypto_acomp_alloc_streams (struct crypto_acomp_streams *s); -struct crypto_acomp_stream *crypto_acomp_lock_stream_bh ( -struct crypto_acomp_streams *s)__acquires (stream); +#define crypto_acomp_lock_stream_bh (...) __acquire_ret(_crypto_acomp_lock_stream_bh(__VA_ARGS__), &__ret->lock); +struct crypto_acomp_stream *_crypto_acomp_lock_stream_bh ( +struct crypto_acomp_streams *s) __acquires_ret;static inline void crypto_acomp_unlock_stream_bh ( -struct crypto_acomp_stream *stream)__releases (stream) + struct crypto_acomp_stream *stream) __releases(&stream->lock) {spin_unlock_bh (&stream->lock); }
include/crypto/internal/engine.h +1 -1
@@ -45,7 +45,7 @@ struct crypto_engine {struct list_head list;spinlock_t queue_lock; -struct crypto_queue queue; + struct crypto_queue queue __guarded_by(&queue_lock);struct device *dev;struct kthread_worker *kworker;
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Marco Elver
maintainerPATCH v4 35/35 sched: Enable context analysis for core.c and fair.c
In reply to Marco ElverThis demonstrates a larger conversion to use Clang's context analysis. The benefit is additional static checking of locking rules, along with better documentation.
Notably, kernel/sched contains sufficiently complex synchronization patterns, and application to core.c & fair.c demonstrates that the latest Clang version has become powerful enough to start applying this to more complex subsystems (with some modest annotations and changes).
---
v4:
* Rename capability -> context analysis.
v3:
* New patch.
--- include/linux/sched.h | 6 +- include/linux/sched/signal.h | 4 +- include/linux/sched/task.h | 5 +- include/linux/sched/wake_q.h | 3 + kernel/sched/Makefile | 3 + kernel/sched/core.c | 89 ++++++++++++------ kernel/sched/fair.c | 9 +- kernel/sched/sched.h | 110 +++++++++++++++-------- scripts/context-analysis-suppression.txt | 1 + 9 files changed, 162 insertions(+), 68 deletions(-)
include/linux/sched.h +3 -3
@@ -2108,9 +2108,9 @@ static inline int _cond_resched(void)_cond_resched (); \ }) -extern int __cond_resched_lock (spinlock_t *lock); -extern int __cond_resched_rwlock_read (rwlock_t *lock); -extern int __cond_resched_rwlock_write (rwlock_t *lock); +extern int __cond_resched_lock(spinlock_t *lock) __must_hold(lock); +extern int __cond_resched_rwlock_read(rwlock_t *lock) __must_hold_shared(lock); +extern int __cond_resched_rwlock_write(rwlock_t *lock) __must_hold(lock);#define MIGHT_RESCHED_RCU_SHIFT 8#define MIGHT_RESCHED_PREEMPT_MASK ((1U << MIGHT_RESCHED_RCU_SHIFT) - 1)
include/linux/sched/signal.h +3 -1
@@ -738,10 +738,12 @@ static inline int thread_group_empty(struct task_struct *p) (thread_group_leader(p) && !thread_group_empty(p))extern struct sighand_struct *lock_task_sighand (struct task_struct *task, -unsigned long *flags); +unsigned long *flags) + __acquires(&task->sighand->siglock);static inline void unlock_task_sighand (struct task_struct *task,unsigned long *flags) + __releases(&task->sighand->siglock) {spin_unlock_irqrestore (&task->sighand->siglock, *flags); }
include/linux/sched/task.h +4 -1
@@ -214,15 +214,18 @@ static inline struct vm_struct *task_stack_vm_area(const struct task_struct *t)* write_lock_irq(&tasklist_lock), neither inside nor outside. */ static inline void task_lock (struct task_struct *p) + __acquires(&p->alloc_lock) {spin_lock (&p->alloc_lock); }static inline void task_unlock (struct task_struct *p) + __releases(&p->alloc_lock) {spin_unlock (&p->alloc_lock); } -DEFINE_GUARD(task_lock, struct task_struct *, task_lock(_T), task_unlock(_T)) +DEFINE_LOCK_GUARD_1(task_lock, struct task_struct, task_lock(_T->lock), task_unlock(_T->lock)) +DECLARE_LOCK_GUARD_1_ATTRS(task_lock, __assumes_ctx_guard(_T->alloc_lock), /* */)#endif /* _LINUX_SCHED_TASK_H */
include/linux/sched/wake_q.h +3 -0
@@ -66,6 +66,7 @@ extern void wake_up_q(struct wake_q_head *head);/* Spin unlock helpers to unlock and call wake_up_q with preempt disabled */ static inline void raw_spin_unlock_wake (raw_spinlock_t *lock,struct wake_q_head *wake_q) +__releases (lock) {guard (preempt)();raw_spin_unlock (lock);
@@ -77,6 +78,7 @@ void raw_spin_unlock_wake(raw_spinlock_t *lock, struct wake_q_head *wake_q)static inline void raw_spin_unlock_irq_wake (raw_spinlock_t *lock,struct wake_q_head *wake_q) +__releases (lock) {guard (preempt)();raw_spin_unlock_irq (lock);
@@ -89,6 +91,7 @@ void raw_spin_unlock_irq_wake(raw_spinlock_t *lock, struct wake_q_head *wake_q)static inline void raw_spin_unlock_irqrestore_wake (raw_spinlock_t *lock,unsigned long flags,struct wake_q_head *wake_q) +__releases (lock) {guard (preempt)();raw_spin_unlock_irqrestore (lock, flags);
kernel/sched/Makefile +3 -0
@@ -1,5 +1,8 @@ # SPDX-License-Identifier: GPL-2.0 +CONTEXT_ANALYSIS_core.o := y +CONTEXT_ANALYSIS_fair.o := y + # The compilers are complaining about unused variables inside an if(0) scope # block. This is daft, shut them up. ccflags-y += $(call cc-disable-warning, unused-but-set-variable)
kernel/sched/core.c +62 -27
256 lines not on this page · raw message
kernel/sched/fair.c +8 -1
@@ -2876,6 +2876,7 @@ static int preferred_group_nid(struct task_struct *p, int nid) }static void task_numa_placement (struct task_struct *p) +__context_unsafe (/* conditional locking */ ) {int seq, nid, max_nid =NUMA_NO_NODE ;unsigned long max_faults =0 ;
@@ -4803,7 +4804,8 @@ static inline unsigned long cfs_rq_load_avg(struct cfs_rq *cfs_rq)return cfs_rq->avg.load_avg; } -static int sched_balance_newidle (struct rq *this_rq,struct rq_flags *rf); +static int sched_balance_newidle(struct rq *this_rq, struct rq_flags *rf) + __must_hold(__rq_lockp(this_rq));static inline unsigned long task_util (struct task_struct *p) {
@@ -6229,6 +6231,7 @@ static bool distribute_cfs_runtime(struct cfs_bandwidth *cfs_b)* used to track this state. */ static int do_sched_cfs_period_timer (struct cfs_bandwidth *cfs_b,int overrun,unsigned long flags) + __must_hold(&cfs_b->lock) {int throttled;
@@ -8714,6 +8717,7 @@ static void set_cpus_allowed_fair(struct task_struct *p, struct affinity_contextstatic int balance_fair (struct rq *rq,struct task_struct *prev,struct rq_flags *rf) +__must_hold (__rq_lockp (rq)) {if (sched_fair_runnable (rq))return 1 ;
@@ -8867,6 +8871,7 @@ static void set_next_task_fair(struct rq *rq, struct task_struct *p, bool first)struct task_struct *pick_next_task_fair (struct rq *rq,struct task_struct *prev,struct rq_flags *rf) +__must_hold (__rq_lockp (rq)) {struct sched_entity *se;struct task_struct *p;
@@ -8953,6 +8958,7 @@ pick_next_task_fair(struct rq *rq, struct task_struct *prev, struct rq_flags *rf }static struct task_struct *__pick_next_task_fair (struct rq *rq,struct task_struct *prev) +__must_hold (__rq_lockp (rq)) {return pick_next_task_fair (rq, prev,NULL ); }
@@ -12784,6 +12790,7 @@ static inline void nohz_newidle_balance(struct rq *this_rq) { }* > 0 - success, new (fair) tasks present */ static int sched_balance_newidle (struct rq *this_rq,struct rq_flags *rf) +__must_hold (__rq_lockp (this_rq)) {unsigned long next_balance = jiffies +HZ ;int this_cpu = this_rq->cpu;
kernel/sched/sched.h +75 -35
313 lines not on this page · raw message
scripts/context-analysis-suppression.txt +1 -0
@@ -26,6 +26,7 @@ src:*include/linux/refcount.h=emit src:*include/linux/rhashtable.h=emit src:*include/linux/rwlock*.h=emit src:*include/linux/rwsem.h=emit +src:*include/linux/sched*=emit src:*include/linux/seqlock*.h=emit src:*include/linux/spinlock*.h=emit src:*include/linux/srcu*.h=emit
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Peter Zijlstra
maintainerRe: [PATCH v4 06/35] cleanup: Basic compatibility with context analysis
In reply to Marco ElverQuoted 24 lines · Marco Elver
Introduce basic compatibility with
cleanup.hinfrastructure: introduce DECLARE_LOCK_GUARD_*_ATTRS() helpers to add attributes to constructors and destructors respectively.Note: Due to the scoped cleanup helpers used for lock guards wrapping acquire and release around their own constructors/destructors that store pointers to the passed locks in a separate struct, we currently cannot accurately annotate *destructors* which lock was released. While it's possible to annotate the constructor to say which lock was acquired, that alone would result in false positives claiming the lock was not released on function return.
Instead, to avoid false positives, we can claim that the constructor "assumes" that the taken lock is held via
__assumes_ctx_guard().This will ensure we can still benefit from the analysis where scoped guards are used to protect access to guarded variables, while avoiding false positives. The only downside are false negatives where we might accidentally lock the same lock again:
raw_spin_lock(&my_lock); ... guard(raw_spinlock)(&my_lock); // no warning
Quoted 5 lines
Arguably, lockdep will immediately catch issues like this.
While Clang's analysis supports scoped guards in C++ [1], there's no way to apply this to C right now. Better support for Linux's scoped guard design could be added in future if deemed critical.
Moo, so the alias analysis didn't help here?
Peter Zijlstra
maintainerRe: [PATCH v4 06/35] cleanup: Basic compatibility with context analysis
In reply to Marco Elverinclude/linux/cleanup.h static inline class_##_name##_t class_##_name##_constructor(void) \ · line 508
Quoted 7 lines · Marco Elver
include/linux/cleanup.h +7
-0+#define DECLARE_LOCK_GUARD_0_ATTRS (_name, _lock, _unlock) \ +static inline class_##_name##_t class_##_name##_constructor(void) _lock;\ +static inline void class_##_name##_destructor(class_##_name##_t *_T) _unlock; + +#define DECLARE_LOCK_GUARD_1_ATTRS (_name, _lock, _unlock) \ +static inline class_##_name##_t class_##_name##_constructor(lock_##_name##_t *_T) _lock;\ +static inline void class_##_name##_destructor(class_##_name##_t *_T) _unlock;
When you rebase this series; you'll find cleanup.h moved to __always_inline (because compilers are weird) and these should probably also switch.
Peter Zijlstra
maintainerRe: [PATCH v4 06/35] cleanup: Basic compatibility with context analysis
In reply to Marco ElverQuoted 12 lines · Marco Elver
Introduce basic compatibility with
cleanup.hinfrastructure: introduce DECLARE_LOCK_GUARD_*_ATTRS() helpers to add attributes to constructors and destructors respectively.Note: Due to the scoped cleanup helpers used for lock guards wrapping acquire and release around their own constructors/destructors that store pointers to the passed locks in a separate struct, we currently cannot accurately annotate *destructors* which lock was released. While it's possible to annotate the constructor to say which lock was acquired, that alone would result in false positives claiming the lock was not released on function return.
Quoted 2 lines
Instead, to avoid false positives, we can claim that the constructor "assumes" that the taken lock is held via
__assumes_ctx_guard().
What is the scope of this __assumes_ctx stuff? The way it is used in the lock initializes seems to suggest it escapes scope. But then something like:
scoped_guard (mutex, &foo) {
...
}
// context analysis would still assume foo heldis somewhat sub-optimal, no?
Quoted 2 lines
Better support for Linux's scoped guard design could be added in future if deemed critical.
I would think so, per the above I don't think this is 'right'.
Marco Elver
maintainerRe: [PATCH v4 06/35] cleanup: Basic compatibility with context analysis
Quoted 14 lines · Peter Zijlstra
Quoted 12 lines · Marco Elver
Introduce basic compatibility with
cleanup.hinfrastructure: introduce DECLARE_LOCK_GUARD_*_ATTRS() helpers to add attributes to constructors and destructors respectively.Note: Due to the scoped cleanup helpers used for lock guards wrapping acquire and release around their own constructors/destructors that store pointers to the passed locks in a separate struct, we currently cannot accurately annotate *destructors* which lock was released. While it's possible to annotate the constructor to say which lock was acquired, that alone would result in false positives claiming the lock was not released on function return.
Quoted 5 lines
Quoted 2 lines
Instead, to avoid false positives, we can claim that the constructor "assumes" that the taken lock is held via
__assumes_ctx_guard().Moo, so the alias analysis didn't help here?
Unfortunately no, because intra-procedural alias analysis for these kinds of diagnostics is infeasible. The compiler can only safely perform alias analysis for local variables that do not escape the function. The layers of wrapping here make this a bit tricky.
The compiler (unlike before) is now able to deal with things like:
{
spinlock_t *lock_scope __attribute__((cleanup(spin_unlock))) = &lock; spin_lock(&lock); // lock through &lock
... critical section ...
} // unlock through lock_scope (alias -> &lock)
Quoted 3 lines
What is the scope of this
__assumes_ctxstuff? The way it is used in the lock initializes seems to suggest it escapes scope. But then something like:
It escapes scope.
Quoted 6 lines
scoped_guard (mutex, &foo) { ... } // context analysis would still assume foo heldis somewhat sub-optimal, no?
Correct. We're trading false negatives over false positives at this point, just to get things to compile cleanly.
Quoted 4 lines
Quoted 2 lines
Better support for Linux's scoped guard design could be added in future if deemed critical.
I would think so, per the above I don't think this is 'right'.
It's not sound, but we'll avoid false positives for the time being. Maybe we can wrangle the jigsaw of macros to let it correctly acquire and then release (via a 2nd cleanup function), it might be as simple as marking the 'constructor' with the right __acquires(..), and then have a 2nd __attribute__((cleanup)) variable that just does a no-op release via __release(..) so we get the already supported pattern above.
Peter Zijlstra
maintainerRe: [PATCH v4 06/35] cleanup: Basic compatibility with context analysis
Quoted 44 lines · Marco Elver
Quoted 14 lines · Peter Zijlstra
Quoted 12 lines · Marco Elver
Introduce basic compatibility with
cleanup.hinfrastructure: introduce DECLARE_LOCK_GUARD_*_ATTRS() helpers to add attributes to constructors and destructors respectively.Note: Due to the scoped cleanup helpers used for lock guards wrapping acquire and release around their own constructors/destructors that store pointers to the passed locks in a separate struct, we currently cannot accurately annotate *destructors* which lock was released. While it's possible to annotate the constructor to say which lock was acquired, that alone would result in false positives claiming the lock was not released on function return.
Quoted 5 lines
Quoted 2 lines
Instead, to avoid false positives, we can claim that the constructor "assumes" that the taken lock is held via
__assumes_ctx_guard().Moo, so the alias analysis didn't help here?
Unfortunately no, because intra-procedural alias analysis for these kinds of diagnostics is infeasible. The compiler can only safely perform alias analysis for local variables that do not escape the function. The layers of wrapping here make this a bit tricky.
The compiler (unlike before) is now able to deal with things like:
{
spinlock_t*lock_scope__attribute__((cleanup(spin_unlock))) = &lock;spin_lock(&lock); // lock through &lock
... critical section ...
} // unlock throughlock_scope(alias -> &lock)Quoted 3 lines
What is the scope of this
__assumes_ctxstuff? The way it is used in the lock initializes seems to suggest it escapes scope. But then something like:It escapes scope.
Quoted 5 lines
scoped_guard (mutex, &foo) { ... } // context analysis would still assume foo held
Quoted 4 lines
Quoted 1 line
is somewhat sub-optimal, no?
Correct. We're trading false negatives over false positives at this point, just to get things to compile cleanly.
Right, and this all 'works' right up to the point someone sticks a must_not_hold somewhere.
Quoted 5 lines
Quoted 4 lines
Quoted 2 lines
Better support for Linux's scoped guard design could be added in future if deemed critical.
I would think so, per the above I don't think this is 'right'.
Quoted 7 lines
It's not sound, but we'll avoid false positives for the time being. Maybe we can wrangle the jigsaw of macros to let it correctly acquire and then release (via a 2nd cleanup function), it might be as simple as marking the 'constructor' with the right
__acquires(..), and then have a 2nd __attribute__((cleanup)) variable that just does a no-op release via__release(..)so we get the already supported pattern above.
Right, like I mentioned in my previous email; it would be lovely if at the very least __always_inline would get a *very* early pass such that the above could be resolved without inter-procedural bits. I really don't consider an __always_inline as another procedure.
Because as I already noted yesterday, cleanup is now all __always_inline, and as such *should* all end up in the one function.
But yes, if we can get a magical mash-up of __cleanup and __release (let it be knows as __release_on_cleanup ?) that might also work I suppose. But I vastly prefer __always_inline actually 'working' ;-)
Marco Elver
maintainerRe: [PATCH v4 06/35] cleanup: Basic compatibility with context analysis
On Fri, 12 Dec 2025 at 10:43, Peter Zijlstra <[email protected]> wrote:
[..]
Quoted 24 lines
Quoted 2 lines
Correct. We're trading false negatives over false positives at this point, just to get things to compile cleanly.
Right, and this all 'works' right up to the point someone sticks a
must_not_holdsomewhere.Quoted 5 lines
Quoted 4 lines
Quoted 2 lines
Better support for Linux's scoped guard design could be added in future if deemed critical.
I would think so, per the above I don't think this is 'right'.
Quoted 7 lines
It's not sound, but we'll avoid false positives for the time being. Maybe we can wrangle the jigsaw of macros to let it correctly acquire and then release (via a 2nd cleanup function), it might be as simple as marking the 'constructor' with the right
__acquires(..), and then have a 2nd __attribute__((cleanup)) variable that just does a no-op release via__release(..)so we get the already supported pattern above.Right, like I mentioned in my previous email; it would be lovely if at the very least
__always_inlinewould get a *very* early pass such that the above could be resolved without inter-procedural bits. I really don't consider an__always_inlineas another procedure.
Quoted 6 lines
Because as I already noted yesterday, cleanup is now all
__always_inline, and as such *should* all end up in the one function.But yes, if we can get a magical mash-up of
__cleanupand__release(let it be knows as__release_on_cleanup?) that might also work I suppose. But I vastly prefer__always_inlineactually 'working' ;-)
The truth is that __always_inline working in this way is currently infeasible. Clang and LLVM's architecture simply disallow this today:
the semantic analysis that -Wthread-safety does happens over the AST, whereas always_inline is processed by early passes in the middle-end already within LLVM's pipeline, well after semantic analysis. There's a complexity budget limit for semantic analysis (type checking, warnings, assorted other errors), and path-sensitive & intra-procedural analysis over the plain AST is outside that budget. Which is why tools like clang-analyzer exist (symbolic execution), where it's possible to afford that complexity since that's not something that runs for a normal compile.
I think I've pushed the current version of Clang's -Wthread-safety already far beyond what folks were thinking is possible (a variant of alias analysis), but even my healthy disregard for the impossible tells me that making path-sensitive intra-procedural analysis even if just for __always_inline functions is quite possibly a fool's errand.
So either we get it to work with what we have, or give up.
Thanks,
-- Marco
Peter Zijlstra
maintainerRe: [PATCH v4 06/35] cleanup: Basic compatibility with context analysis
Quoted 45 lines · Marco Elver
On Fri, 12 Dec 2025 at 10:43, Peter Zijlstra <[email protected]> wrote:
[..]Quoted 24 lines
Quoted 2 lines
Correct. We're trading false negatives over false positives at this point, just to get things to compile cleanly.
Right, and this all 'works' right up to the point someone sticks a
must_not_holdsomewhere.Quoted 5 lines
Quoted 4 lines
Quoted 2 lines
Better support for Linux's scoped guard design could be added in future if deemed critical.
I would think so, per the above I don't think this is 'right'.
Quoted 7 lines
It's not sound, but we'll avoid false positives for the time being. Maybe we can wrangle the jigsaw of macros to let it correctly acquire and then release (via a 2nd cleanup function), it might be as simple as marking the 'constructor' with the right
__acquires(..), and then have a 2nd __attribute__((cleanup)) variable that just does a no-op release via__release(..)so we get the already supported pattern above.Right, like I mentioned in my previous email; it would be lovely if at the very least
__always_inlinewould get a *very* early pass such that the above could be resolved without inter-procedural bits. I really don't consider an__always_inlineas another procedure.Quoted 6 lines
Because as I already noted yesterday, cleanup is now all
__always_inline, and as such *should* all end up in the one function.But yes, if we can get a magical mash-up of
__cleanupand__release(let it be knows as__release_on_cleanup?) that might also work I suppose. But I vastly prefer__always_inlineactually 'working' ;-)The truth is that
__always_inlineworking in this way is currently infeasible. Clang and LLVM's architecture simply disallow this today:
the semantic analysis that -Wthread-safety does happens over the AST, whereasalways_inlineis processed by early passes in the middle-end already within LLVM's pipeline, well after semantic analysis. There's a complexity budget limit for semantic analysis (type checking, warnings, assorted other errors), and path-sensitive & intra-procedural analysis over the plain AST is outside that budget. Which is why tools like clang-analyzer exist (symbolic execution), where it's possible to afford that complexity since that's not something that runs for a normal compile.
Quoted 5 lines
I think I've pushed the current version of Clang's -Wthread-safety already far beyond what folks were thinking is possible (a variant of alias analysis), but even my healthy disregard for the impossible tells me that making path-sensitive intra-procedural analysis even if just for
__always_inlinefunctions is quite possibly a fool's errand.
Well, I had to propose it. Gotta push the envelope :-)
Quoted 1 line
So either we get it to work with what we have, or give up.
So I think as is, we can start. But I really do want the cleanup thing sorted, even if just with that __release_on_cleanup mashup or so.
Marco Elver
maintainerRe: [PATCH v4 06/35] cleanup: Basic compatibility with context analysis
Quoted 52 lines · Peter Zijlstra
Quoted 45 lines · Marco Elver
On Fri, 12 Dec 2025 at 10:43, Peter Zijlstra <[email protected]> wrote:
[..]Quoted 24 lines
Quoted 2 lines
Correct. We're trading false negatives over false positives at this point, just to get things to compile cleanly.
Right, and this all 'works' right up to the point someone sticks a
must_not_holdsomewhere.Quoted 5 lines
Quoted 4 lines
Quoted 2 lines
Better support for Linux's scoped guard design could be added in future if deemed critical.
I would think so, per the above I don't think this is 'right'.
Quoted 7 lines
It's not sound, but we'll avoid false positives for the time being. Maybe we can wrangle the jigsaw of macros to let it correctly acquire and then release (via a 2nd cleanup function), it might be as simple as marking the 'constructor' with the right
__acquires(..), and then have a 2nd __attribute__((cleanup)) variable that just does a no-op release via__release(..)so we get the already supported pattern above.Right, like I mentioned in my previous email; it would be lovely if at the very least
__always_inlinewould get a *very* early pass such that the above could be resolved without inter-procedural bits. I really don't consider an__always_inlineas another procedure.Quoted 6 lines
Because as I already noted yesterday, cleanup is now all
__always_inline, and as such *should* all end up in the one function.But yes, if we can get a magical mash-up of
__cleanupand__release(let it be knows as__release_on_cleanup?) that might also work I suppose. But I vastly prefer__always_inlineactually 'working' ;-)The truth is that
__always_inlineworking in this way is currently infeasible. Clang and LLVM's architecture simply disallow this today:
the semantic analysis that -Wthread-safety does happens over the AST, whereasalways_inlineis processed by early passes in the middle-end already within LLVM's pipeline, well after semantic analysis. There's a complexity budget limit for semantic analysis (type checking, warnings, assorted other errors), and path-sensitive & intra-procedural analysis over the plain AST is outside that budget. Which is why tools like clang-analyzer exist (symbolic execution), where it's possible to afford that complexity since that's not something that runs for a normal compile.Quoted 5 lines
I think I've pushed the current version of Clang's -Wthread-safety already far beyond what folks were thinking is possible (a variant of alias analysis), but even my healthy disregard for the impossible tells me that making path-sensitive intra-procedural analysis even if just for
__always_inlinefunctions is quite possibly a fool's errand.
Quoted 6 lines
Well, I had to propose it. Gotta push the envelope :-)
Quoted 1 line
So either we get it to work with what we have, or give up.
So I think as is, we can start. But I really do want the cleanup thing sorted, even if just with that
__release_on_cleanupmashup or so.
Working on rebasing this to v6.19-rc1 and saw this new scoped seqlock abstraction. For that one I was able to make it work like I thought we could (below). Some awkwardness is required to make it work in for-loops, which only let you define variables with the same type.
For <linux/cleanup.h> it needs some more thought due to extra levels of indirection.
------ >8 ------
include/linux/seqlock.h +12 -1
@@ -1249,6 +1249,7 @@ struct ss_tmp { }; static __always_inline void __scoped_seqlock_cleanup(struct ss_tmp *sst) + __no_context_analysis {if (sst->lock)spin_unlock (sst->lock);
@@ -1278,6 +1279,7 @@ extern void __scoped_seqlock_bug(void); static __always_inline void__scoped_seqlock_next (struct ss_tmp *sst,seqlock_t *lock,enum ss_state target) + __no_context_analysis {switch (sst->state) {case ss_done:
@@ -1320,9 +1322,18 @@ __scoped_seqlock_next(struct ss_tmp *sst, seqlock_t *lock, enum ss_state target) } } +/* +* Context analysis helper to release seqlock at the end of the for-scope; the +* alias analysis of the compiler will recognize that the pointer @s is is an +* alias to @_seqlock passed to read_seqbegin(_seqlock) below. +*/ +static __always_inline void __scoped_seqlock_cleanup_ctx(struct ss_tmp **s) + __releases_shared(*((seqlock_t **)s)) __no_context_analysis {} +#define __scoped_seqlock_read (_seqlock, _target, _s) \ for (struct ss_tmp _s __cleanup(__scoped_seqlock_cleanup) = \ - { .state = ss_lockless, .data = read_seqbegin(_seqlock) }; \ + { .state = ss_lockless, .data = read_seqbegin(_seqlock) }, \ + *__UNIQUE_ID(ctx) __cleanup(__scoped_seqlock_cleanup_ctx) = (struct ss_tmp *)_seqlock; \ _s.state != ss_done; \ __scoped_seqlock_next(&_s, _seqlock, _target))
lib/test_context-analysis.c +7 -0
@@ -261,6 +261,13 @@ static void __used test_seqlock_writer(struct test_seqlock_data *d)write_sequnlock_irqrestore (&d->sl, flags); } +static void __used test_seqlock_scoped (struct test_seqlock_data *d) +{ + scoped_seqlock_read (&d->sl, ss_lockless) { + (void )d->counter; + } +} +struct test_rwsem_data {struct rw_semaphore sem; int counter __guarded_by(&sem);
Marco Elver
maintainerRe: [PATCH v4 06/35] cleanup: Basic compatibility with context analysis
Quoted 61 lines · Marco Elver
Quoted 52 lines · Peter Zijlstra
Quoted 45 lines · Marco Elver
On Fri, 12 Dec 2025 at 10:43, Peter Zijlstra <[email protected]> wrote:
[..]Quoted 24 lines
Quoted 2 lines
Correct. We're trading false negatives over false positives at this point, just to get things to compile cleanly.
Right, and this all 'works' right up to the point someone sticks a
must_not_holdsomewhere.Quoted 5 lines
Quoted 4 lines
Quoted 2 lines
Better support for Linux's scoped guard design could be added in future if deemed critical.
I would think so, per the above I don't think this is 'right'.
Quoted 7 lines
It's not sound, but we'll avoid false positives for the time being. Maybe we can wrangle the jigsaw of macros to let it correctly acquire and then release (via a 2nd cleanup function), it might be as simple as marking the 'constructor' with the right
__acquires(..), and then have a 2nd __attribute__((cleanup)) variable that just does a no-op release via__release(..)so we get the already supported pattern above.Right, like I mentioned in my previous email; it would be lovely if at the very least
__always_inlinewould get a *very* early pass such that the above could be resolved without inter-procedural bits. I really don't consider an__always_inlineas another procedure.Quoted 6 lines
Because as I already noted yesterday, cleanup is now all
__always_inline, and as such *should* all end up in the one function.But yes, if we can get a magical mash-up of
__cleanupand__release(let it be knows as__release_on_cleanup?) that might also work I suppose. But I vastly prefer__always_inlineactually 'working' ;-)The truth is that
__always_inlineworking in this way is currently infeasible. Clang and LLVM's architecture simply disallow this today:
the semantic analysis that -Wthread-safety does happens over the AST, whereasalways_inlineis processed by early passes in the middle-end already within LLVM's pipeline, well after semantic analysis. There's a complexity budget limit for semantic analysis (type checking, warnings, assorted other errors), and path-sensitive & intra-procedural analysis over the plain AST is outside that budget. Which is why tools like clang-analyzer exist (symbolic execution), where it's possible to afford that complexity since that's not something that runs for a normal compile.Quoted 5 lines
I think I've pushed the current version of Clang's -Wthread-safety already far beyond what folks were thinking is possible (a variant of alias analysis), but even my healthy disregard for the impossible tells me that making path-sensitive intra-procedural analysis even if just for
__always_inlinefunctions is quite possibly a fool's errand.Quoted 6 lines
Well, I had to propose it. Gotta push the envelope :-)
Quoted 1 line
So either we get it to work with what we have, or give up.
So I think as is, we can start. But I really do want the cleanup thing sorted, even if just with that
__release_on_cleanupmashup or so.
Quoted 7 lines
Working on rebasing this to v6.19-rc1 and saw this new scoped seqlock abstraction. For that one I was able to make it work like I thought we could (below). Some awkwardness is required to make it work in for-loops, which only let you define variables with the same type.
For <
linux/cleanup.h> it needs some more thought due to extra levels of indirection.
For cleanup.h, the problem is that to instantiate we use "guard(class)(args..)". If it had been designed as "guard(class, args...)", i.e. just use __VA_ARGS__ explicitly instead of the implicit 'args...', it might have been possible to add a second cleanup variable to do the same (with some additional magic to extract the first arg if one exists). Unfortunately, the use of the current guard()() idiom has become so pervasive that this is a bigger refactor. I'm going to leave cleanup.h as-is for now, if we think we want to give this a go in the current state.
One observation from the rebase: Generally synchronization primitives do not change much and the annotations are relatively stable, but e.g. RCU & sched (latter is optional and depends on the sched-enablement patch) receive disproportionally more changes, and while new annotations required for v6.19-rc1 were trivial, it does require compiling with a Clang version that does produce the warnings to notice.
While Clang 22-dev is being tested on CI, I doubt maintainers already use it, so it's possible we'll see some late warnings due to missing annotations when things hit -next. This might be an acceptable churn cost, if we think the outcome is worthwhile. Things should get better when Clang 22 is released properly, but until then things might be a little bumpy if there are large changes across the core synchronization primitives.
Thanks,
-- Marco
Marco Elver
maintainerRe: [PATCH v4 06/35] cleanup: Basic compatibility with context analysis
On Mon, Dec 15, 2025 at 04:53PM +0100, Marco Elver wrote:
[..]
Quoted 11 lines
Quoted 10 lines
Quoted 2 lines
So I think as is, we can start. But I really do want the cleanup thing sorted, even if just with that
__release_on_cleanupmashup or so.Working on rebasing this to v6.19-rc1 and saw this new scoped seqlock abstraction. For that one I was able to make it work like I thought we could (below). Some awkwardness is required to make it work in for-loops, which only let you define variables with the same type.
For <
linux/cleanup.h> it needs some more thought due to extra levels of indirection.
Quoted 9 lines
For
cleanup.h, the problem is that to instantiate we use "guard(class)(args..)". If it had been designed as "guard(class, args...)", i.e. just use__VA_ARGS__explicitly instead of the implicit 'args...', it might have been possible to add a second cleanup variable to do the same (with some additional magic to extract the first arg if one exists). Unfortunately, the use of the current guard()() idiom has become so pervasive that this is a bigger refactor. I'm going to leavecleanup.has-is for now, if we think we want to give this a go in the current state.
Alright, this can work, but it's not that ergonomic as I'd hoped (see below): we can redefine class_<name>_constructor to append another cleanup variable. With enough documentation, this might be workable.
WDYT?
------ >8 ------
include/linux/cleanup.h +4 -1
@@ -518,7 +518,10 @@ static inline void class_##_name##_destructor(class_##_name##_t *_T) _unlock;#define DECLARE_LOCK_GUARD_1_ATTRS (_name, _lock, _unlock) \ static inline class_##_name##_t class_##_name##_constructor(lock_##_name##_t *_T) _lock;\ -static inline void class_##_name##_destructor(class_##_name##_t *_T) _unlock; +static __always_inline void __class_##_name##_cleanup_ctx(class_##_name##_t **_T) \ + __no_context_analysis _unlock {} +#define WITH_LOCK_GUARD_1_ATTRS (_name, _T) class_##_name##_constructor(_T), \ + *__UNIQUE_ID(cleanup_ctx) __cleanup(__class_##_name##_cleanup_ctx) = (void *)(_T)#define DEFINE_LOCK_GUARD_1 (_name, _type, _lock, _unlock, ...) \ __DEFINE_CLASS_IS_CONDITIONAL(_name, false); \
include/linux/mutex.h +6 -3
@@ -255,9 +255,12 @@ DEFINE_LOCK_GUARD_1(mutex, struct mutex, mutex_lock(_T->lock), mutex_unlock(_T-> DEFINE_LOCK_GUARD_1_COND(mutex, _try, mutex_trylock(_T->lock)) DEFINE_LOCK_GUARD_1_COND(mutex, _intr, mutex_lock_interruptible(_T->lock), _RET == 0) -DECLARE_LOCK_GUARD_1_ATTRS(mutex, __assumes_ctx_lock(_T), /* */) -DECLARE_LOCK_GUARD_1_ATTRS(mutex_try, __assumes_ctx_lock(_T), /* */) -DECLARE_LOCK_GUARD_1_ATTRS(mutex_intr, __assumes_ctx_lock(_T), /* */) +DECLARE_LOCK_GUARD_1_ATTRS(mutex, __acquires(_T), __releases(*(struct mutex **)_T)) +DECLARE_LOCK_GUARD_1_ATTRS(mutex_try, __acquires(_T), __releases(*(struct mutex **)_T)) +DECLARE_LOCK_GUARD_1_ATTRS(mutex_intr, __acquires(_T), __releases(*(struct mutex **)_T)) +#define class_mutex_constructor (_T) WITH_LOCK_GUARD_1_ATTRS(mutex, _T) +#define class_mutex_try_constructor (_T) WITH_LOCK_GUARD_1_ATTRS(mutex_try, _T) +#define class_mutex_intr_constructor (_T) WITH_LOCK_GUARD_1_ATTRS(mutex_intr, _T)extern unsigned long mutex_get_owner (struct mutex *lock);
Marco Elver
maintainerRe: [PATCH v4 06/35] cleanup: Basic compatibility with context analysis
Quoted 23 lines · Marco Elver
On Mon, Dec 15, 2025 at 04:53PM +0100, Marco Elver wrote:
[..]Quoted 11 lines
Quoted 10 lines
Quoted 2 lines
So I think as is, we can start. But I really do want the cleanup thing sorted, even if just with that
__release_on_cleanupmashup or so.Working on rebasing this to v6.19-rc1 and saw this new scoped seqlock abstraction. For that one I was able to make it work like I thought we could (below). Some awkwardness is required to make it work in for-loops, which only let you define variables with the same type.
For <
linux/cleanup.h> it needs some more thought due to extra levels of indirection.Quoted 9 lines
For
cleanup.h, the problem is that to instantiate we use "guard(class)(args..)". If it had been designed as "guard(class, args...)", i.e. just use__VA_ARGS__explicitly instead of the implicit 'args...', it might have been possible to add a second cleanup variable to do the same (with some additional magic to extract the first arg if one exists). Unfortunately, the use of the current guard()() idiom has become so pervasive that this is a bigger refactor. I'm going to leavecleanup.has-is for now, if we think we want to give this a go in the current state.
Quoted 3 lines
Alright, this can work, but it's not that ergonomic as I'd hoped (see below): we can redefine class_<name>_constructor to append another cleanup variable. With enough documentation, this might be workable.
Below is the preview of the complete changes to make the lock guards work properly.
Thanks,
-- Marco
------ >8 ------
include/linux/cleanup.h +34 -1
@@ -516,9 +516,42 @@ static __always_inline class_##_name##_t class_##_name##_constructor(void) \ static inline class_##_name##_t class_##_name##_constructor(void) _lock;\ static inline void class_##_name##_destructor(class_##_name##_t *_T) _unlock; +/* +* To support Context Analysis, we need to allow the compiler to see the +* acquisition and release of the context lock. However, the "cleanup" helpers +* wrap the lock in a struct passed through seperate helper functions, which +* hides the lock alias from the compiler (no inter-procedural analysis). +* +* To make it work, we introduce an explicit alias to the context lock instance +* that is "cleaned" up with a separate cleanup helper. This helper is a dummy +* function that does nothing at runtime, but has the "_unlock" attribute to +* tell the compiler what happens at the end of the scope. +* +* To generalize the pattern, the WITH_LOCK_GUARD_1_ATTRS() macro should be used +* to redefine the constructor, which then also creates the alias variable with +* the right "cleanup" attribute, *after* DECLARE_LOCK_GUARD_1_ATTRS() has been +* used. +* +* Example usage: +* +* DECLARE_LOCK_GUARD_1_ATTRS(mutex, __acquires(_T), __releases(*(struct mutex **)_T)) +* #define class_mutex_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(mutex, _T) +* +* Note: To support the for-loop based scoped helpers, the auxiliary variable +* must be a pointer to the "class" type because it is defined in the same +* statement as the guard variable. However, we initialize it with the lock +* pointer (despite the type mismatch, the compiler's alias analysis still works +* as expected). The "_unlock" attribute receives a pointer to the auxiliary +* variable (a double pointer to the class type), and must be cast and +* dereferenced appropriately. +*/ #define DECLARE_LOCK_GUARD_1_ATTRS (_name, _lock, _unlock) \ static inline class_##_name##_t class_##_name##_constructor(lock_##_name##_t *_T) _lock;\ -static inline void class_##_name##_destructor(class_##_name##_t *_T) _unlock; +static __always_inline void __class_##_name##_cleanup_ctx(class_##_name##_t **_T) \ + __no_context_analysis _unlock { } +#define WITH_LOCK_GUARD_1_ATTRS (_name, _T) \ + class_##_name##_constructor(_T), \ + *__UNIQUE_ID(unlock) __cleanup(__class_##_name##_cleanup_ctx) = (void *)(_T)#define DEFINE_LOCK_GUARD_1 (_name, _type, _lock, _unlock, ...) \ __DEFINE_CLASS_IS_CONDITIONAL(_name, false); \
include/linux/local_lock.h +8 -4
@@ -104,9 +104,13 @@ DEFINE_LOCK_GUARD_1(local_lock_nested_bh, local_lock_t __percpu, local_lock_nested_bh(_T->lock), local_unlock_nested_bh(_T->lock)) -DECLARE_LOCK_GUARD_1_ATTRS(local_lock, __assumes_ctx_lock(_T), /* */) -DECLARE_LOCK_GUARD_1_ATTRS(local_lock_irq, __assumes_ctx_lock(_T), /* */) -DECLARE_LOCK_GUARD_1_ATTRS(local_lock_irqsave, __assumes_ctx_lock(_T), /* */) -DECLARE_LOCK_GUARD_1_ATTRS(local_lock_nested_bh, __assumes_ctx_lock(_T), /* */) +DECLARE_LOCK_GUARD_1_ATTRS(local_lock, __acquires(_T), __releases(*(local_lock_t __percpu **)_T)) +#define class_local_lock_constructor (_T) WITH_LOCK_GUARD_1_ATTRS(local_lock, _T) +DECLARE_LOCK_GUARD_1_ATTRS(local_lock_irq, __acquires(_T), __releases(*(local_lock_t __percpu **)_T)) +#define class_local_lock_irq_constructor (_T) WITH_LOCK_GUARD_1_ATTRS(local_lock_irq, _T) +DECLARE_LOCK_GUARD_1_ATTRS(local_lock_irqsave, __acquires(_T), __releases(*(local_lock_t __percpu **)_T)) +#define class_local_lock_irqsave_constructor (_T) WITH_LOCK_GUARD_1_ATTRS(local_lock_irqsave, _T) +DECLARE_LOCK_GUARD_1_ATTRS(local_lock_nested_bh, __acquires(_T), __releases(*(local_lock_t __percpu **)_T)) +#define class_local_lock_nested_bh_constructor (_T) WITH_LOCK_GUARD_1_ATTRS(local_lock_nested_bh, _T)#endif
include/linux/mutex.h +6 -3
@@ -255,9 +255,12 @@ DEFINE_LOCK_GUARD_1(mutex, struct mutex, mutex_lock(_T->lock), mutex_unlock(_T-> DEFINE_LOCK_GUARD_1_COND(mutex, _try, mutex_trylock(_T->lock)) DEFINE_LOCK_GUARD_1_COND(mutex, _intr, mutex_lock_interruptible(_T->lock), _RET == 0) -DECLARE_LOCK_GUARD_1_ATTRS(mutex, __assumes_ctx_lock(_T), /* */) -DECLARE_LOCK_GUARD_1_ATTRS(mutex_try, __assumes_ctx_lock(_T), /* */) -DECLARE_LOCK_GUARD_1_ATTRS(mutex_intr, __assumes_ctx_lock(_T), /* */) +DECLARE_LOCK_GUARD_1_ATTRS(mutex, __acquires(_T), __releases(*(struct mutex **)_T)) +DECLARE_LOCK_GUARD_1_ATTRS(mutex_try, __acquires(_T), __releases(*(struct mutex **)_T)) +DECLARE_LOCK_GUARD_1_ATTRS(mutex_intr, __acquires(_T), __releases(*(struct mutex **)_T)) +#define class_mutex_constructor (_T) WITH_LOCK_GUARD_1_ATTRS(mutex, _T) +#define class_mutex_try_constructor (_T) WITH_LOCK_GUARD_1_ATTRS(mutex_try, _T) +#define class_mutex_intr_constructor (_T) WITH_LOCK_GUARD_1_ATTRS(mutex_intr, _T)extern unsigned long mutex_get_owner (struct mutex *lock);
include/linux/rwsem.h +12 -6
@@ -262,17 +262,23 @@ DEFINE_LOCK_GUARD_1(rwsem_read, struct rw_semaphore, down_read(_T->lock), up_rea DEFINE_LOCK_GUARD_1_COND(rwsem_read, _try, down_read_trylock(_T->lock)) DEFINE_LOCK_GUARD_1_COND(rwsem_read, _intr, down_read_interruptible(_T->lock), _RET == 0) -DECLARE_LOCK_GUARD_1_ATTRS(rwsem_read, __assumes_ctx_lock(_T), /* */) -DECLARE_LOCK_GUARD_1_ATTRS(rwsem_read_try, __assumes_ctx_lock(_T), /* */) -DECLARE_LOCK_GUARD_1_ATTRS(rwsem_read_intr, __assumes_ctx_lock(_T), /* */) +DECLARE_LOCK_GUARD_1_ATTRS(rwsem_read, __acquires_shared(_T), __releases_shared(*(struct rw_semaphore **)_T)) +#define class_rwsem_read_constructor (_T) WITH_LOCK_GUARD_1_ATTRS(rwsem_read, _T) +DECLARE_LOCK_GUARD_1_ATTRS(rwsem_read_try, __acquires_shared(_T), __releases_shared(*(struct rw_semaphore **)_T)) +#define class_rwsem_read_try_constructor (_T) WITH_LOCK_GUARD_1_ATTRS(rwsem_read_try, _T) +DECLARE_LOCK_GUARD_1_ATTRS(rwsem_read_intr, __acquires_shared(_T), __releases_shared(*(struct rw_semaphore **)_T)) +#define class_rwsem_read_intr_constructor (_T) WITH_LOCK_GUARD_1_ATTRS(rwsem_read_intr, _T) DEFINE_LOCK_GUARD_1(rwsem_write, struct rw_semaphore, down_write(_T->lock), up_write(_T->lock)) DEFINE_LOCK_GUARD_1_COND(rwsem_write, _try, down_write_trylock(_T->lock)) DEFINE_LOCK_GUARD_1_COND(rwsem_write, _kill, down_write_killable(_T->lock), _RET == 0) -DECLARE_LOCK_GUARD_1_ATTRS(rwsem_write, __assumes_ctx_lock(_T), /* */) -DECLARE_LOCK_GUARD_1_ATTRS(rwsem_write_try, __assumes_ctx_lock(_T), /* */) -DECLARE_LOCK_GUARD_1_ATTRS(rwsem_write_kill, __assumes_ctx_lock(_T), /* */) +DECLARE_LOCK_GUARD_1_ATTRS(rwsem_write, __acquires(_T), __releases(*(struct rw_semaphore **)_T)) +#define class_rwsem_write_constructor (_T) WITH_LOCK_GUARD_1_ATTRS(rwsem_write, _T) +DECLARE_LOCK_GUARD_1_ATTRS(rwsem_write_try, __acquires(_T), __releases(*(struct rw_semaphore **)_T)) +#define class_rwsem_write_try_constructor (_T) WITH_LOCK_GUARD_1_ATTRS(rwsem_write_try, _T) +DECLARE_LOCK_GUARD_1_ATTRS(rwsem_write_kill, __acquires(_T), __releases(*(struct rw_semaphore **)_T)) +#define class_rwsem_write_kill_constructor (_T) WITH_LOCK_GUARD_1_ATTRS(rwsem_write_kill, _T)/* * downgrade write lock to read lock
include/linux/sched/task.h +2 -1
@@ -226,6 +226,7 @@ static inline void task_unlock(struct task_struct *p) } DEFINE_LOCK_GUARD_1(task_lock, struct task_struct, task_lock(_T->lock), task_unlock(_T->lock)) -DECLARE_LOCK_GUARD_1_ATTRS(task_lock, __assumes_ctx_lock(_T->alloc_lock), /* */) +DECLARE_LOCK_GUARD_1_ATTRS(task_lock, __acquires(&_T->alloc_lock), __releases(&(*(struct task_struct **)_T)->alloc_lock)) +#define class_task_lock_constructor (_T) WITH_LOCK_GUARD_1_ATTRS(task_lock, _T)#endif /* _LINUX_SCHED_TASK_H */
include/linux/spinlock.h +46 -23
155 lines not on this page · raw message
include/linux/srcu.h +6 -1
@@ -621,16 +621,21 @@ DEFINE_LOCK_GUARD_1(srcu, struct srcu_struct, _T->idx =srcu_read_lock (_T->lock),srcu_read_unlock (_T->lock, _T->idx), int idx) -DECLARE_LOCK_GUARD_1_ATTRS(srcu, __assumes_ctx_lock(_T), /* */) +DECLARE_LOCK_GUARD_1_ATTRS(srcu, __acquires_shared(_T), __releases_shared(*(struct srcu_struct **)_T)) +#define class_srcu_constructor (_T) WITH_LOCK_GUARD_1_ATTRS(srcu, _T) DEFINE_LOCK_GUARD_1(srcu_fast, struct srcu_struct, _T->scp =srcu_read_lock_fast (_T->lock),srcu_read_unlock_fast (_T->lock, _T->scp), struct srcu_ctr __percpu *scp) +DECLARE_LOCK_GUARD_1_ATTRS(srcu_fast, __acquires_shared(_T), __releases_shared(*(struct srcu_struct **)_T)) +#define class_srcu_fast_constructor (_T) WITH_LOCK_GUARD_1_ATTRS(srcu_fast, _T) DEFINE_LOCK_GUARD_1(srcu_fast_notrace, struct srcu_struct, _T->scp =srcu_read_lock_fast_notrace (_T->lock),srcu_read_unlock_fast_notrace (_T->lock, _T->scp), struct srcu_ctr __percpu *scp) +DECLARE_LOCK_GUARD_1_ATTRS(srcu_fast_notrace, __acquires_shared(_T), __releases_shared(*(struct srcu_struct **)_T)) +#define class_srcu_fast_notrace_constructor (_T) WITH_LOCK_GUARD_1_ATTRS(srcu_fast_notrace, _T)#endif
kernel/sched/sched.h +23 -7
@@ -1874,7 +1874,8 @@ DEFINE_LOCK_GUARD_1(task_rq_lock, struct task_struct, _T->rq =task_rq_lock (_T->lock, &_T->rf),task_rq_unlock (_T->rq, _T->lock, &_T->rf), struct rq *rq; struct rq_flags rf) -DECLARE_LOCK_GUARD_1_ATTRS(task_rq_lock, __assumes_ctx_lock(_T->pi_lock), /* */) +DECLARE_LOCK_GUARD_1_ATTRS(task_rq_lock, __acquires(_T->pi_lock), __releases((*(struct task_struct **)_T)->pi_lock)) +#define class_task_rq_lock_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(task_rq_lock, _T) DEFINE_LOCK_GUARD_1(__task_rq_lock, struct task_struct, _T->rq = __task_rq_lock(_T->lock, &_T->rf),
@@ -1928,21 +1929,24 @@ DEFINE_LOCK_GUARD_1(rq_lock, struct rq,rq_unlock (_T->lock, &_T->rf), struct rq_flags rf) -DECLARE_LOCK_GUARD_1_ATTRS(rq_lock, __assumes_ctx_lock(__rq_lockp(_T)), /* */); +DECLARE_LOCK_GUARD_1_ATTRS(rq_lock, __acquires(__rq_lockp(_T)), __releases(__rq_lockp(*(struct rq **)_T))); +#define class_rq_lock_constructor (_T) WITH_LOCK_GUARD_1_ATTRS(rq_lock, _T) DEFINE_LOCK_GUARD_1(rq_lock_irq, struct rq,rq_lock_irq (_T->lock, &_T->rf),rq_unlock_irq (_T->lock, &_T->rf), struct rq_flags rf) -DECLARE_LOCK_GUARD_1_ATTRS(rq_lock_irq, __assumes_ctx_lock(__rq_lockp(_T)), /* */); +DECLARE_LOCK_GUARD_1_ATTRS (rq_lock_irq,__acquires (__rq_lockp (_T)),__releases (__rq_lockp (*(struct rq **)_T))); +#define class_rq_lock_irq_constructor (_T) WITH_LOCK_GUARD_1_ATTRS(rq_lock_irq, _T) DEFINE_LOCK_GUARD_1(rq_lock_irqsave, struct rq,rq_lock_irqsave (_T->lock, &_T->rf),rq_unlock_irqrestore (_T->lock, &_T->rf), struct rq_flags rf) -DECLARE_LOCK_GUARD_1_ATTRS(rq_lock_irqsave, __assumes_ctx_lock(__rq_lockp(_T)), /* */); +DECLARE_LOCK_GUARD_1_ATTRS (rq_lock_irqsave,__acquires (__rq_lockp (_T)),__releases (__rq_lockp (*(struct rq **)_T))); +#define class_rq_lock_irqsave_constructor (_T) WITH_LOCK_GUARD_1_ATTRS(rq_lock_irqsave, _T)#define this_rq_lock_irq (...) __acquire_ret(_this_rq_lock_irq(__VA_ARGS__), __rq_lockp(__ret))static inline struct rq *_this_rq_lock_irq (struct rq_flags *rf) __acquires_ret
@@ -3075,10 +3079,17 @@ static inline class_##name##_t class_##name##_constructor(type *lock, type *lock __no_context_analysis \ { class_##name##_t _t = { .lock = lock, .lock2 = lock2 }, *_T = &_t; \ _lock; return _t; } -#define DECLARE_LOCK_GUARD_2_ATTRS (_name, _lock, _unlock) \ +#define DECLARE_LOCK_GUARD_2_ATTRS (_name, _lock, _unlock1, _unlock2) \ static inline class_##_name##_t class_##_name##_constructor(lock_##_name##_t *_T1, \ lock_##_name##_t *_T2) _lock; \ -static inline void class_##_name##_destructor(class_##_name##_t *_T) _unlock +static __always_inline void __class_##_name##_cleanup_ctx1(class_##_name##_t **_T1) \ + __no_context_analysis _unlock1 { } \ +static __always_inline void __class_##_name##_cleanup_ctx2(class_##_name##_t **_T2) \ + __no_context_analysis _unlock2 { } +#define WITH_LOCK_GUARD_2_ATTRS (_name, _T1, _T2) \ + class_##_name##_constructor(_T), \ + *__UNIQUE_ID(unlock1) __cleanup(__class_##_name##_cleanup_ctx1) = (void *)(_T1),\ + *__UNIQUE_ID(unlock2) __cleanup(__class_##_name##_cleanup_ctx2) = (void *)(_T2)static inline bool rq_order_less (struct rq *rq1,struct rq *rq2) {
@@ -3229,7 +3240,12 @@ DEFINE_LOCK_GUARD_2(double_raw_spinlock, raw_spinlock_t, double_raw_lock(_T->lock, _T->lock2), double_raw_unlock(_T->lock, _T->lock2)) -DECLARE_LOCK_GUARD_2_ATTRS(double_raw_spinlock, __assumes_ctx_lock(_T1) __assumes_ctx_lock(_T2), /* */); +DECLARE_LOCK_GUARD_2_ATTRS (double_raw_spinlock, +__acquires (_T1, _T2), +__releases (*(raw_spinlock_t **)_T1), +__releases (*(raw_spinlock_t **)_T2)); +#define class_double_raw_spinlock_constructor (_T1, _T2) \ + WITH_LOCK_GUARD_2_ATTRS(double_raw_spinlock, _T1, _T2)/* * double_rq_unlock - safely unlock two runqueues
lib/test_context-analysis.c +3 -2
@@ -459,8 +459,9 @@ static void __used test_srcu(struct test_srcu_data *d)static void __used test_srcu_guard (struct test_srcu_data *d) { -guard (srcu)(&d->srcu); - (void )srcu_dereference (d->data, &d->srcu); + {guard (srcu)(&d->srcu); (void )srcu_dereference (d->data, &d->srcu); } + {guard (srcu_fast)(&d->srcu); (void )srcu_dereference (d->data, &d->srcu); } + {guard (srcu_fast_notrace)(&d->srcu); (void )srcu_dereference (d->data, &d->srcu); } }struct test_local_lock_data {
Peter Zijlstra
maintainerRe: [PATCH v4 06/35] cleanup: Basic compatibility with context analysis
Quoted 2 lines · Marco Elver
Below is the preview of the complete changes to make the lock guards work properly.
Right. Not pretty but it works.
I did spend a few hours yesterday trying out various thing that don't work -- as I'm sure you did too -- but could not come up with something saner.
So yeah, lets just do this.
Peter Zijlstra
maintainerRe: [PATCH v4 06/35] cleanup: Basic compatibility with context analysis
In reply to Marco ElverQuoted 7 lines · Marco Elver
One observation from the rebase: Generally synchronization primitives do not change much and the annotations are relatively stable, but e.g. RCU & sched (latter is optional and depends on the sched-enablement patch) receive disproportionally more changes, and while new annotations required for v6.19-rc1 were trivial, it does require compiling with a Clang version that does produce the warnings to notice.
I have:
Debian clang version 22.0.0 (++20251023025710+3f47a7be1ae6-1~exp5)
I've not tried if that is new enough.
Quoted 7 lines
While Clang 22-dev is being tested on CI, I doubt maintainers already use it, so it's possible we'll see some late warnings due to missing annotations when things hit -next. This might be an acceptable churn cost, if we think the outcome is worthwhile. Things should get better when Clang 22 is released properly, but until then things might be a little bumpy if there are large changes across the core synchronization primitives.
Yeah, we'll see how bad it gets, we can always disable it for COMPILE_TEST or so for a while.
Marco Elver
maintainerRe: [PATCH v4 06/35] cleanup: Basic compatibility with context analysis
Quoted 9 lines · Peter Zijlstra
Quoted 7 lines · Marco Elver
One observation from the rebase: Generally synchronization primitives do not change much and the annotations are relatively stable, but e.g. RCU & sched (latter is optional and depends on the sched-enablement patch) receive disproportionally more changes, and while new annotations required for v6.19-rc1 were trivial, it does require compiling with a Clang version that does produce the warnings to notice.
Quoted 5 lines
I have:
Debian clang version 22.0.0 (++20251023025710+3f47a7be1ae6-1~exp5)
I've not tried if that is new enough.
That's new enough - it's after
https://github.com/llvm/llvm-project/commit/7ccb5c08f0685d4787f12c3224a72f0650c5865e
which is the minimum required version.
Quoted 10 lines
Quoted 7 lines
While Clang 22-dev is being tested on CI, I doubt maintainers already use it, so it's possible we'll see some late warnings due to missing annotations when things hit -next. This might be an acceptable churn cost, if we think the outcome is worthwhile. Things should get better when Clang 22 is released properly, but until then things might be a little bumpy if there are large changes across the core synchronization primitives.
Yeah, we'll see how bad it gets, we can always disable it for
COMPILE_TESTor so for a while.
Bart Van Assche
reviewerRe: [PATCH v4 06/35] cleanup: Basic compatibility with context analysis
In reply to Marco ElverQuoted 9 lines · Marco Elver
For
cleanup.h, the problem is that to instantiate we use "guard(class)(args..)". If it had been designed as "guard(class, args...)", i.e. just use__VA_ARGS__explicitly instead of the implicit 'args...', it might have been possible to add a second cleanup variable to do the same (with some additional magic to extract the first arg if one exists). Unfortunately, the use of the current guard()() idiom has become so pervasive that this is a bigger refactor. I'm going to leavecleanup.has-is for now, if we think we want to give this a go in the current state.
Peter, has it already been considered to make the guard() and scoped_guard() macros more consistent? If there would be agreement that guard(class)(args..) should be changed into guard(class, args..), I can help with realizing this conversion.
Thanks,
Bart.
Peter Zijlstra
maintainerRe: [PATCH v4 06/35] cleanup: Basic compatibility with context analysis
In reply to Marco ElverQuoted 36 lines · Marco Elver
Working on rebasing this to v6.19-rc1 and saw this new scoped seqlock abstraction. For that one I was able to make it work like I thought we could (below). Some awkwardness is required to make it work in for-loops, which only let you define variables with the same type.
include/linux/seqlock.h +8
-0@@ -1249,6 +1249,7 @@ struct ss_tmp { }; static __always_inline void __scoped_seqlock_cleanup(struct ss_tmp *sst) + __no_context_analysis {if (sst->lock)spin_unlock (sst->lock);@@ -1278,6 +1279,7 @@ extern void __scoped_seqlock_bug(void); static __always_inline void__scoped_seqlock_next (struct ss_tmp *sst,seqlock_t *lock,enum ss_state target) + __no_context_analysis {switch (sst->state) {case ss_done:@@ -1320,9 +1322,18 @@ __scoped_seqlock_next(struct ss_tmp *sst, seqlock_t *lock, enum ss_state target) } } +/* +* Context analysis helper to release seqlock at the end of the for-scope; the +* alias analysis of the compiler will recognize that the pointer @s is is an +* alias to @_seqlock passed to read_seqbegin(_seqlock) below. +*/ +static __always_inline void __scoped_seqlock_cleanup_ctx(struct ss_tmp **s)
include/linux/seqlock.h __scoped_seqlock_next(struct ss_tmp *sst, seqlock_t *lock, enum ss_state target) · line 1339
Quoted 10 lines
include/linux/seqlock.h +4
-1+ __releases_shared(*((seqlock_t **)s)) __no_context_analysis {} +#define __scoped_seqlock_read (_seqlock, _target, _s) \ for (struct ss_tmp _s __cleanup(__scoped_seqlock_cleanup) = \ - { .state = ss_lockless, .data = read_seqbegin(_seqlock) }; \ + { .state = ss_lockless, .data = read_seqbegin(_seqlock) }, \ + *__UNIQUE_ID(ctx) __cleanup(__scoped_seqlock_cleanup_ctx) = (struct ss_tmp *)_seqlock; \ _s.state != ss_done; \ __scoped_seqlock_next(&_s, _seqlock, _target))
I am ever so confused.. where is the __acquire_shared(), in read_seqbegin() ?
Also, why do we need this second variable with cleanup; can't the existing __scoped_seqlock_cleanup() get the __releases_shared() attribute?
Marco Elver
maintainerRe: [PATCH v4 06/35] cleanup: Basic compatibility with context analysis
Quoted 42 lines · Peter Zijlstra
Quoted 40 lines · Marco Elver
Working on rebasing this to v6.19-rc1 and saw this new scoped seqlock abstraction. For that one I was able to make it work like I thought we could (below). Some awkwardness is required to make it work in for-loops, which only let you define variables with the same type.
include/linux/seqlock.h +10
-0@@ -1249,6 +1249,7 @@ struct ss_tmp { }; static __always_inline void __scoped_seqlock_cleanup(struct ss_tmp *sst) + __no_context_analysis {if (sst->lock)spin_unlock (sst->lock);@@ -1278,6 +1279,7 @@ extern void __scoped_seqlock_bug(void); static __always_inline void__scoped_seqlock_next (struct ss_tmp *sst,seqlock_t *lock,enum ss_state target) + __no_context_analysis {switch (sst->state) {case ss_done:@@ -1320,9 +1322,18 @@ __scoped_seqlock_next(struct ss_tmp *sst, seqlock_t *lock, enum ss_state target) } } +/* +* Context analysis helper to release seqlock at the end of the for-scope; the +* alias analysis of the compiler will recognize that the pointer @s is is an +* alias to @_seqlock passed to read_seqbegin(_seqlock) below. +*/ +static __always_inline void __scoped_seqlock_cleanup_ctx(struct ss_tmp **s) + __releases_shared(*((seqlock_t **)s)) __no_context_analysis {} +#define __scoped_seqlock_read (_seqlock, _target, _s) \ for (struct ss_tmp _s __cleanup(__scoped_seqlock_cleanup) = \
Quoted 8 lines
include/linux/seqlock.h __scoped_seqlock_next(struct ss_tmp *sst, seqlock_t *lock, enum ss_state target) · line 1339
Quoted 6 lines
include/linux/seqlock.h +2
-1- { .state = ss_lockless, .data = read_seqbegin(_seqlock) }; \ + { .state = ss_lockless, .data = read_seqbegin(_seqlock) }, \ + *__UNIQUE_ID(ctx) __cleanup(__scoped_seqlock_cleanup_ctx) = (struct ss_tmp *)_seqlock; \ _s.state != ss_done; \ __scoped_seqlock_next(&_s, _seqlock, _target))I am ever so confused.. where is the
__acquire_shared(), inread_seqbegin()?
Ah this is just a diff on top of this v4 series. The read_seqbegin() already had it:
static inline unsigned read_seqbegin(const seqlock_t *sl)
__acquires_shared(sl) __no_context_analysis
{Quoted 3 lines
Also, why do we need this second variable with cleanup; can't the existing
__scoped_seqlock_cleanup()get the__releases_shared()attribute?
The existing __scoped_seqlock_cleanup() receives &_s (struct ss_tmp *), and we can't refer to the _seqlock from __scoped_seqlock_cleanup(). Even if I create a member seqlock_t* ss_tmp::seqlock and initialize it with _seqlock, the compiler can't track that the member would be an alias of _seqlock. The function __scoped_seqlock_next() does receive _seqlock to effectively release it executes for every loop, so there'd be a "lock imbalance" in the compiler's eyes.
So having the direct alias (even if we cast it to make it work in the single-statement multi-definition, the compiler doesn't care) is required for it to work.
Peter Zijlstra
maintainerRe: [PATCH v4 06/35] cleanup: Basic compatibility with context analysis
Quoted 12 lines · Marco Elver
Quoted 3 lines
Also, why do we need this second variable with cleanup; can't the existing
__scoped_seqlock_cleanup()get the__releases_shared()attribute?The existing
__scoped_seqlock_cleanup()receives &_s (structss_tmp*), and we can't refer to the_seqlockfrom__scoped_seqlock_cleanup(). Even if I create a member seqlock_t*ss_tmp::seqlockand initialize it with_seqlock, the compiler can't track that the member would be an alias of_seqlock. The function__scoped_seqlock_next()does receive_seqlockto effectively release it executes for every loop, so there'd be a "lock imbalance" in the compiler's eyes.
Quoted 3 lines
So having the direct alias (even if we cast it to make it work in the single-statement multi-definition, the compiler doesn't care) is required for it to work.
Right -- it just clicked while I was walking outside. Without actual inlining it cannot see through the constructor and track the variable :/
OK, let me stare at this more.
Marco Elver
maintainerAll,
Quoted 6 lines · Marco Elver
Context Analysis is a language extension, which enables statically checking that required contexts are active (or inactive) by acquiring and releasing user-definable "context guards". An obvious application is lock-safety checking for the kernel's various synchronization primitives (each of which represents a "context guard"), and checking that locking rules are not violated.
[...]
Quoted 11 lines
A Clang version that supports
-Wthread-safety-pointerand the new alias-analysis of context-guard pointers is required (from this version onwards):https://github.com/llvm/llvm-project/commit/7ccb5c08f0685d4787f12c3224a72f0650c5865eThe minimum required release version will be Clang 22.
This series is also available at this Git tree:
https://git.kernel.org/pub/scm/linux/kernel/git/melver/linux.git/log/?h=ctx-analysis/dev
[...]
I realize that I sent this series at the end of the last release cycle, and now we're in the merge window, along with LPC going on -- so it wasn't the best timing (however, it might be something to discuss at LPC, too :-) .. I'm attending virtually, however :-/).
How to proceed?
I'll be preparing a rebased and retested version of all this when
v6.19-rc1 is out. One outstanding recommendation from Linus was to
investigate compile-times, but as-is, it's unclear there's any notable
overhead per brief investigation: https://lore.kernel.org/all/[email protected]/
From what I can tell most of this has to go through the locking tree, given the potential for conflict there. However, it is possible to split this up as follows:
Batch 1:
Quoted 20 lines
compiler_types: Move lock checking attributes to
compiler-context-analysis.h
compiler-context-analysis: Add infrastructure for Context Analysis
with Clang
compiler-context-analysis: Add test stub
Documentation: Add documentation for Compiler-Based Context Analysis
checkpatch: Warn aboutcontext_unsafe()without comment
cleanup: Basic compatibility with context analysis
lockdep: Annotate lockdep assertions for context analysis locking/rwlock, spinlock: Support Clang's context analysis
compiler-context-analysis: Change__cond_acquiresto take return value locking/mutex: Support Clang's context analysis locking/seqlock: Support Clang's context analysis
bit_spinlock: Include missing <asm/processor.h>
bit_spinlock: Support Clang's context analysis
rcu: Support Clang's context analysis
srcu: Support Clang's context analysis
kref: Add context-analysis annotations
locking/rwsem: Support Clang's context analysis locking/local_lock: Include missing headers
Quoted 8 lines
locking/local_lock: Support Clang's context analysis locking/ww_mutex: Support Clang's context analysis
debugfs: Makedebugfs_cancellationa context guard struct
compiler-context-analysis: Remove Sparse support
compiler-context-analysis: Remove__cond_lock()function-like helper
compiler-context-analysis: Introduce header suppressions
compiler: Letdata_race()imply disabled context analysis
MAINTAINERS: Add entry for Context Analysis
Batch 2: Everything below this can wait for the initial support in mainline, at which point subsystem maintainers can pick them up if deemed appropriate.
Quoted 9 lines
kfence: Enable context analysis
kcov: Enable context analysis
kcsan: Enable context analysis
stackdepot: Enable context analysis
rhashtable: Enable context analysis
printk: Move locking annotation toprintk.csecurity/tomoyo: Enable context analysis
crypto: Enable context analysis
sched: Enable context analysis forcore.candfair.c
Thanks,
-- Marco
Peter Zijlstra
maintainerQuoted 21 lines · Marco Elver
All,
Quoted 6 lines · Marco Elver
Context Analysis is a language extension, which enables statically checking that required contexts are active (or inactive) by acquiring and releasing user-definable "context guards". An obvious application is lock-safety checking for the kernel's various synchronization primitives (each of which represents a "context guard"), and checking that locking rules are not violated.
[...]
Quoted 11 lines
A Clang version that supports
-Wthread-safety-pointerand the new alias-analysis of context-guard pointers is required (from this version onwards):https://github.com/llvm/llvm-project/commit/7ccb5c08f0685d4787f12c3224a72f0650c5865eThe minimum required release version will be Clang 22.
This series is also available at this Git tree:
https://git.kernel.org/pub/scm/linux/kernel/git/melver/linux.git/log/?h=ctx-analysis/dev
Quoted 8 lines
[...]
I realize that I sent this series at the end of the last release cycle, and now we're in the merge window, along with LPC going on -- so it wasn't the best timing (however, it might be something to discuss at LPC, too :-) .. I'm attending virtually, however :-/).
How to proceed?
Ah, I knew I was forgetting something :/ I'll try and have a peek at this series this week.