License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 14:07:57 +00:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
2005-04-16 22:20:36 +00:00
|
|
|
#ifndef __LINUX_SEQLOCK_H
|
|
|
|
#define __LINUX_SEQLOCK_H
|
2020-07-20 15:55:07 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2020-07-20 15:55:07 +00:00
|
|
|
* seqcount_t / seqlock_t - a reader-writer consistency mechanism with
|
|
|
|
* lockless readers (read-only retry loops), and no writer starvation.
|
|
|
|
*
|
|
|
|
* See Documentation/locking/seqlock.rst
|
|
|
|
*
|
|
|
|
* Copyrights:
|
|
|
|
* - Based on x86_64 vsyscall gettimeofday: Keith Owens, Andrea Arcangeli
|
2020-07-20 15:55:15 +00:00
|
|
|
* - Sequence counters with associated locks, (C) 2020 Linutronix GmbH
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
|
2015-05-27 01:39:36 +00:00
|
|
|
#include <linux/compiler.h>
|
2020-02-11 16:04:20 +00:00
|
|
|
#include <linux/kcsan-checks.h>
|
2020-07-20 15:55:15 +00:00
|
|
|
#include <linux/lockdep.h>
|
|
|
|
#include <linux/mutex.h>
|
2020-09-04 15:32:30 +00:00
|
|
|
#include <linux/ww_mutex.h>
|
2020-07-20 15:55:15 +00:00
|
|
|
#include <linux/preempt.h>
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
|
2011-06-11 11:29:58 +00:00
|
|
|
#include <asm/processor.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
seqlock, kcsan: Add annotations for KCSAN
Since seqlocks in the Linux kernel do not require the use of marked
atomic accesses in critical sections, we teach KCSAN to assume such
accesses are atomic. KCSAN currently also pretends that writes to
`sequence` are atomic, although currently plain writes are used (their
corresponding reads are READ_ONCE).
Further, to avoid false positives in the absence of clear ending of a
seqlock reader critical section (only when using the raw interface),
KCSAN assumes a fixed number of accesses after start of a seqlock
critical section are atomic.
=== Commentary on design around absence of clear begin/end markings ===
Seqlock usage via seqlock_t follows a predictable usage pattern, where
clear critical section begin/end is enforced. With subtle special cases
for readers needing to be flat atomic regions, e.g. because usage such
as in:
- fs/namespace.c:__legitimize_mnt - unbalanced read_seqretry
- fs/dcache.c:d_walk - unbalanced need_seqretry
But, anything directly accessing seqcount_t seems to be unpredictable.
Filtering for usage of read_seqcount_retry not following 'do { .. }
while (read_seqcount_retry(..));':
$ git grep 'read_seqcount_retry' | grep -Ev 'while \(|seqlock.h|Doc|\* '
=> about 1/3 of the total read_seqcount_retry usage.
Just looking at fs/namei.c, we conclude that it is non-trivial to
prescribe and migrate to an interface that would force clear begin/end
seqlock markings for critical sections.
As such, we concluded that the best design currently, is to simply
ensure that KCSAN works well with the existing code.
Signed-off-by: Marco Elver <elver@google.com>
Acked-by: Paul E. McKenney <paulmck@kernel.org>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2019-11-14 18:02:59 +00:00
|
|
|
/*
|
2020-07-20 15:55:07 +00:00
|
|
|
* The seqlock seqcount_t interface does not prescribe a precise sequence of
|
|
|
|
* read begin/retry/end. For readers, typically there is a call to
|
seqlock, kcsan: Add annotations for KCSAN
Since seqlocks in the Linux kernel do not require the use of marked
atomic accesses in critical sections, we teach KCSAN to assume such
accesses are atomic. KCSAN currently also pretends that writes to
`sequence` are atomic, although currently plain writes are used (their
corresponding reads are READ_ONCE).
Further, to avoid false positives in the absence of clear ending of a
seqlock reader critical section (only when using the raw interface),
KCSAN assumes a fixed number of accesses after start of a seqlock
critical section are atomic.
=== Commentary on design around absence of clear begin/end markings ===
Seqlock usage via seqlock_t follows a predictable usage pattern, where
clear critical section begin/end is enforced. With subtle special cases
for readers needing to be flat atomic regions, e.g. because usage such
as in:
- fs/namespace.c:__legitimize_mnt - unbalanced read_seqretry
- fs/dcache.c:d_walk - unbalanced need_seqretry
But, anything directly accessing seqcount_t seems to be unpredictable.
Filtering for usage of read_seqcount_retry not following 'do { .. }
while (read_seqcount_retry(..));':
$ git grep 'read_seqcount_retry' | grep -Ev 'while \(|seqlock.h|Doc|\* '
=> about 1/3 of the total read_seqcount_retry usage.
Just looking at fs/namei.c, we conclude that it is non-trivial to
prescribe and migrate to an interface that would force clear begin/end
seqlock markings for critical sections.
As such, we concluded that the best design currently, is to simply
ensure that KCSAN works well with the existing code.
Signed-off-by: Marco Elver <elver@google.com>
Acked-by: Paul E. McKenney <paulmck@kernel.org>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2019-11-14 18:02:59 +00:00
|
|
|
* read_seqcount_begin() and read_seqcount_retry(), however, there are more
|
|
|
|
* esoteric cases which do not follow this pattern.
|
|
|
|
*
|
|
|
|
* As a consequence, we take the following best-effort approach for raw usage
|
|
|
|
* via seqcount_t under KCSAN: upon beginning a seq-reader critical section,
|
2019-11-20 09:41:43 +00:00
|
|
|
* pessimistically mark the next KCSAN_SEQLOCK_REGION_MAX memory accesses as
|
seqlock, kcsan: Add annotations for KCSAN
Since seqlocks in the Linux kernel do not require the use of marked
atomic accesses in critical sections, we teach KCSAN to assume such
accesses are atomic. KCSAN currently also pretends that writes to
`sequence` are atomic, although currently plain writes are used (their
corresponding reads are READ_ONCE).
Further, to avoid false positives in the absence of clear ending of a
seqlock reader critical section (only when using the raw interface),
KCSAN assumes a fixed number of accesses after start of a seqlock
critical section are atomic.
=== Commentary on design around absence of clear begin/end markings ===
Seqlock usage via seqlock_t follows a predictable usage pattern, where
clear critical section begin/end is enforced. With subtle special cases
for readers needing to be flat atomic regions, e.g. because usage such
as in:
- fs/namespace.c:__legitimize_mnt - unbalanced read_seqretry
- fs/dcache.c:d_walk - unbalanced need_seqretry
But, anything directly accessing seqcount_t seems to be unpredictable.
Filtering for usage of read_seqcount_retry not following 'do { .. }
while (read_seqcount_retry(..));':
$ git grep 'read_seqcount_retry' | grep -Ev 'while \(|seqlock.h|Doc|\* '
=> about 1/3 of the total read_seqcount_retry usage.
Just looking at fs/namei.c, we conclude that it is non-trivial to
prescribe and migrate to an interface that would force clear begin/end
seqlock markings for critical sections.
As such, we concluded that the best design currently, is to simply
ensure that KCSAN works well with the existing code.
Signed-off-by: Marco Elver <elver@google.com>
Acked-by: Paul E. McKenney <paulmck@kernel.org>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2019-11-14 18:02:59 +00:00
|
|
|
* atomics; if there is a matching read_seqcount_retry() call, no following
|
2020-07-20 15:55:07 +00:00
|
|
|
* memory operations are considered atomic. Usage of the seqlock_t interface
|
|
|
|
* is not affected.
|
seqlock, kcsan: Add annotations for KCSAN
Since seqlocks in the Linux kernel do not require the use of marked
atomic accesses in critical sections, we teach KCSAN to assume such
accesses are atomic. KCSAN currently also pretends that writes to
`sequence` are atomic, although currently plain writes are used (their
corresponding reads are READ_ONCE).
Further, to avoid false positives in the absence of clear ending of a
seqlock reader critical section (only when using the raw interface),
KCSAN assumes a fixed number of accesses after start of a seqlock
critical section are atomic.
=== Commentary on design around absence of clear begin/end markings ===
Seqlock usage via seqlock_t follows a predictable usage pattern, where
clear critical section begin/end is enforced. With subtle special cases
for readers needing to be flat atomic regions, e.g. because usage such
as in:
- fs/namespace.c:__legitimize_mnt - unbalanced read_seqretry
- fs/dcache.c:d_walk - unbalanced need_seqretry
But, anything directly accessing seqcount_t seems to be unpredictable.
Filtering for usage of read_seqcount_retry not following 'do { .. }
while (read_seqcount_retry(..));':
$ git grep 'read_seqcount_retry' | grep -Ev 'while \(|seqlock.h|Doc|\* '
=> about 1/3 of the total read_seqcount_retry usage.
Just looking at fs/namei.c, we conclude that it is non-trivial to
prescribe and migrate to an interface that would force clear begin/end
seqlock markings for critical sections.
As such, we concluded that the best design currently, is to simply
ensure that KCSAN works well with the existing code.
Signed-off-by: Marco Elver <elver@google.com>
Acked-by: Paul E. McKenney <paulmck@kernel.org>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2019-11-14 18:02:59 +00:00
|
|
|
*/
|
|
|
|
#define KCSAN_SEQLOCK_REGION_MAX 1000
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2020-07-20 15:55:07 +00:00
|
|
|
* Sequence counters (seqcount_t)
|
|
|
|
*
|
|
|
|
* This is the raw counting mechanism, without any writer protection.
|
|
|
|
*
|
|
|
|
* Write side critical sections must be serialized and non-preemptible.
|
|
|
|
*
|
|
|
|
* If readers can be invoked from hardirq or softirq contexts,
|
|
|
|
* interrupts or bottom halves must also be respectively disabled before
|
|
|
|
* entering the write section.
|
|
|
|
*
|
|
|
|
* This mechanism can't be used if the protected data contains pointers,
|
|
|
|
* as the writer can invalidate a pointer that a reader is following.
|
|
|
|
*
|
2020-07-20 15:55:15 +00:00
|
|
|
* If the write serialization mechanism is one of the common kernel
|
|
|
|
* locking primitives, use a sequence counter with associated lock
|
2020-09-04 15:32:27 +00:00
|
|
|
* (seqcount_LOCKNAME_t) instead.
|
2020-07-20 15:55:15 +00:00
|
|
|
*
|
2020-07-20 15:55:07 +00:00
|
|
|
* If it's desired to automatically handle the sequence counter writer
|
|
|
|
* serialization and non-preemptibility requirements, use a sequential
|
|
|
|
* lock (seqlock_t) instead.
|
|
|
|
*
|
|
|
|
* See Documentation/locking/seqlock.rst
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
typedef struct seqcount {
|
|
|
|
unsigned sequence;
|
2013-10-07 22:51:59 +00:00
|
|
|
#ifdef CONFIG_DEBUG_LOCK_ALLOC
|
|
|
|
struct lockdep_map dep_map;
|
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
} seqcount_t;
|
|
|
|
|
2013-10-07 22:51:59 +00:00
|
|
|
static inline void __seqcount_init(seqcount_t *s, const char *name,
|
|
|
|
struct lock_class_key *key)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Make sure we are not reinitializing a held lock:
|
|
|
|
*/
|
|
|
|
lockdep_init_map(&s->dep_map, name, key, 0);
|
|
|
|
s->sequence = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_DEBUG_LOCK_ALLOC
|
2020-07-20 15:55:16 +00:00
|
|
|
|
|
|
|
# define SEQCOUNT_DEP_MAP_INIT(lockname) \
|
|
|
|
.dep_map = { .name = #lockname }
|
2013-10-07 22:51:59 +00:00
|
|
|
|
2020-07-20 15:55:11 +00:00
|
|
|
/**
|
|
|
|
* seqcount_init() - runtime initializer for seqcount_t
|
|
|
|
* @s: Pointer to the seqcount_t instance
|
|
|
|
*/
|
2020-07-20 15:55:16 +00:00
|
|
|
# define seqcount_init(s) \
|
|
|
|
do { \
|
|
|
|
static struct lock_class_key __key; \
|
|
|
|
__seqcount_init((s), #s, &__key); \
|
2013-10-07 22:51:59 +00:00
|
|
|
} while (0)
|
|
|
|
|
|
|
|
static inline void seqcount_lockdep_reader_access(const seqcount_t *s)
|
|
|
|
{
|
|
|
|
seqcount_t *l = (seqcount_t *)s;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
local_irq_save(flags);
|
|
|
|
seqcount_acquire_read(&l->dep_map, 0, 0, _RET_IP_);
|
2019-09-19 16:09:40 +00:00
|
|
|
seqcount_release(&l->dep_map, _RET_IP_);
|
2013-10-07 22:51:59 +00:00
|
|
|
local_irq_restore(flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
# define SEQCOUNT_DEP_MAP_INIT(lockname)
|
|
|
|
# define seqcount_init(s) __seqcount_init(s, NULL, NULL)
|
|
|
|
# define seqcount_lockdep_reader_access(x)
|
|
|
|
#endif
|
|
|
|
|
2020-07-20 15:55:11 +00:00
|
|
|
/**
|
|
|
|
* SEQCNT_ZERO() - static initializer for seqcount_t
|
|
|
|
* @name: Name of the seqcount_t instance
|
|
|
|
*/
|
|
|
|
#define SEQCNT_ZERO(name) { .sequence = 0, SEQCOUNT_DEP_MAP_INIT(name) }
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2020-07-20 15:55:15 +00:00
|
|
|
/*
|
2020-09-04 15:32:27 +00:00
|
|
|
* Sequence counters with associated locks (seqcount_LOCKNAME_t)
|
2020-07-20 15:55:15 +00:00
|
|
|
*
|
|
|
|
* A sequence counter which associates the lock used for writer
|
|
|
|
* serialization at initialization time. This enables lockdep to validate
|
|
|
|
* that the write side critical section is properly serialized.
|
|
|
|
*
|
|
|
|
* For associated locks which do not implicitly disable preemption,
|
|
|
|
* preemption protection is enforced in the write side function.
|
|
|
|
*
|
|
|
|
* Lockdep is never used in any for the raw write variants.
|
|
|
|
*
|
|
|
|
* See Documentation/locking/seqlock.rst
|
|
|
|
*/
|
|
|
|
|
2020-09-04 15:32:30 +00:00
|
|
|
/*
|
|
|
|
* For PREEMPT_RT, seqcount_LOCKNAME_t write side critical sections cannot
|
|
|
|
* disable preemption. It can lead to higher latencies, and the write side
|
|
|
|
* sections will not be able to acquire locks which become sleeping locks
|
|
|
|
* (e.g. spinlock_t).
|
|
|
|
*
|
|
|
|
* To remain preemptible while avoiding a possible livelock caused by the
|
|
|
|
* reader preempting the writer, use a different technique: let the reader
|
|
|
|
* detect if a seqcount_LOCKNAME_t writer is in progress. If that is the
|
|
|
|
* case, acquire then release the associated LOCKNAME writer serialization
|
|
|
|
* lock. This will allow any possibly-preempted writer to make progress
|
|
|
|
* until the end of its writer serialization lock critical section.
|
|
|
|
*
|
|
|
|
* This lock-unlock technique must be implemented for all of PREEMPT_RT
|
|
|
|
* sleeping locks. See Documentation/locking/locktypes.rst
|
|
|
|
*/
|
|
|
|
#if defined(CONFIG_LOCKDEP) || defined(CONFIG_PREEMPT_RT)
|
2020-07-23 09:56:22 +00:00
|
|
|
#define __SEQ_LOCK(expr) expr
|
2020-07-20 15:55:15 +00:00
|
|
|
#else
|
2020-07-23 09:56:22 +00:00
|
|
|
#define __SEQ_LOCK(expr)
|
2020-07-20 15:55:15 +00:00
|
|
|
#endif
|
|
|
|
|
2020-10-13 12:14:43 +00:00
|
|
|
/*
|
2020-09-04 15:32:27 +00:00
|
|
|
* typedef seqcount_LOCKNAME_t - sequence counter with LOCKNAME associated
|
2020-07-23 09:56:49 +00:00
|
|
|
* @seqcount: The real sequence counter
|
2020-09-04 15:32:27 +00:00
|
|
|
* @lock: Pointer to the associated lock
|
2020-07-23 09:56:49 +00:00
|
|
|
*
|
2020-09-04 15:32:27 +00:00
|
|
|
* A plain sequence counter with external writer synchronization by
|
|
|
|
* LOCKNAME @lock. The lock is associated to the sequence counter in the
|
2020-07-23 09:56:49 +00:00
|
|
|
* static initializer or init function. This enables lockdep to validate
|
|
|
|
* that the write side critical section is properly serialized.
|
2020-09-04 15:32:27 +00:00
|
|
|
*
|
|
|
|
* LOCKNAME: raw_spinlock, spinlock, rwlock, mutex, or ww_mutex.
|
2020-07-23 09:56:49 +00:00
|
|
|
*/
|
|
|
|
|
2020-08-17 00:02:00 +00:00
|
|
|
/*
|
2020-07-23 10:00:53 +00:00
|
|
|
* seqcount_LOCKNAME_init() - runtime initializer for seqcount_LOCKNAME_t
|
|
|
|
* @s: Pointer to the seqcount_LOCKNAME_t instance
|
2020-09-04 15:32:27 +00:00
|
|
|
* @lock: Pointer to the associated lock
|
2020-07-23 10:00:53 +00:00
|
|
|
*/
|
|
|
|
|
2020-09-15 14:30:28 +00:00
|
|
|
#define seqcount_LOCKNAME_init(s, _lock, lockname) \
|
|
|
|
do { \
|
|
|
|
seqcount_##lockname##_t *____s = (s); \
|
|
|
|
seqcount_init(&____s->seqcount); \
|
|
|
|
__SEQ_LOCK(____s->lock = (_lock)); \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
#define seqcount_raw_spinlock_init(s, lock) seqcount_LOCKNAME_init(s, lock, raw_spinlock)
|
|
|
|
#define seqcount_spinlock_init(s, lock) seqcount_LOCKNAME_init(s, lock, spinlock)
|
|
|
|
#define seqcount_rwlock_init(s, lock) seqcount_LOCKNAME_init(s, lock, rwlock);
|
|
|
|
#define seqcount_mutex_init(s, lock) seqcount_LOCKNAME_init(s, lock, mutex);
|
|
|
|
#define seqcount_ww_mutex_init(s, lock) seqcount_LOCKNAME_init(s, lock, ww_mutex);
|
|
|
|
|
2020-07-20 15:55:15 +00:00
|
|
|
/*
|
2020-09-04 15:32:28 +00:00
|
|
|
* SEQCOUNT_LOCKNAME() - Instantiate seqcount_LOCKNAME_t and helpers
|
|
|
|
* seqprop_LOCKNAME_*() - Property accessors for seqcount_LOCKNAME_t
|
|
|
|
*
|
2020-09-04 15:32:27 +00:00
|
|
|
* @lockname: "LOCKNAME" part of seqcount_LOCKNAME_t
|
|
|
|
* @locktype: LOCKNAME canonical C data type
|
2020-09-04 15:32:30 +00:00
|
|
|
* @preemptible: preemptibility of above locktype
|
2020-07-23 09:56:49 +00:00
|
|
|
* @lockmember: argument for lockdep_assert_held()
|
2020-09-04 15:32:30 +00:00
|
|
|
* @lockbase: associated lock release function (prefix only)
|
|
|
|
* @lock_acquire: associated lock acquisition function (full call)
|
2020-07-20 15:55:15 +00:00
|
|
|
*/
|
2020-09-04 15:32:30 +00:00
|
|
|
#define SEQCOUNT_LOCKNAME(lockname, locktype, preemptible, lockmember, lockbase, lock_acquire) \
|
2020-07-23 09:56:49 +00:00
|
|
|
typedef struct seqcount_##lockname { \
|
|
|
|
seqcount_t seqcount; \
|
|
|
|
__SEQ_LOCK(locktype *lock); \
|
|
|
|
} seqcount_##lockname##_t; \
|
|
|
|
\
|
|
|
|
static __always_inline seqcount_t * \
|
2020-09-04 15:32:28 +00:00
|
|
|
__seqprop_##lockname##_ptr(seqcount_##lockname##_t *s) \
|
2020-07-20 15:55:15 +00:00
|
|
|
{ \
|
|
|
|
return &s->seqcount; \
|
|
|
|
} \
|
|
|
|
\
|
2020-09-04 15:32:29 +00:00
|
|
|
static __always_inline unsigned \
|
|
|
|
__seqprop_##lockname##_sequence(const seqcount_##lockname##_t *s) \
|
|
|
|
{ \
|
2020-09-04 15:32:30 +00:00
|
|
|
unsigned seq = READ_ONCE(s->seqcount.sequence); \
|
|
|
|
\
|
|
|
|
if (!IS_ENABLED(CONFIG_PREEMPT_RT)) \
|
|
|
|
return seq; \
|
|
|
|
\
|
|
|
|
if (preemptible && unlikely(seq & 1)) { \
|
|
|
|
__SEQ_LOCK(lock_acquire); \
|
|
|
|
__SEQ_LOCK(lockbase##_unlock(s->lock)); \
|
|
|
|
\
|
|
|
|
/* \
|
|
|
|
* Re-read the sequence counter since the (possibly \
|
|
|
|
* preempted) writer made progress. \
|
|
|
|
*/ \
|
|
|
|
seq = READ_ONCE(s->seqcount.sequence); \
|
|
|
|
} \
|
|
|
|
\
|
|
|
|
return seq; \
|
2020-09-04 15:32:29 +00:00
|
|
|
} \
|
|
|
|
\
|
2020-07-23 09:56:49 +00:00
|
|
|
static __always_inline bool \
|
2020-09-04 15:32:28 +00:00
|
|
|
__seqprop_##lockname##_preemptible(const seqcount_##lockname##_t *s) \
|
2020-07-20 15:55:15 +00:00
|
|
|
{ \
|
2020-09-04 15:32:30 +00:00
|
|
|
if (!IS_ENABLED(CONFIG_PREEMPT_RT)) \
|
|
|
|
return preemptible; \
|
|
|
|
\
|
|
|
|
/* PREEMPT_RT relies on the above LOCK+UNLOCK */ \
|
|
|
|
return false; \
|
2020-07-20 15:55:15 +00:00
|
|
|
} \
|
|
|
|
\
|
2020-07-23 09:56:49 +00:00
|
|
|
static __always_inline void \
|
2020-09-04 15:32:28 +00:00
|
|
|
__seqprop_##lockname##_assert(const seqcount_##lockname##_t *s) \
|
2020-07-20 15:55:15 +00:00
|
|
|
{ \
|
2020-07-23 09:56:22 +00:00
|
|
|
__SEQ_LOCK(lockdep_assert_held(lockmember)); \
|
2020-07-20 15:55:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2020-07-23 09:56:49 +00:00
|
|
|
* __seqprop() for seqcount_t
|
2020-07-20 15:55:15 +00:00
|
|
|
*/
|
|
|
|
|
2020-09-04 15:32:28 +00:00
|
|
|
static inline seqcount_t *__seqprop_ptr(seqcount_t *s)
|
2020-07-20 15:55:15 +00:00
|
|
|
{
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
2020-09-04 15:32:29 +00:00
|
|
|
static inline unsigned __seqprop_sequence(const seqcount_t *s)
|
|
|
|
{
|
|
|
|
return READ_ONCE(s->sequence);
|
|
|
|
}
|
|
|
|
|
2020-09-04 15:32:28 +00:00
|
|
|
static inline bool __seqprop_preemptible(const seqcount_t *s)
|
2020-07-20 15:55:15 +00:00
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2020-09-04 15:32:28 +00:00
|
|
|
static inline void __seqprop_assert(const seqcount_t *s)
|
2020-07-20 15:55:15 +00:00
|
|
|
{
|
|
|
|
lockdep_assert_preemption_disabled();
|
|
|
|
}
|
|
|
|
|
2020-09-04 15:32:30 +00:00
|
|
|
#define __SEQ_RT IS_ENABLED(CONFIG_PREEMPT_RT)
|
|
|
|
|
|
|
|
SEQCOUNT_LOCKNAME(raw_spinlock, raw_spinlock_t, false, s->lock, raw_spin, raw_spin_lock(s->lock))
|
|
|
|
SEQCOUNT_LOCKNAME(spinlock, spinlock_t, __SEQ_RT, s->lock, spin, spin_lock(s->lock))
|
|
|
|
SEQCOUNT_LOCKNAME(rwlock, rwlock_t, __SEQ_RT, s->lock, read, read_lock(s->lock))
|
|
|
|
SEQCOUNT_LOCKNAME(mutex, struct mutex, true, s->lock, mutex, mutex_lock(s->lock))
|
|
|
|
SEQCOUNT_LOCKNAME(ww_mutex, struct ww_mutex, true, &s->lock->base, ww_mutex, ww_mutex_lock(s->lock, NULL))
|
2020-07-23 09:56:49 +00:00
|
|
|
|
2020-08-17 00:02:00 +00:00
|
|
|
/*
|
2020-07-23 10:03:13 +00:00
|
|
|
* SEQCNT_LOCKNAME_ZERO - static initializer for seqcount_LOCKNAME_t
|
|
|
|
* @name: Name of the seqcount_LOCKNAME_t instance
|
2020-09-04 15:32:27 +00:00
|
|
|
* @lock: Pointer to the associated LOCKNAME
|
2020-07-23 10:03:13 +00:00
|
|
|
*/
|
|
|
|
|
2020-09-04 15:32:27 +00:00
|
|
|
#define SEQCOUNT_LOCKNAME_ZERO(seq_name, assoc_lock) { \
|
2020-07-23 10:03:13 +00:00
|
|
|
.seqcount = SEQCNT_ZERO(seq_name.seqcount), \
|
|
|
|
__SEQ_LOCK(.lock = (assoc_lock)) \
|
|
|
|
}
|
|
|
|
|
2020-09-04 15:32:27 +00:00
|
|
|
#define SEQCNT_RAW_SPINLOCK_ZERO(name, lock) SEQCOUNT_LOCKNAME_ZERO(name, lock)
|
2020-09-15 14:30:28 +00:00
|
|
|
#define SEQCNT_SPINLOCK_ZERO(name, lock) SEQCOUNT_LOCKNAME_ZERO(name, lock)
|
2020-09-04 15:32:27 +00:00
|
|
|
#define SEQCNT_RWLOCK_ZERO(name, lock) SEQCOUNT_LOCKNAME_ZERO(name, lock)
|
|
|
|
#define SEQCNT_MUTEX_ZERO(name, lock) SEQCOUNT_LOCKNAME_ZERO(name, lock)
|
|
|
|
#define SEQCNT_WW_MUTEX_ZERO(name, lock) SEQCOUNT_LOCKNAME_ZERO(name, lock)
|
2020-07-23 10:03:13 +00:00
|
|
|
|
2020-07-23 09:56:49 +00:00
|
|
|
#define __seqprop_case(s, lockname, prop) \
|
2020-09-04 15:32:28 +00:00
|
|
|
seqcount_##lockname##_t: __seqprop_##lockname##_##prop((void *)(s))
|
2020-07-20 15:55:15 +00:00
|
|
|
|
|
|
|
#define __seqprop(s, prop) _Generic(*(s), \
|
2020-09-04 15:32:28 +00:00
|
|
|
seqcount_t: __seqprop_##prop((void *)(s)), \
|
2020-07-20 15:55:15 +00:00
|
|
|
__seqprop_case((s), raw_spinlock, prop), \
|
|
|
|
__seqprop_case((s), spinlock, prop), \
|
|
|
|
__seqprop_case((s), rwlock, prop), \
|
|
|
|
__seqprop_case((s), mutex, prop), \
|
|
|
|
__seqprop_case((s), ww_mutex, prop))
|
|
|
|
|
2020-07-23 10:11:49 +00:00
|
|
|
#define __seqcount_ptr(s) __seqprop(s, ptr)
|
2020-09-04 15:32:29 +00:00
|
|
|
#define __seqcount_sequence(s) __seqprop(s, sequence)
|
2020-07-23 10:11:49 +00:00
|
|
|
#define __seqcount_lock_preemptible(s) __seqprop(s, preemptible)
|
|
|
|
#define __seqcount_assert_lock_held(s) __seqprop(s, assert)
|
2020-07-20 15:55:15 +00:00
|
|
|
|
2011-01-07 06:49:51 +00:00
|
|
|
/**
|
2020-07-20 15:55:11 +00:00
|
|
|
* __read_seqcount_begin() - begin a seqcount_t read section w/o barrier
|
2020-09-04 15:32:27 +00:00
|
|
|
* @s: Pointer to seqcount_t or any of the seqcount_LOCKNAME_t variants
|
2011-01-07 06:49:51 +00:00
|
|
|
*
|
|
|
|
* __read_seqcount_begin is like read_seqcount_begin, but has no smp_rmb()
|
|
|
|
* barrier. Callers should ensure that smp_rmb() or equivalent ordering is
|
|
|
|
* provided before actually loading any of the variables that are to be
|
|
|
|
* protected in this critical section.
|
|
|
|
*
|
|
|
|
* Use carefully, only in critical code, and comment how the barrier is
|
|
|
|
* provided.
|
2020-07-20 15:55:11 +00:00
|
|
|
*
|
|
|
|
* Return: count to be passed to read_seqcount_retry()
|
2011-01-07 06:49:51 +00:00
|
|
|
*/
|
2020-07-20 15:55:15 +00:00
|
|
|
#define __read_seqcount_begin(s) \
|
2020-09-04 15:32:29 +00:00
|
|
|
({ \
|
|
|
|
unsigned seq; \
|
|
|
|
\
|
|
|
|
while ((seq = __seqcount_sequence(s)) & 1) \
|
|
|
|
cpu_relax(); \
|
|
|
|
\
|
|
|
|
kcsan_atomic_next(KCSAN_SEQLOCK_REGION_MAX); \
|
|
|
|
seq; \
|
|
|
|
})
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-10-07 22:51:59 +00:00
|
|
|
/**
|
2020-07-20 15:55:11 +00:00
|
|
|
* raw_read_seqcount_begin() - begin a seqcount_t read section w/o lockdep
|
2020-09-04 15:32:27 +00:00
|
|
|
* @s: Pointer to seqcount_t or any of the seqcount_LOCKNAME_t variants
|
2013-10-07 22:51:59 +00:00
|
|
|
*
|
2020-07-20 15:55:11 +00:00
|
|
|
* Return: count to be passed to read_seqcount_retry()
|
2013-10-07 22:51:59 +00:00
|
|
|
*/
|
2020-07-20 15:55:15 +00:00
|
|
|
#define raw_read_seqcount_begin(s) \
|
2020-09-04 15:32:29 +00:00
|
|
|
({ \
|
|
|
|
unsigned seq = __read_seqcount_begin(s); \
|
|
|
|
\
|
|
|
|
smp_rmb(); \
|
|
|
|
seq; \
|
|
|
|
})
|
2013-10-07 22:51:59 +00:00
|
|
|
|
2011-01-07 06:49:51 +00:00
|
|
|
/**
|
2020-07-20 15:55:11 +00:00
|
|
|
* read_seqcount_begin() - begin a seqcount_t read critical section
|
2020-09-04 15:32:27 +00:00
|
|
|
* @s: Pointer to seqcount_t or any of the seqcount_LOCKNAME_t variants
|
2011-01-07 06:49:51 +00:00
|
|
|
*
|
2020-07-20 15:55:11 +00:00
|
|
|
* Return: count to be passed to read_seqcount_retry()
|
2011-01-07 06:49:51 +00:00
|
|
|
*/
|
2020-07-20 15:55:15 +00:00
|
|
|
#define read_seqcount_begin(s) \
|
2020-09-04 15:32:29 +00:00
|
|
|
({ \
|
|
|
|
seqcount_lockdep_reader_access(__seqcount_ptr(s)); \
|
|
|
|
raw_read_seqcount_begin(s); \
|
|
|
|
})
|
2011-01-07 06:49:51 +00:00
|
|
|
|
2020-07-20 15:55:10 +00:00
|
|
|
/**
|
2020-07-20 15:55:11 +00:00
|
|
|
* raw_read_seqcount() - read the raw seqcount_t counter value
|
2020-09-04 15:32:27 +00:00
|
|
|
* @s: Pointer to seqcount_t or any of the seqcount_LOCKNAME_t variants
|
2020-07-20 15:55:10 +00:00
|
|
|
*
|
|
|
|
* raw_read_seqcount opens a read critical section of the given
|
2020-07-20 15:55:11 +00:00
|
|
|
* seqcount_t, without any lockdep checking, and without checking or
|
|
|
|
* masking the sequence counter LSB. Calling code is responsible for
|
|
|
|
* handling that.
|
|
|
|
*
|
|
|
|
* Return: count to be passed to read_seqcount_retry()
|
2020-07-20 15:55:10 +00:00
|
|
|
*/
|
2020-07-20 15:55:15 +00:00
|
|
|
#define raw_read_seqcount(s) \
|
2020-09-04 15:32:29 +00:00
|
|
|
({ \
|
|
|
|
unsigned seq = __seqcount_sequence(s); \
|
|
|
|
\
|
|
|
|
smp_rmb(); \
|
|
|
|
kcsan_atomic_next(KCSAN_SEQLOCK_REGION_MAX); \
|
|
|
|
seq; \
|
|
|
|
})
|
2020-07-20 15:55:10 +00:00
|
|
|
|
2012-05-04 22:13:54 +00:00
|
|
|
/**
|
2020-07-20 15:55:11 +00:00
|
|
|
* raw_seqcount_begin() - begin a seqcount_t read critical section w/o
|
|
|
|
* lockdep and w/o counter stabilization
|
2020-09-04 15:32:27 +00:00
|
|
|
* @s: Pointer to seqcount_t or any of the seqcount_LOCKNAME_t variants
|
2012-05-04 22:13:54 +00:00
|
|
|
*
|
2020-07-20 15:55:11 +00:00
|
|
|
* raw_seqcount_begin opens a read critical section of the given
|
|
|
|
* seqcount_t. Unlike read_seqcount_begin(), this function will not wait
|
|
|
|
* for the count to stabilize. If a writer is active when it begins, it
|
|
|
|
* will fail the read_seqcount_retry() at the end of the read critical
|
|
|
|
* section instead of stabilizing at the beginning of it.
|
2012-05-04 22:13:54 +00:00
|
|
|
*
|
2020-07-20 15:55:11 +00:00
|
|
|
* Use this only in special kernel hot paths where the read section is
|
|
|
|
* small and has a high probability of success through other external
|
|
|
|
* means. It will save a single branching instruction.
|
|
|
|
*
|
|
|
|
* Return: count to be passed to read_seqcount_retry()
|
2012-05-04 22:13:54 +00:00
|
|
|
*/
|
2020-07-20 15:55:15 +00:00
|
|
|
#define raw_seqcount_begin(s) \
|
2020-09-04 15:32:29 +00:00
|
|
|
({ \
|
|
|
|
/* \
|
|
|
|
* If the counter is odd, let read_seqcount_retry() fail \
|
|
|
|
* by decrementing the counter. \
|
|
|
|
*/ \
|
|
|
|
raw_read_seqcount(s) & ~1; \
|
|
|
|
})
|
2012-05-04 22:13:54 +00:00
|
|
|
|
2011-01-07 06:49:51 +00:00
|
|
|
/**
|
2020-07-20 15:55:11 +00:00
|
|
|
* __read_seqcount_retry() - end a seqcount_t read section w/o barrier
|
2020-09-04 15:32:27 +00:00
|
|
|
* @s: Pointer to seqcount_t or any of the seqcount_LOCKNAME_t variants
|
2020-07-20 15:55:11 +00:00
|
|
|
* @start: count, from read_seqcount_begin()
|
2011-01-07 06:49:51 +00:00
|
|
|
*
|
|
|
|
* __read_seqcount_retry is like read_seqcount_retry, but has no smp_rmb()
|
|
|
|
* barrier. Callers should ensure that smp_rmb() or equivalent ordering is
|
|
|
|
* provided before actually loading any of the variables that are to be
|
|
|
|
* protected in this critical section.
|
|
|
|
*
|
|
|
|
* Use carefully, only in critical code, and comment how the barrier is
|
|
|
|
* provided.
|
2020-07-20 15:55:11 +00:00
|
|
|
*
|
|
|
|
* Return: true if a read section retry is required, else false
|
2011-01-07 06:49:51 +00:00
|
|
|
*/
|
2020-07-20 15:55:15 +00:00
|
|
|
#define __read_seqcount_retry(s, start) \
|
2020-07-23 10:11:49 +00:00
|
|
|
__read_seqcount_t_retry(__seqcount_ptr(s), start)
|
2020-07-20 15:55:15 +00:00
|
|
|
|
|
|
|
static inline int __read_seqcount_t_retry(const seqcount_t *s, unsigned start)
|
2011-01-07 06:49:51 +00:00
|
|
|
{
|
seqlock, kcsan: Add annotations for KCSAN
Since seqlocks in the Linux kernel do not require the use of marked
atomic accesses in critical sections, we teach KCSAN to assume such
accesses are atomic. KCSAN currently also pretends that writes to
`sequence` are atomic, although currently plain writes are used (their
corresponding reads are READ_ONCE).
Further, to avoid false positives in the absence of clear ending of a
seqlock reader critical section (only when using the raw interface),
KCSAN assumes a fixed number of accesses after start of a seqlock
critical section are atomic.
=== Commentary on design around absence of clear begin/end markings ===
Seqlock usage via seqlock_t follows a predictable usage pattern, where
clear critical section begin/end is enforced. With subtle special cases
for readers needing to be flat atomic regions, e.g. because usage such
as in:
- fs/namespace.c:__legitimize_mnt - unbalanced read_seqretry
- fs/dcache.c:d_walk - unbalanced need_seqretry
But, anything directly accessing seqcount_t seems to be unpredictable.
Filtering for usage of read_seqcount_retry not following 'do { .. }
while (read_seqcount_retry(..));':
$ git grep 'read_seqcount_retry' | grep -Ev 'while \(|seqlock.h|Doc|\* '
=> about 1/3 of the total read_seqcount_retry usage.
Just looking at fs/namei.c, we conclude that it is non-trivial to
prescribe and migrate to an interface that would force clear begin/end
seqlock markings for critical sections.
As such, we concluded that the best design currently, is to simply
ensure that KCSAN works well with the existing code.
Signed-off-by: Marco Elver <elver@google.com>
Acked-by: Paul E. McKenney <paulmck@kernel.org>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2019-11-14 18:02:59 +00:00
|
|
|
kcsan_atomic_next(0);
|
|
|
|
return unlikely(READ_ONCE(s->sequence) != start);
|
2011-01-07 06:49:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2020-07-20 15:55:11 +00:00
|
|
|
* read_seqcount_retry() - end a seqcount_t read critical section
|
2020-09-04 15:32:27 +00:00
|
|
|
* @s: Pointer to seqcount_t or any of the seqcount_LOCKNAME_t variants
|
2020-07-20 15:55:11 +00:00
|
|
|
* @start: count, from read_seqcount_begin()
|
2011-01-07 06:49:51 +00:00
|
|
|
*
|
2020-07-20 15:55:11 +00:00
|
|
|
* read_seqcount_retry closes the read critical section of given
|
|
|
|
* seqcount_t. If the critical section was invalid, it must be ignored
|
|
|
|
* (and typically retried).
|
|
|
|
*
|
|
|
|
* Return: true if a read section retry is required, else false
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2020-07-20 15:55:15 +00:00
|
|
|
#define read_seqcount_retry(s, start) \
|
2020-07-23 10:11:49 +00:00
|
|
|
read_seqcount_t_retry(__seqcount_ptr(s), start)
|
2020-07-20 15:55:15 +00:00
|
|
|
|
|
|
|
static inline int read_seqcount_t_retry(const seqcount_t *s, unsigned start)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
smp_rmb();
|
2020-07-20 15:55:15 +00:00
|
|
|
return __read_seqcount_t_retry(s, start);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2020-07-20 15:55:11 +00:00
|
|
|
/**
|
|
|
|
* raw_write_seqcount_begin() - start a seqcount_t write section w/o lockdep
|
2020-09-04 15:32:27 +00:00
|
|
|
* @s: Pointer to seqcount_t or any of the seqcount_LOCKNAME_t variants
|
2020-07-20 15:55:11 +00:00
|
|
|
*/
|
2020-07-20 15:55:15 +00:00
|
|
|
#define raw_write_seqcount_begin(s) \
|
|
|
|
do { \
|
2020-07-23 10:11:49 +00:00
|
|
|
if (__seqcount_lock_preemptible(s)) \
|
2020-07-20 15:55:15 +00:00
|
|
|
preempt_disable(); \
|
|
|
|
\
|
2020-07-23 10:11:49 +00:00
|
|
|
raw_write_seqcount_t_begin(__seqcount_ptr(s)); \
|
2020-07-20 15:55:15 +00:00
|
|
|
} while (0)
|
|
|
|
|
|
|
|
static inline void raw_write_seqcount_t_begin(seqcount_t *s)
|
2014-01-02 23:11:13 +00:00
|
|
|
{
|
seqlock, kcsan: Add annotations for KCSAN
Since seqlocks in the Linux kernel do not require the use of marked
atomic accesses in critical sections, we teach KCSAN to assume such
accesses are atomic. KCSAN currently also pretends that writes to
`sequence` are atomic, although currently plain writes are used (their
corresponding reads are READ_ONCE).
Further, to avoid false positives in the absence of clear ending of a
seqlock reader critical section (only when using the raw interface),
KCSAN assumes a fixed number of accesses after start of a seqlock
critical section are atomic.
=== Commentary on design around absence of clear begin/end markings ===
Seqlock usage via seqlock_t follows a predictable usage pattern, where
clear critical section begin/end is enforced. With subtle special cases
for readers needing to be flat atomic regions, e.g. because usage such
as in:
- fs/namespace.c:__legitimize_mnt - unbalanced read_seqretry
- fs/dcache.c:d_walk - unbalanced need_seqretry
But, anything directly accessing seqcount_t seems to be unpredictable.
Filtering for usage of read_seqcount_retry not following 'do { .. }
while (read_seqcount_retry(..));':
$ git grep 'read_seqcount_retry' | grep -Ev 'while \(|seqlock.h|Doc|\* '
=> about 1/3 of the total read_seqcount_retry usage.
Just looking at fs/namei.c, we conclude that it is non-trivial to
prescribe and migrate to an interface that would force clear begin/end
seqlock markings for critical sections.
As such, we concluded that the best design currently, is to simply
ensure that KCSAN works well with the existing code.
Signed-off-by: Marco Elver <elver@google.com>
Acked-by: Paul E. McKenney <paulmck@kernel.org>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2019-11-14 18:02:59 +00:00
|
|
|
kcsan_nestable_atomic_begin();
|
2014-01-02 23:11:13 +00:00
|
|
|
s->sequence++;
|
|
|
|
smp_wmb();
|
|
|
|
}
|
|
|
|
|
2020-07-20 15:55:11 +00:00
|
|
|
/**
|
|
|
|
* raw_write_seqcount_end() - end a seqcount_t write section w/o lockdep
|
2020-09-04 15:32:27 +00:00
|
|
|
* @s: Pointer to seqcount_t or any of the seqcount_LOCKNAME_t variants
|
2020-07-20 15:55:11 +00:00
|
|
|
*/
|
2020-07-20 15:55:15 +00:00
|
|
|
#define raw_write_seqcount_end(s) \
|
|
|
|
do { \
|
2020-07-23 10:11:49 +00:00
|
|
|
raw_write_seqcount_t_end(__seqcount_ptr(s)); \
|
2020-07-20 15:55:15 +00:00
|
|
|
\
|
2020-07-23 10:11:49 +00:00
|
|
|
if (__seqcount_lock_preemptible(s)) \
|
2020-07-20 15:55:15 +00:00
|
|
|
preempt_enable(); \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
static inline void raw_write_seqcount_t_end(seqcount_t *s)
|
2014-01-02 23:11:13 +00:00
|
|
|
{
|
|
|
|
smp_wmb();
|
|
|
|
s->sequence++;
|
seqlock, kcsan: Add annotations for KCSAN
Since seqlocks in the Linux kernel do not require the use of marked
atomic accesses in critical sections, we teach KCSAN to assume such
accesses are atomic. KCSAN currently also pretends that writes to
`sequence` are atomic, although currently plain writes are used (their
corresponding reads are READ_ONCE).
Further, to avoid false positives in the absence of clear ending of a
seqlock reader critical section (only when using the raw interface),
KCSAN assumes a fixed number of accesses after start of a seqlock
critical section are atomic.
=== Commentary on design around absence of clear begin/end markings ===
Seqlock usage via seqlock_t follows a predictable usage pattern, where
clear critical section begin/end is enforced. With subtle special cases
for readers needing to be flat atomic regions, e.g. because usage such
as in:
- fs/namespace.c:__legitimize_mnt - unbalanced read_seqretry
- fs/dcache.c:d_walk - unbalanced need_seqretry
But, anything directly accessing seqcount_t seems to be unpredictable.
Filtering for usage of read_seqcount_retry not following 'do { .. }
while (read_seqcount_retry(..));':
$ git grep 'read_seqcount_retry' | grep -Ev 'while \(|seqlock.h|Doc|\* '
=> about 1/3 of the total read_seqcount_retry usage.
Just looking at fs/namei.c, we conclude that it is non-trivial to
prescribe and migrate to an interface that would force clear begin/end
seqlock markings for critical sections.
As such, we concluded that the best design currently, is to simply
ensure that KCSAN works well with the existing code.
Signed-off-by: Marco Elver <elver@google.com>
Acked-by: Paul E. McKenney <paulmck@kernel.org>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2019-11-14 18:02:59 +00:00
|
|
|
kcsan_nestable_atomic_end();
|
2014-01-02 23:11:13 +00:00
|
|
|
}
|
|
|
|
|
2020-07-20 15:55:11 +00:00
|
|
|
/**
|
|
|
|
* write_seqcount_begin_nested() - start a seqcount_t write section with
|
|
|
|
* custom lockdep nesting level
|
2020-09-04 15:32:27 +00:00
|
|
|
* @s: Pointer to seqcount_t or any of the seqcount_LOCKNAME_t variants
|
2020-07-20 15:55:11 +00:00
|
|
|
* @subclass: lockdep nesting level
|
|
|
|
*
|
|
|
|
* See Documentation/locking/lockdep-design.rst
|
|
|
|
*/
|
2020-07-20 15:55:15 +00:00
|
|
|
#define write_seqcount_begin_nested(s, subclass) \
|
|
|
|
do { \
|
2020-07-23 10:11:49 +00:00
|
|
|
__seqcount_assert_lock_held(s); \
|
2020-07-20 15:55:15 +00:00
|
|
|
\
|
2020-07-23 10:11:49 +00:00
|
|
|
if (__seqcount_lock_preemptible(s)) \
|
2020-07-20 15:55:15 +00:00
|
|
|
preempt_disable(); \
|
|
|
|
\
|
2020-07-23 10:11:49 +00:00
|
|
|
write_seqcount_t_begin_nested(__seqcount_ptr(s), subclass); \
|
2020-07-20 15:55:15 +00:00
|
|
|
} while (0)
|
2020-07-20 15:55:14 +00:00
|
|
|
|
2020-07-20 15:55:15 +00:00
|
|
|
static inline void write_seqcount_t_begin_nested(seqcount_t *s, int subclass)
|
2020-07-20 15:55:14 +00:00
|
|
|
{
|
2020-07-20 15:55:15 +00:00
|
|
|
raw_write_seqcount_t_begin(s);
|
|
|
|
seqcount_acquire(&s->dep_map, subclass, 0, _RET_IP_);
|
2020-07-20 15:55:10 +00:00
|
|
|
}
|
|
|
|
|
2020-07-20 15:55:11 +00:00
|
|
|
/**
|
|
|
|
* write_seqcount_begin() - start a seqcount_t write side critical section
|
2020-09-04 15:32:27 +00:00
|
|
|
* @s: Pointer to seqcount_t or any of the seqcount_LOCKNAME_t variants
|
2020-07-20 15:55:11 +00:00
|
|
|
*
|
|
|
|
* write_seqcount_begin opens a write side critical section of the given
|
|
|
|
* seqcount_t.
|
|
|
|
*
|
|
|
|
* Context: seqcount_t write side critical sections must be serialized and
|
|
|
|
* non-preemptible. If readers can be invoked from hardirq or softirq
|
|
|
|
* context, interrupts or bottom halves must be respectively disabled.
|
|
|
|
*/
|
2020-07-20 15:55:15 +00:00
|
|
|
#define write_seqcount_begin(s) \
|
|
|
|
do { \
|
2020-07-23 10:11:49 +00:00
|
|
|
__seqcount_assert_lock_held(s); \
|
2020-07-20 15:55:15 +00:00
|
|
|
\
|
2020-07-23 10:11:49 +00:00
|
|
|
if (__seqcount_lock_preemptible(s)) \
|
2020-07-20 15:55:15 +00:00
|
|
|
preempt_disable(); \
|
|
|
|
\
|
2020-07-23 10:11:49 +00:00
|
|
|
write_seqcount_t_begin(__seqcount_ptr(s)); \
|
2020-07-20 15:55:15 +00:00
|
|
|
} while (0)
|
|
|
|
|
|
|
|
static inline void write_seqcount_t_begin(seqcount_t *s)
|
2020-07-20 15:55:10 +00:00
|
|
|
{
|
2020-07-20 15:55:15 +00:00
|
|
|
write_seqcount_t_begin_nested(s, 0);
|
2020-07-20 15:55:10 +00:00
|
|
|
}
|
|
|
|
|
2020-07-20 15:55:11 +00:00
|
|
|
/**
|
|
|
|
* write_seqcount_end() - end a seqcount_t write side critical section
|
2020-09-04 15:32:27 +00:00
|
|
|
* @s: Pointer to seqcount_t or any of the seqcount_LOCKNAME_t variants
|
2020-07-20 15:55:11 +00:00
|
|
|
*
|
|
|
|
* The write section must've been opened with write_seqcount_begin().
|
|
|
|
*/
|
2020-07-20 15:55:15 +00:00
|
|
|
#define write_seqcount_end(s) \
|
|
|
|
do { \
|
2020-07-23 10:11:49 +00:00
|
|
|
write_seqcount_t_end(__seqcount_ptr(s)); \
|
2020-07-20 15:55:15 +00:00
|
|
|
\
|
2020-07-23 10:11:49 +00:00
|
|
|
if (__seqcount_lock_preemptible(s)) \
|
2020-07-20 15:55:15 +00:00
|
|
|
preempt_enable(); \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
static inline void write_seqcount_t_end(seqcount_t *s)
|
2020-07-20 15:55:10 +00:00
|
|
|
{
|
|
|
|
seqcount_release(&s->dep_map, _RET_IP_);
|
2020-07-20 15:55:15 +00:00
|
|
|
raw_write_seqcount_t_end(s);
|
2020-07-20 15:55:10 +00:00
|
|
|
}
|
|
|
|
|
2015-06-17 12:29:24 +00:00
|
|
|
/**
|
2020-07-20 15:55:11 +00:00
|
|
|
* raw_write_seqcount_barrier() - do a seqcount_t write barrier
|
2020-09-04 15:32:27 +00:00
|
|
|
* @s: Pointer to seqcount_t or any of the seqcount_LOCKNAME_t variants
|
2015-06-17 12:29:24 +00:00
|
|
|
*
|
2020-07-20 15:55:11 +00:00
|
|
|
* This can be used to provide an ordering guarantee instead of the usual
|
|
|
|
* consistency guarantee. It is one wmb cheaper, because it can collapse
|
|
|
|
* the two back-to-back wmb()s.
|
2015-06-17 12:29:24 +00:00
|
|
|
*
|
2019-11-20 09:41:43 +00:00
|
|
|
* Note that writes surrounding the barrier should be declared atomic (e.g.
|
2019-11-14 18:03:00 +00:00
|
|
|
* via WRITE_ONCE): a) to ensure the writes become visible to other threads
|
|
|
|
* atomically, avoiding compiler optimizations; b) to document which writes are
|
|
|
|
* meant to propagate to the reader critical section. This is necessary because
|
|
|
|
* neither writes before and after the barrier are enclosed in a seq-writer
|
2020-07-20 15:55:08 +00:00
|
|
|
* critical section that would ensure readers are aware of ongoing writes::
|
2019-11-14 18:03:00 +00:00
|
|
|
*
|
2020-07-20 15:55:08 +00:00
|
|
|
* seqcount_t seq;
|
|
|
|
* bool X = true, Y = false;
|
2015-06-17 12:29:24 +00:00
|
|
|
*
|
2020-07-20 15:55:08 +00:00
|
|
|
* void read(void)
|
|
|
|
* {
|
|
|
|
* bool x, y;
|
2015-06-17 12:29:24 +00:00
|
|
|
*
|
2020-07-20 15:55:08 +00:00
|
|
|
* do {
|
|
|
|
* int s = read_seqcount_begin(&seq);
|
2015-06-17 12:29:24 +00:00
|
|
|
*
|
2020-07-20 15:55:08 +00:00
|
|
|
* x = X; y = Y;
|
2015-06-17 12:29:24 +00:00
|
|
|
*
|
2020-07-20 15:55:08 +00:00
|
|
|
* } while (read_seqcount_retry(&seq, s));
|
2015-06-17 12:29:24 +00:00
|
|
|
*
|
2020-07-20 15:55:08 +00:00
|
|
|
* BUG_ON(!x && !y);
|
2015-06-17 12:29:24 +00:00
|
|
|
* }
|
|
|
|
*
|
|
|
|
* void write(void)
|
|
|
|
* {
|
2020-07-20 15:55:08 +00:00
|
|
|
* WRITE_ONCE(Y, true);
|
2015-06-17 12:29:24 +00:00
|
|
|
*
|
2020-07-20 15:55:08 +00:00
|
|
|
* raw_write_seqcount_barrier(seq);
|
2015-06-17 12:29:24 +00:00
|
|
|
*
|
2020-07-20 15:55:08 +00:00
|
|
|
* WRITE_ONCE(X, false);
|
2015-06-17 12:29:24 +00:00
|
|
|
* }
|
|
|
|
*/
|
2020-07-20 15:55:15 +00:00
|
|
|
#define raw_write_seqcount_barrier(s) \
|
2020-07-23 10:11:49 +00:00
|
|
|
raw_write_seqcount_t_barrier(__seqcount_ptr(s))
|
2020-07-20 15:55:15 +00:00
|
|
|
|
|
|
|
static inline void raw_write_seqcount_t_barrier(seqcount_t *s)
|
2015-06-17 12:29:24 +00:00
|
|
|
{
|
seqlock, kcsan: Add annotations for KCSAN
Since seqlocks in the Linux kernel do not require the use of marked
atomic accesses in critical sections, we teach KCSAN to assume such
accesses are atomic. KCSAN currently also pretends that writes to
`sequence` are atomic, although currently plain writes are used (their
corresponding reads are READ_ONCE).
Further, to avoid false positives in the absence of clear ending of a
seqlock reader critical section (only when using the raw interface),
KCSAN assumes a fixed number of accesses after start of a seqlock
critical section are atomic.
=== Commentary on design around absence of clear begin/end markings ===
Seqlock usage via seqlock_t follows a predictable usage pattern, where
clear critical section begin/end is enforced. With subtle special cases
for readers needing to be flat atomic regions, e.g. because usage such
as in:
- fs/namespace.c:__legitimize_mnt - unbalanced read_seqretry
- fs/dcache.c:d_walk - unbalanced need_seqretry
But, anything directly accessing seqcount_t seems to be unpredictable.
Filtering for usage of read_seqcount_retry not following 'do { .. }
while (read_seqcount_retry(..));':
$ git grep 'read_seqcount_retry' | grep -Ev 'while \(|seqlock.h|Doc|\* '
=> about 1/3 of the total read_seqcount_retry usage.
Just looking at fs/namei.c, we conclude that it is non-trivial to
prescribe and migrate to an interface that would force clear begin/end
seqlock markings for critical sections.
As such, we concluded that the best design currently, is to simply
ensure that KCSAN works well with the existing code.
Signed-off-by: Marco Elver <elver@google.com>
Acked-by: Paul E. McKenney <paulmck@kernel.org>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2019-11-14 18:02:59 +00:00
|
|
|
kcsan_nestable_atomic_begin();
|
2015-06-17 12:29:24 +00:00
|
|
|
s->sequence++;
|
|
|
|
smp_wmb();
|
|
|
|
s->sequence++;
|
seqlock, kcsan: Add annotations for KCSAN
Since seqlocks in the Linux kernel do not require the use of marked
atomic accesses in critical sections, we teach KCSAN to assume such
accesses are atomic. KCSAN currently also pretends that writes to
`sequence` are atomic, although currently plain writes are used (their
corresponding reads are READ_ONCE).
Further, to avoid false positives in the absence of clear ending of a
seqlock reader critical section (only when using the raw interface),
KCSAN assumes a fixed number of accesses after start of a seqlock
critical section are atomic.
=== Commentary on design around absence of clear begin/end markings ===
Seqlock usage via seqlock_t follows a predictable usage pattern, where
clear critical section begin/end is enforced. With subtle special cases
for readers needing to be flat atomic regions, e.g. because usage such
as in:
- fs/namespace.c:__legitimize_mnt - unbalanced read_seqretry
- fs/dcache.c:d_walk - unbalanced need_seqretry
But, anything directly accessing seqcount_t seems to be unpredictable.
Filtering for usage of read_seqcount_retry not following 'do { .. }
while (read_seqcount_retry(..));':
$ git grep 'read_seqcount_retry' | grep -Ev 'while \(|seqlock.h|Doc|\* '
=> about 1/3 of the total read_seqcount_retry usage.
Just looking at fs/namei.c, we conclude that it is non-trivial to
prescribe and migrate to an interface that would force clear begin/end
seqlock markings for critical sections.
As such, we concluded that the best design currently, is to simply
ensure that KCSAN works well with the existing code.
Signed-off-by: Marco Elver <elver@google.com>
Acked-by: Paul E. McKenney <paulmck@kernel.org>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2019-11-14 18:02:59 +00:00
|
|
|
kcsan_nestable_atomic_end();
|
2015-06-17 12:29:24 +00:00
|
|
|
}
|
|
|
|
|
2020-07-20 15:55:10 +00:00
|
|
|
/**
|
2020-07-20 15:55:11 +00:00
|
|
|
* write_seqcount_invalidate() - invalidate in-progress seqcount_t read
|
|
|
|
* side operations
|
2020-09-04 15:32:27 +00:00
|
|
|
* @s: Pointer to seqcount_t or any of the seqcount_LOCKNAME_t variants
|
2020-07-20 15:55:10 +00:00
|
|
|
*
|
2020-07-20 15:55:11 +00:00
|
|
|
* After write_seqcount_invalidate, no seqcount_t read side operations
|
|
|
|
* will complete successfully and see data older than this.
|
2020-07-20 15:55:10 +00:00
|
|
|
*/
|
2020-07-20 15:55:15 +00:00
|
|
|
#define write_seqcount_invalidate(s) \
|
2020-07-23 10:11:49 +00:00
|
|
|
write_seqcount_t_invalidate(__seqcount_ptr(s))
|
2020-07-20 15:55:15 +00:00
|
|
|
|
|
|
|
static inline void write_seqcount_t_invalidate(seqcount_t *s)
|
2020-07-20 15:55:10 +00:00
|
|
|
{
|
|
|
|
smp_wmb();
|
|
|
|
kcsan_nestable_atomic_begin();
|
|
|
|
s->sequence+=2;
|
|
|
|
kcsan_nestable_atomic_end();
|
|
|
|
}
|
|
|
|
|
2020-08-27 11:40:39 +00:00
|
|
|
/*
|
|
|
|
* Latch sequence counters (seqcount_latch_t)
|
2020-07-20 15:55:11 +00:00
|
|
|
*
|
2020-08-27 11:40:39 +00:00
|
|
|
* A sequence counter variant where the counter even/odd value is used to
|
|
|
|
* switch between two copies of protected data. This allows the read path,
|
|
|
|
* typically NMIs, to safely interrupt the write side critical section.
|
2020-07-20 15:55:11 +00:00
|
|
|
*
|
2020-08-27 11:40:39 +00:00
|
|
|
* As the write sections are fully preemptible, no special handling for
|
|
|
|
* PREEMPT_RT is needed.
|
|
|
|
*/
|
|
|
|
typedef struct {
|
|
|
|
seqcount_t seqcount;
|
|
|
|
} seqcount_latch_t;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* SEQCNT_LATCH_ZERO() - static initializer for seqcount_latch_t
|
|
|
|
* @seq_name: Name of the seqcount_latch_t instance
|
|
|
|
*/
|
|
|
|
#define SEQCNT_LATCH_ZERO(seq_name) { \
|
|
|
|
.seqcount = SEQCNT_ZERO(seq_name.seqcount), \
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* seqcount_latch_init() - runtime initializer for seqcount_latch_t
|
|
|
|
* @s: Pointer to the seqcount_latch_t instance
|
|
|
|
*/
|
|
|
|
static inline void seqcount_latch_init(seqcount_latch_t *s)
|
|
|
|
{
|
|
|
|
seqcount_init(&s->seqcount);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* raw_read_seqcount_latch() - pick even/odd latch data copy
|
2020-08-27 11:40:44 +00:00
|
|
|
* @s: Pointer to seqcount_latch_t
|
2020-08-27 11:40:39 +00:00
|
|
|
*
|
|
|
|
* See raw_write_seqcount_latch() for details and a full reader/writer
|
|
|
|
* usage example.
|
2020-07-20 15:55:11 +00:00
|
|
|
*
|
|
|
|
* Return: sequence counter raw value. Use the lowest bit as an index for
|
2020-08-27 11:40:39 +00:00
|
|
|
* picking which data copy to read. The full counter must then be checked
|
|
|
|
* with read_seqcount_latch_retry().
|
2020-07-20 15:55:11 +00:00
|
|
|
*/
|
2020-08-27 11:40:44 +00:00
|
|
|
static inline unsigned raw_read_seqcount_latch(const seqcount_latch_t *s)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Pairs with the first smp_wmb() in raw_write_seqcount_latch().
|
|
|
|
* Due to the dependent load, a full smp_rmb() is not needed.
|
|
|
|
*/
|
|
|
|
return READ_ONCE(s->seqcount.sequence);
|
|
|
|
}
|
2020-07-20 15:55:15 +00:00
|
|
|
|
2020-08-27 11:40:39 +00:00
|
|
|
/**
|
|
|
|
* read_seqcount_latch_retry() - end a seqcount_latch_t read section
|
|
|
|
* @s: Pointer to seqcount_latch_t
|
|
|
|
* @start: count, from raw_read_seqcount_latch()
|
|
|
|
*
|
|
|
|
* Return: true if a read section retry is required, else false
|
|
|
|
*/
|
|
|
|
static inline int
|
|
|
|
read_seqcount_latch_retry(const seqcount_latch_t *s, unsigned start)
|
2015-05-27 01:39:36 +00:00
|
|
|
{
|
2020-08-27 11:40:39 +00:00
|
|
|
return read_seqcount_retry(&s->seqcount, start);
|
2015-05-27 01:39:36 +00:00
|
|
|
}
|
|
|
|
|
2015-05-27 01:39:36 +00:00
|
|
|
/**
|
2020-08-27 11:40:39 +00:00
|
|
|
* raw_write_seqcount_latch() - redirect latch readers to even/odd copy
|
2020-08-27 11:40:44 +00:00
|
|
|
* @s: Pointer to seqcount_latch_t
|
2015-05-27 01:39:36 +00:00
|
|
|
*
|
|
|
|
* The latch technique is a multiversion concurrency control method that allows
|
|
|
|
* queries during non-atomic modifications. If you can guarantee queries never
|
|
|
|
* interrupt the modification -- e.g. the concurrency is strictly between CPUs
|
|
|
|
* -- you most likely do not need this.
|
|
|
|
*
|
|
|
|
* Where the traditional RCU/lockless data structures rely on atomic
|
|
|
|
* modifications to ensure queries observe either the old or the new state the
|
|
|
|
* latch allows the same for non-atomic updates. The trade-off is doubling the
|
|
|
|
* cost of storage; we have to maintain two copies of the entire data
|
|
|
|
* structure.
|
|
|
|
*
|
|
|
|
* Very simply put: we first modify one copy and then the other. This ensures
|
|
|
|
* there is always one copy in a stable state, ready to give us an answer.
|
|
|
|
*
|
2020-07-20 15:55:08 +00:00
|
|
|
* The basic form is a data structure like::
|
2015-05-27 01:39:36 +00:00
|
|
|
*
|
2020-07-20 15:55:08 +00:00
|
|
|
* struct latch_struct {
|
2020-08-27 11:40:39 +00:00
|
|
|
* seqcount_latch_t seq;
|
2020-07-20 15:55:08 +00:00
|
|
|
* struct data_struct data[2];
|
|
|
|
* };
|
2015-05-27 01:39:36 +00:00
|
|
|
*
|
|
|
|
* Where a modification, which is assumed to be externally serialized, does the
|
2020-07-20 15:55:08 +00:00
|
|
|
* following::
|
2015-05-27 01:39:36 +00:00
|
|
|
*
|
2020-07-20 15:55:08 +00:00
|
|
|
* void latch_modify(struct latch_struct *latch, ...)
|
|
|
|
* {
|
|
|
|
* smp_wmb(); // Ensure that the last data[1] update is visible
|
2020-08-27 11:40:39 +00:00
|
|
|
* latch->seq.sequence++;
|
2020-07-20 15:55:08 +00:00
|
|
|
* smp_wmb(); // Ensure that the seqcount update is visible
|
2015-05-27 01:39:36 +00:00
|
|
|
*
|
2020-07-20 15:55:08 +00:00
|
|
|
* modify(latch->data[0], ...);
|
2015-05-27 01:39:36 +00:00
|
|
|
*
|
2020-07-20 15:55:08 +00:00
|
|
|
* smp_wmb(); // Ensure that the data[0] update is visible
|
2020-08-27 11:40:39 +00:00
|
|
|
* latch->seq.sequence++;
|
2020-07-20 15:55:08 +00:00
|
|
|
* smp_wmb(); // Ensure that the seqcount update is visible
|
2015-05-27 01:39:36 +00:00
|
|
|
*
|
2020-07-20 15:55:08 +00:00
|
|
|
* modify(latch->data[1], ...);
|
|
|
|
* }
|
2015-05-27 01:39:36 +00:00
|
|
|
*
|
2020-07-20 15:55:08 +00:00
|
|
|
* The query will have a form like::
|
2015-05-27 01:39:36 +00:00
|
|
|
*
|
2020-07-20 15:55:08 +00:00
|
|
|
* struct entry *latch_query(struct latch_struct *latch, ...)
|
|
|
|
* {
|
|
|
|
* struct entry *entry;
|
|
|
|
* unsigned seq, idx;
|
2015-05-27 01:39:36 +00:00
|
|
|
*
|
2020-07-20 15:55:08 +00:00
|
|
|
* do {
|
|
|
|
* seq = raw_read_seqcount_latch(&latch->seq);
|
2015-05-27 01:39:36 +00:00
|
|
|
*
|
2020-07-20 15:55:08 +00:00
|
|
|
* idx = seq & 0x01;
|
|
|
|
* entry = data_query(latch->data[idx], ...);
|
2015-05-27 01:39:36 +00:00
|
|
|
*
|
2020-08-27 11:40:39 +00:00
|
|
|
* // This includes needed smp_rmb()
|
|
|
|
* } while (read_seqcount_latch_retry(&latch->seq, seq));
|
2015-05-27 01:39:36 +00:00
|
|
|
*
|
2020-07-20 15:55:08 +00:00
|
|
|
* return entry;
|
|
|
|
* }
|
2015-05-27 01:39:36 +00:00
|
|
|
*
|
|
|
|
* So during the modification, queries are first redirected to data[1]. Then we
|
|
|
|
* modify data[0]. When that is complete, we redirect queries back to data[0]
|
|
|
|
* and we can modify data[1].
|
|
|
|
*
|
2020-07-20 15:55:08 +00:00
|
|
|
* NOTE:
|
|
|
|
*
|
|
|
|
* The non-requirement for atomic modifications does _NOT_ include
|
|
|
|
* the publishing of new entries in the case where data is a dynamic
|
|
|
|
* data structure.
|
|
|
|
*
|
|
|
|
* An iteration might start in data[0] and get suspended long enough
|
|
|
|
* to miss an entire modification sequence, once it resumes it might
|
|
|
|
* observe the new entry.
|
2015-05-27 01:39:36 +00:00
|
|
|
*
|
2020-08-17 00:02:00 +00:00
|
|
|
* NOTE2:
|
2015-05-27 01:39:36 +00:00
|
|
|
*
|
2020-07-20 15:55:08 +00:00
|
|
|
* When data is a dynamic data structure; one should use regular RCU
|
|
|
|
* patterns to manage the lifetimes of the objects within.
|
2014-07-16 21:05:21 +00:00
|
|
|
*/
|
2020-08-27 11:40:44 +00:00
|
|
|
static inline void raw_write_seqcount_latch(seqcount_latch_t *s)
|
|
|
|
{
|
|
|
|
smp_wmb(); /* prior stores before incrementing "sequence" */
|
|
|
|
s->seqcount.sequence++;
|
|
|
|
smp_wmb(); /* increment "sequence" before following stores */
|
2014-07-16 21:05:21 +00:00
|
|
|
}
|
|
|
|
|
2020-07-20 15:55:07 +00:00
|
|
|
/*
|
|
|
|
* Sequential locks (seqlock_t)
|
|
|
|
*
|
|
|
|
* Sequence counters with an embedded spinlock for writer serialization
|
|
|
|
* and non-preemptibility.
|
|
|
|
*
|
|
|
|
* For more info, see:
|
|
|
|
* - Comments on top of seqcount_t
|
|
|
|
* - Documentation/locking/seqlock.rst
|
|
|
|
*/
|
2011-07-16 16:40:26 +00:00
|
|
|
typedef struct {
|
2020-09-04 15:32:31 +00:00
|
|
|
/*
|
|
|
|
* 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;
|
2011-07-16 16:40:26 +00:00
|
|
|
spinlock_t lock;
|
|
|
|
} seqlock_t;
|
|
|
|
|
2020-07-20 15:55:16 +00:00
|
|
|
#define __SEQLOCK_UNLOCKED(lockname) \
|
|
|
|
{ \
|
2020-09-04 15:32:31 +00:00
|
|
|
.seqcount = SEQCNT_SPINLOCK_ZERO(lockname, &(lockname).lock), \
|
2020-07-20 15:55:16 +00:00
|
|
|
.lock = __SPIN_LOCK_UNLOCKED(lockname) \
|
2011-07-16 16:40:26 +00:00
|
|
|
}
|
|
|
|
|
2020-07-20 15:55:11 +00:00
|
|
|
/**
|
|
|
|
* seqlock_init() - dynamic initializer for seqlock_t
|
|
|
|
* @sl: Pointer to the seqlock_t instance
|
|
|
|
*/
|
2020-07-20 15:55:16 +00:00
|
|
|
#define seqlock_init(sl) \
|
|
|
|
do { \
|
|
|
|
spin_lock_init(&(sl)->lock); \
|
2020-09-04 15:32:31 +00:00
|
|
|
seqcount_spinlock_init(&(sl)->seqcount, &(sl)->lock); \
|
2011-07-16 16:40:26 +00:00
|
|
|
} while (0)
|
|
|
|
|
2020-07-20 15:55:11 +00:00
|
|
|
/**
|
2020-09-24 15:48:51 +00:00
|
|
|
* DEFINE_SEQLOCK(sl) - Define a statically allocated seqlock_t
|
2020-07-20 15:55:11 +00:00
|
|
|
* @sl: Name of the seqlock_t instance
|
|
|
|
*/
|
|
|
|
#define DEFINE_SEQLOCK(sl) \
|
|
|
|
seqlock_t sl = __SEQLOCK_UNLOCKED(sl)
|
2011-07-16 16:40:26 +00:00
|
|
|
|
2020-07-20 15:55:11 +00:00
|
|
|
/**
|
|
|
|
* read_seqbegin() - start a seqlock_t read side critical section
|
|
|
|
* @sl: Pointer to seqlock_t
|
|
|
|
*
|
|
|
|
* Return: count, to be passed to read_seqretry()
|
2011-07-16 16:40:26 +00:00
|
|
|
*/
|
|
|
|
static inline unsigned read_seqbegin(const seqlock_t *sl)
|
|
|
|
{
|
seqlock, kcsan: Add annotations for KCSAN
Since seqlocks in the Linux kernel do not require the use of marked
atomic accesses in critical sections, we teach KCSAN to assume such
accesses are atomic. KCSAN currently also pretends that writes to
`sequence` are atomic, although currently plain writes are used (their
corresponding reads are READ_ONCE).
Further, to avoid false positives in the absence of clear ending of a
seqlock reader critical section (only when using the raw interface),
KCSAN assumes a fixed number of accesses after start of a seqlock
critical section are atomic.
=== Commentary on design around absence of clear begin/end markings ===
Seqlock usage via seqlock_t follows a predictable usage pattern, where
clear critical section begin/end is enforced. With subtle special cases
for readers needing to be flat atomic regions, e.g. because usage such
as in:
- fs/namespace.c:__legitimize_mnt - unbalanced read_seqretry
- fs/dcache.c:d_walk - unbalanced need_seqretry
But, anything directly accessing seqcount_t seems to be unpredictable.
Filtering for usage of read_seqcount_retry not following 'do { .. }
while (read_seqcount_retry(..));':
$ git grep 'read_seqcount_retry' | grep -Ev 'while \(|seqlock.h|Doc|\* '
=> about 1/3 of the total read_seqcount_retry usage.
Just looking at fs/namei.c, we conclude that it is non-trivial to
prescribe and migrate to an interface that would force clear begin/end
seqlock markings for critical sections.
As such, we concluded that the best design currently, is to simply
ensure that KCSAN works well with the existing code.
Signed-off-by: Marco Elver <elver@google.com>
Acked-by: Paul E. McKenney <paulmck@kernel.org>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2019-11-14 18:02:59 +00:00
|
|
|
unsigned ret = read_seqcount_begin(&sl->seqcount);
|
|
|
|
|
2019-11-20 09:41:43 +00:00
|
|
|
kcsan_atomic_next(0); /* non-raw usage, assume closing read_seqretry() */
|
seqlock, kcsan: Add annotations for KCSAN
Since seqlocks in the Linux kernel do not require the use of marked
atomic accesses in critical sections, we teach KCSAN to assume such
accesses are atomic. KCSAN currently also pretends that writes to
`sequence` are atomic, although currently plain writes are used (their
corresponding reads are READ_ONCE).
Further, to avoid false positives in the absence of clear ending of a
seqlock reader critical section (only when using the raw interface),
KCSAN assumes a fixed number of accesses after start of a seqlock
critical section are atomic.
=== Commentary on design around absence of clear begin/end markings ===
Seqlock usage via seqlock_t follows a predictable usage pattern, where
clear critical section begin/end is enforced. With subtle special cases
for readers needing to be flat atomic regions, e.g. because usage such
as in:
- fs/namespace.c:__legitimize_mnt - unbalanced read_seqretry
- fs/dcache.c:d_walk - unbalanced need_seqretry
But, anything directly accessing seqcount_t seems to be unpredictable.
Filtering for usage of read_seqcount_retry not following 'do { .. }
while (read_seqcount_retry(..));':
$ git grep 'read_seqcount_retry' | grep -Ev 'while \(|seqlock.h|Doc|\* '
=> about 1/3 of the total read_seqcount_retry usage.
Just looking at fs/namei.c, we conclude that it is non-trivial to
prescribe and migrate to an interface that would force clear begin/end
seqlock markings for critical sections.
As such, we concluded that the best design currently, is to simply
ensure that KCSAN works well with the existing code.
Signed-off-by: Marco Elver <elver@google.com>
Acked-by: Paul E. McKenney <paulmck@kernel.org>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2019-11-14 18:02:59 +00:00
|
|
|
kcsan_flat_atomic_begin();
|
|
|
|
return ret;
|
2011-07-16 16:40:26 +00:00
|
|
|
}
|
|
|
|
|
2020-07-20 15:55:11 +00:00
|
|
|
/**
|
|
|
|
* read_seqretry() - end a seqlock_t read side section
|
|
|
|
* @sl: Pointer to seqlock_t
|
|
|
|
* @start: count, from read_seqbegin()
|
|
|
|
*
|
|
|
|
* read_seqretry closes the read side critical section of given seqlock_t.
|
|
|
|
* If the critical section was invalid, it must be ignored (and typically
|
|
|
|
* retried).
|
|
|
|
*
|
|
|
|
* Return: true if a read section retry is required, else false
|
|
|
|
*/
|
2011-07-16 16:40:26 +00:00
|
|
|
static inline unsigned read_seqretry(const seqlock_t *sl, unsigned start)
|
|
|
|
{
|
seqlock, kcsan: Add annotations for KCSAN
Since seqlocks in the Linux kernel do not require the use of marked
atomic accesses in critical sections, we teach KCSAN to assume such
accesses are atomic. KCSAN currently also pretends that writes to
`sequence` are atomic, although currently plain writes are used (their
corresponding reads are READ_ONCE).
Further, to avoid false positives in the absence of clear ending of a
seqlock reader critical section (only when using the raw interface),
KCSAN assumes a fixed number of accesses after start of a seqlock
critical section are atomic.
=== Commentary on design around absence of clear begin/end markings ===
Seqlock usage via seqlock_t follows a predictable usage pattern, where
clear critical section begin/end is enforced. With subtle special cases
for readers needing to be flat atomic regions, e.g. because usage such
as in:
- fs/namespace.c:__legitimize_mnt - unbalanced read_seqretry
- fs/dcache.c:d_walk - unbalanced need_seqretry
But, anything directly accessing seqcount_t seems to be unpredictable.
Filtering for usage of read_seqcount_retry not following 'do { .. }
while (read_seqcount_retry(..));':
$ git grep 'read_seqcount_retry' | grep -Ev 'while \(|seqlock.h|Doc|\* '
=> about 1/3 of the total read_seqcount_retry usage.
Just looking at fs/namei.c, we conclude that it is non-trivial to
prescribe and migrate to an interface that would force clear begin/end
seqlock markings for critical sections.
As such, we concluded that the best design currently, is to simply
ensure that KCSAN works well with the existing code.
Signed-off-by: Marco Elver <elver@google.com>
Acked-by: Paul E. McKenney <paulmck@kernel.org>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2019-11-14 18:02:59 +00:00
|
|
|
/*
|
2019-11-20 09:41:43 +00:00
|
|
|
* Assume not nested: read_seqretry() may be called multiple times when
|
seqlock, kcsan: Add annotations for KCSAN
Since seqlocks in the Linux kernel do not require the use of marked
atomic accesses in critical sections, we teach KCSAN to assume such
accesses are atomic. KCSAN currently also pretends that writes to
`sequence` are atomic, although currently plain writes are used (their
corresponding reads are READ_ONCE).
Further, to avoid false positives in the absence of clear ending of a
seqlock reader critical section (only when using the raw interface),
KCSAN assumes a fixed number of accesses after start of a seqlock
critical section are atomic.
=== Commentary on design around absence of clear begin/end markings ===
Seqlock usage via seqlock_t follows a predictable usage pattern, where
clear critical section begin/end is enforced. With subtle special cases
for readers needing to be flat atomic regions, e.g. because usage such
as in:
- fs/namespace.c:__legitimize_mnt - unbalanced read_seqretry
- fs/dcache.c:d_walk - unbalanced need_seqretry
But, anything directly accessing seqcount_t seems to be unpredictable.
Filtering for usage of read_seqcount_retry not following 'do { .. }
while (read_seqcount_retry(..));':
$ git grep 'read_seqcount_retry' | grep -Ev 'while \(|seqlock.h|Doc|\* '
=> about 1/3 of the total read_seqcount_retry usage.
Just looking at fs/namei.c, we conclude that it is non-trivial to
prescribe and migrate to an interface that would force clear begin/end
seqlock markings for critical sections.
As such, we concluded that the best design currently, is to simply
ensure that KCSAN works well with the existing code.
Signed-off-by: Marco Elver <elver@google.com>
Acked-by: Paul E. McKenney <paulmck@kernel.org>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2019-11-14 18:02:59 +00:00
|
|
|
* completing read critical section.
|
|
|
|
*/
|
|
|
|
kcsan_flat_atomic_end();
|
|
|
|
|
2011-07-16 16:40:26 +00:00
|
|
|
return read_seqcount_retry(&sl->seqcount, start);
|
|
|
|
}
|
|
|
|
|
2020-09-04 15:32:31 +00:00
|
|
|
/*
|
|
|
|
* For all seqlock_t write side functions, use write_seqcount_*t*_begin()
|
|
|
|
* instead of the generic write_seqcount_begin(). This way, no redundant
|
|
|
|
* lockdep_assert_held() checks are added.
|
|
|
|
*/
|
|
|
|
|
2020-07-20 15:55:11 +00:00
|
|
|
/**
|
|
|
|
* write_seqlock() - start a seqlock_t write side critical section
|
|
|
|
* @sl: Pointer to seqlock_t
|
|
|
|
*
|
|
|
|
* write_seqlock opens a write side critical section for the given
|
|
|
|
* seqlock_t. It also implicitly acquires the spinlock_t embedded inside
|
|
|
|
* that sequential lock. All seqlock_t write side sections are thus
|
|
|
|
* automatically serialized and non-preemptible.
|
|
|
|
*
|
|
|
|
* Context: if the seqlock_t read section, or other write side critical
|
|
|
|
* sections, can be invoked from hardirq or softirq contexts, use the
|
|
|
|
* _irqsave or _bh variants of this function instead.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2011-07-16 16:40:26 +00:00
|
|
|
static inline void write_seqlock(seqlock_t *sl)
|
|
|
|
{
|
|
|
|
spin_lock(&sl->lock);
|
2020-09-04 15:32:31 +00:00
|
|
|
write_seqcount_t_begin(&sl->seqcount.seqcount);
|
2011-07-16 16:40:26 +00:00
|
|
|
}
|
|
|
|
|
2020-07-20 15:55:11 +00:00
|
|
|
/**
|
|
|
|
* write_sequnlock() - end a seqlock_t write side critical section
|
|
|
|
* @sl: Pointer to seqlock_t
|
|
|
|
*
|
|
|
|
* write_sequnlock closes the (serialized and non-preemptible) write side
|
|
|
|
* critical section of given seqlock_t.
|
|
|
|
*/
|
2011-07-16 16:40:26 +00:00
|
|
|
static inline void write_sequnlock(seqlock_t *sl)
|
|
|
|
{
|
2020-09-04 15:32:31 +00:00
|
|
|
write_seqcount_t_end(&sl->seqcount.seqcount);
|
2011-07-16 16:40:26 +00:00
|
|
|
spin_unlock(&sl->lock);
|
|
|
|
}
|
|
|
|
|
2020-07-20 15:55:11 +00:00
|
|
|
/**
|
|
|
|
* write_seqlock_bh() - start a softirqs-disabled seqlock_t write section
|
|
|
|
* @sl: Pointer to seqlock_t
|
|
|
|
*
|
|
|
|
* _bh variant of write_seqlock(). Use only if the read side section, or
|
|
|
|
* other write side sections, can be invoked from softirq contexts.
|
|
|
|
*/
|
2011-07-16 16:40:26 +00:00
|
|
|
static inline void write_seqlock_bh(seqlock_t *sl)
|
|
|
|
{
|
|
|
|
spin_lock_bh(&sl->lock);
|
2020-09-04 15:32:31 +00:00
|
|
|
write_seqcount_t_begin(&sl->seqcount.seqcount);
|
2011-07-16 16:40:26 +00:00
|
|
|
}
|
|
|
|
|
2020-07-20 15:55:11 +00:00
|
|
|
/**
|
|
|
|
* write_sequnlock_bh() - end a softirqs-disabled seqlock_t write section
|
|
|
|
* @sl: Pointer to seqlock_t
|
|
|
|
*
|
|
|
|
* write_sequnlock_bh closes the serialized, non-preemptible, and
|
|
|
|
* softirqs-disabled, seqlock_t write side critical section opened with
|
|
|
|
* write_seqlock_bh().
|
|
|
|
*/
|
2011-07-16 16:40:26 +00:00
|
|
|
static inline void write_sequnlock_bh(seqlock_t *sl)
|
|
|
|
{
|
2020-09-04 15:32:31 +00:00
|
|
|
write_seqcount_t_end(&sl->seqcount.seqcount);
|
2011-07-16 16:40:26 +00:00
|
|
|
spin_unlock_bh(&sl->lock);
|
|
|
|
}
|
|
|
|
|
2020-07-20 15:55:11 +00:00
|
|
|
/**
|
|
|
|
* write_seqlock_irq() - start a non-interruptible seqlock_t write section
|
|
|
|
* @sl: Pointer to seqlock_t
|
|
|
|
*
|
|
|
|
* _irq variant of write_seqlock(). Use only if the read side section, or
|
|
|
|
* other write sections, can be invoked from hardirq contexts.
|
|
|
|
*/
|
2011-07-16 16:40:26 +00:00
|
|
|
static inline void write_seqlock_irq(seqlock_t *sl)
|
|
|
|
{
|
|
|
|
spin_lock_irq(&sl->lock);
|
2020-09-04 15:32:31 +00:00
|
|
|
write_seqcount_t_begin(&sl->seqcount.seqcount);
|
2011-07-16 16:40:26 +00:00
|
|
|
}
|
|
|
|
|
2020-07-20 15:55:11 +00:00
|
|
|
/**
|
|
|
|
* write_sequnlock_irq() - end a non-interruptible seqlock_t write section
|
|
|
|
* @sl: Pointer to seqlock_t
|
|
|
|
*
|
|
|
|
* write_sequnlock_irq closes the serialized and non-interruptible
|
|
|
|
* seqlock_t write side section opened with write_seqlock_irq().
|
|
|
|
*/
|
2011-07-16 16:40:26 +00:00
|
|
|
static inline void write_sequnlock_irq(seqlock_t *sl)
|
|
|
|
{
|
2020-09-04 15:32:31 +00:00
|
|
|
write_seqcount_t_end(&sl->seqcount.seqcount);
|
2011-07-16 16:40:26 +00:00
|
|
|
spin_unlock_irq(&sl->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned long __write_seqlock_irqsave(seqlock_t *sl)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&sl->lock, flags);
|
2020-09-04 15:32:31 +00:00
|
|
|
write_seqcount_t_begin(&sl->seqcount.seqcount);
|
2011-07-16 16:40:26 +00:00
|
|
|
return flags;
|
|
|
|
}
|
|
|
|
|
2020-07-20 15:55:11 +00:00
|
|
|
/**
|
|
|
|
* write_seqlock_irqsave() - start a non-interruptible seqlock_t write
|
|
|
|
* section
|
|
|
|
* @lock: Pointer to seqlock_t
|
|
|
|
* @flags: Stack-allocated storage for saving caller's local interrupt
|
|
|
|
* state, to be passed to write_sequnlock_irqrestore().
|
|
|
|
*
|
|
|
|
* _irqsave variant of write_seqlock(). Use it only if the read side
|
|
|
|
* section, or other write sections, can be invoked from hardirq context.
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
#define write_seqlock_irqsave(lock, flags) \
|
2011-07-16 16:40:26 +00:00
|
|
|
do { flags = __write_seqlock_irqsave(lock); } while (0)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2020-07-20 15:55:11 +00:00
|
|
|
/**
|
|
|
|
* write_sequnlock_irqrestore() - end non-interruptible seqlock_t write
|
|
|
|
* section
|
|
|
|
* @sl: Pointer to seqlock_t
|
|
|
|
* @flags: Caller's saved interrupt state, from write_seqlock_irqsave()
|
|
|
|
*
|
|
|
|
* write_sequnlock_irqrestore closes the serialized and non-interruptible
|
|
|
|
* seqlock_t write section previously opened with write_seqlock_irqsave().
|
|
|
|
*/
|
2011-07-16 16:40:26 +00:00
|
|
|
static inline void
|
|
|
|
write_sequnlock_irqrestore(seqlock_t *sl, unsigned long flags)
|
|
|
|
{
|
2020-09-04 15:32:31 +00:00
|
|
|
write_seqcount_t_end(&sl->seqcount.seqcount);
|
2011-07-16 16:40:26 +00:00
|
|
|
spin_unlock_irqrestore(&sl->lock, flags);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2020-07-20 15:55:11 +00:00
|
|
|
/**
|
|
|
|
* read_seqlock_excl() - begin a seqlock_t locking reader section
|
2020-07-20 15:55:15 +00:00
|
|
|
* @sl: Pointer to seqlock_t
|
2020-07-20 15:55:11 +00:00
|
|
|
*
|
|
|
|
* read_seqlock_excl opens a seqlock_t locking reader critical section. A
|
|
|
|
* locking reader exclusively locks out *both* other writers *and* other
|
|
|
|
* locking readers, but it does not update the embedded sequence number.
|
|
|
|
*
|
|
|
|
* Locking readers act like a normal spin_lock()/spin_unlock().
|
|
|
|
*
|
|
|
|
* Context: if the seqlock_t write section, *or other read sections*, can
|
|
|
|
* be invoked from hardirq or softirq contexts, use the _irqsave or _bh
|
|
|
|
* variant of this function instead.
|
|
|
|
*
|
|
|
|
* The opened read section must be closed with read_sequnlock_excl().
|
2013-09-12 14:55:34 +00:00
|
|
|
*/
|
|
|
|
static inline void read_seqlock_excl(seqlock_t *sl)
|
|
|
|
{
|
|
|
|
spin_lock(&sl->lock);
|
|
|
|
}
|
|
|
|
|
2020-07-20 15:55:11 +00:00
|
|
|
/**
|
|
|
|
* read_sequnlock_excl() - end a seqlock_t locking reader critical section
|
|
|
|
* @sl: Pointer to seqlock_t
|
|
|
|
*/
|
2013-09-12 14:55:34 +00:00
|
|
|
static inline void read_sequnlock_excl(seqlock_t *sl)
|
|
|
|
{
|
|
|
|
spin_unlock(&sl->lock);
|
|
|
|
}
|
|
|
|
|
2020-07-20 15:55:11 +00:00
|
|
|
/**
|
|
|
|
* read_seqlock_excl_bh() - start a seqlock_t locking reader section with
|
|
|
|
* softirqs disabled
|
|
|
|
* @sl: Pointer to seqlock_t
|
|
|
|
*
|
|
|
|
* _bh variant of read_seqlock_excl(). Use this variant only if the
|
|
|
|
* seqlock_t write side section, *or other read sections*, can be invoked
|
|
|
|
* from softirq contexts.
|
|
|
|
*/
|
2013-09-12 14:55:34 +00:00
|
|
|
static inline void read_seqlock_excl_bh(seqlock_t *sl)
|
|
|
|
{
|
|
|
|
spin_lock_bh(&sl->lock);
|
|
|
|
}
|
|
|
|
|
2020-07-20 15:55:11 +00:00
|
|
|
/**
|
|
|
|
* read_sequnlock_excl_bh() - stop a seqlock_t softirq-disabled locking
|
|
|
|
* reader section
|
|
|
|
* @sl: Pointer to seqlock_t
|
|
|
|
*/
|
2013-09-12 14:55:34 +00:00
|
|
|
static inline void read_sequnlock_excl_bh(seqlock_t *sl)
|
|
|
|
{
|
|
|
|
spin_unlock_bh(&sl->lock);
|
|
|
|
}
|
|
|
|
|
2020-07-20 15:55:11 +00:00
|
|
|
/**
|
|
|
|
* read_seqlock_excl_irq() - start a non-interruptible seqlock_t locking
|
|
|
|
* reader section
|
|
|
|
* @sl: Pointer to seqlock_t
|
|
|
|
*
|
|
|
|
* _irq variant of read_seqlock_excl(). Use this only if the seqlock_t
|
|
|
|
* write side section, *or other read sections*, can be invoked from a
|
|
|
|
* hardirq context.
|
|
|
|
*/
|
2013-09-12 14:55:34 +00:00
|
|
|
static inline void read_seqlock_excl_irq(seqlock_t *sl)
|
|
|
|
{
|
|
|
|
spin_lock_irq(&sl->lock);
|
|
|
|
}
|
|
|
|
|
2020-07-20 15:55:11 +00:00
|
|
|
/**
|
|
|
|
* read_sequnlock_excl_irq() - end an interrupts-disabled seqlock_t
|
|
|
|
* locking reader section
|
|
|
|
* @sl: Pointer to seqlock_t
|
|
|
|
*/
|
2013-09-12 14:55:34 +00:00
|
|
|
static inline void read_sequnlock_excl_irq(seqlock_t *sl)
|
|
|
|
{
|
|
|
|
spin_unlock_irq(&sl->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned long __read_seqlock_excl_irqsave(seqlock_t *sl)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&sl->lock, flags);
|
|
|
|
return flags;
|
|
|
|
}
|
|
|
|
|
2020-07-20 15:55:11 +00:00
|
|
|
/**
|
|
|
|
* read_seqlock_excl_irqsave() - start a non-interruptible seqlock_t
|
|
|
|
* locking reader section
|
|
|
|
* @lock: Pointer to seqlock_t
|
|
|
|
* @flags: Stack-allocated storage for saving caller's local interrupt
|
|
|
|
* state, to be passed to read_sequnlock_excl_irqrestore().
|
|
|
|
*
|
|
|
|
* _irqsave variant of read_seqlock_excl(). Use this only if the seqlock_t
|
|
|
|
* write side section, *or other read sections*, can be invoked from a
|
|
|
|
* hardirq context.
|
|
|
|
*/
|
2013-09-12 14:55:34 +00:00
|
|
|
#define read_seqlock_excl_irqsave(lock, flags) \
|
|
|
|
do { flags = __read_seqlock_excl_irqsave(lock); } while (0)
|
|
|
|
|
2020-07-20 15:55:11 +00:00
|
|
|
/**
|
|
|
|
* read_sequnlock_excl_irqrestore() - end non-interruptible seqlock_t
|
|
|
|
* locking reader section
|
|
|
|
* @sl: Pointer to seqlock_t
|
|
|
|
* @flags: Caller saved interrupt state, from read_seqlock_excl_irqsave()
|
|
|
|
*/
|
2013-09-12 14:55:34 +00:00
|
|
|
static inline void
|
|
|
|
read_sequnlock_excl_irqrestore(seqlock_t *sl, unsigned long flags)
|
|
|
|
{
|
|
|
|
spin_unlock_irqrestore(&sl->lock, flags);
|
|
|
|
}
|
|
|
|
|
2020-07-20 15:55:10 +00:00
|
|
|
/**
|
2020-07-20 15:55:11 +00:00
|
|
|
* read_seqbegin_or_lock() - begin a seqlock_t lockless or locking reader
|
|
|
|
* @lock: Pointer to seqlock_t
|
|
|
|
* @seq : Marker and return parameter. If the passed value is even, the
|
|
|
|
* reader will become a *lockless* seqlock_t reader as in read_seqbegin().
|
|
|
|
* If the passed value is odd, the reader will become a *locking* reader
|
|
|
|
* as in read_seqlock_excl(). In the first call to this function, the
|
|
|
|
* caller *must* initialize and pass an even value to @seq; this way, a
|
|
|
|
* lockless read can be optimistically tried first.
|
|
|
|
*
|
|
|
|
* read_seqbegin_or_lock is an API designed to optimistically try a normal
|
|
|
|
* lockless seqlock_t read section first. If an odd counter is found, the
|
|
|
|
* lockless read trial has failed, and the next read iteration transforms
|
|
|
|
* itself into a full seqlock_t locking reader.
|
|
|
|
*
|
|
|
|
* This is typically used to avoid seqlock_t lockless readers starvation
|
|
|
|
* (too much retry loops) in the case of a sharp spike in write side
|
|
|
|
* activity.
|
|
|
|
*
|
|
|
|
* Context: if the seqlock_t write section, *or other read sections*, can
|
|
|
|
* be invoked from hardirq or softirq contexts, use the _irqsave or _bh
|
|
|
|
* variant of this function instead.
|
|
|
|
*
|
|
|
|
* Check Documentation/locking/seqlock.rst for template example code.
|
|
|
|
*
|
|
|
|
* Return: the encountered sequence counter value, through the @seq
|
|
|
|
* parameter, which is overloaded as a return parameter. This returned
|
|
|
|
* value must be checked with need_seqretry(). If the read section need to
|
|
|
|
* be retried, this returned value must also be passed as the @seq
|
|
|
|
* parameter of the next read_seqbegin_or_lock() iteration.
|
2020-07-20 15:55:10 +00:00
|
|
|
*/
|
|
|
|
static inline void read_seqbegin_or_lock(seqlock_t *lock, int *seq)
|
|
|
|
{
|
|
|
|
if (!(*seq & 1)) /* Even */
|
|
|
|
*seq = read_seqbegin(lock);
|
|
|
|
else /* Odd */
|
|
|
|
read_seqlock_excl(lock);
|
|
|
|
}
|
|
|
|
|
2020-07-20 15:55:11 +00:00
|
|
|
/**
|
|
|
|
* need_seqretry() - validate seqlock_t "locking or lockless" read section
|
|
|
|
* @lock: Pointer to seqlock_t
|
|
|
|
* @seq: sequence count, from read_seqbegin_or_lock()
|
|
|
|
*
|
|
|
|
* Return: true if a read section retry is required, false otherwise
|
|
|
|
*/
|
2020-07-20 15:55:10 +00:00
|
|
|
static inline int need_seqretry(seqlock_t *lock, int seq)
|
|
|
|
{
|
|
|
|
return !(seq & 1) && read_seqretry(lock, seq);
|
|
|
|
}
|
|
|
|
|
2020-07-20 15:55:11 +00:00
|
|
|
/**
|
|
|
|
* done_seqretry() - end seqlock_t "locking or lockless" reader section
|
|
|
|
* @lock: Pointer to seqlock_t
|
|
|
|
* @seq: count, from read_seqbegin_or_lock()
|
|
|
|
*
|
|
|
|
* done_seqretry finishes the seqlock_t read side critical section started
|
|
|
|
* with read_seqbegin_or_lock() and validated by need_seqretry().
|
|
|
|
*/
|
2020-07-20 15:55:10 +00:00
|
|
|
static inline void done_seqretry(seqlock_t *lock, int seq)
|
|
|
|
{
|
|
|
|
if (seq & 1)
|
|
|
|
read_sequnlock_excl(lock);
|
|
|
|
}
|
|
|
|
|
2020-07-20 15:55:11 +00:00
|
|
|
/**
|
|
|
|
* read_seqbegin_or_lock_irqsave() - begin a seqlock_t lockless reader, or
|
|
|
|
* a non-interruptible locking reader
|
|
|
|
* @lock: Pointer to seqlock_t
|
|
|
|
* @seq: Marker and return parameter. Check read_seqbegin_or_lock().
|
|
|
|
*
|
|
|
|
* This is the _irqsave variant of read_seqbegin_or_lock(). Use it only if
|
|
|
|
* the seqlock_t write section, *or other read sections*, can be invoked
|
|
|
|
* from hardirq context.
|
|
|
|
*
|
|
|
|
* Note: Interrupts will be disabled only for "locking reader" mode.
|
|
|
|
*
|
|
|
|
* Return:
|
|
|
|
*
|
|
|
|
* 1. The saved local interrupts state in case of a locking reader, to
|
|
|
|
* be passed to done_seqretry_irqrestore().
|
|
|
|
*
|
|
|
|
* 2. The encountered sequence counter value, returned through @seq
|
|
|
|
* overloaded as a return parameter. Check read_seqbegin_or_lock().
|
|
|
|
*/
|
2014-09-12 13:12:14 +00:00
|
|
|
static inline unsigned long
|
|
|
|
read_seqbegin_or_lock_irqsave(seqlock_t *lock, int *seq)
|
|
|
|
{
|
|
|
|
unsigned long flags = 0;
|
|
|
|
|
|
|
|
if (!(*seq & 1)) /* Even */
|
|
|
|
*seq = read_seqbegin(lock);
|
|
|
|
else /* Odd */
|
|
|
|
read_seqlock_excl_irqsave(lock, flags);
|
|
|
|
|
|
|
|
return flags;
|
|
|
|
}
|
|
|
|
|
2020-07-20 15:55:11 +00:00
|
|
|
/**
|
|
|
|
* done_seqretry_irqrestore() - end a seqlock_t lockless reader, or a
|
|
|
|
* non-interruptible locking reader section
|
|
|
|
* @lock: Pointer to seqlock_t
|
|
|
|
* @seq: Count, from read_seqbegin_or_lock_irqsave()
|
|
|
|
* @flags: Caller's saved local interrupt state in case of a locking
|
|
|
|
* reader, also from read_seqbegin_or_lock_irqsave()
|
|
|
|
*
|
|
|
|
* This is the _irqrestore variant of done_seqretry(). The read section
|
|
|
|
* must've been opened with read_seqbegin_or_lock_irqsave(), and validated
|
|
|
|
* by need_seqretry().
|
|
|
|
*/
|
2014-09-12 13:12:14 +00:00
|
|
|
static inline void
|
|
|
|
done_seqretry_irqrestore(seqlock_t *lock, int seq, unsigned long flags)
|
|
|
|
{
|
|
|
|
if (seq & 1)
|
|
|
|
read_sequnlock_excl_irqrestore(lock, flags);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif /* __LINUX_SEQLOCK_H */
|