mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-27 12:57:53 +00:00
f038cc1379
Trimming down sched.h dependencies: we don't want to include more than the base types. Cc: Peter Zijlstra <peterz@infradead.org> Cc: Ingo Molnar <mingo@redhat.com> Cc: Will Deacon <will@kernel.org> Cc: Waiman Long <longman@redhat.com> Cc: Boqun Feng <boqun.feng@gmail.com> Signed-off-by: Kent Overstreet <kent.overstreet@linux.dev>
93 lines
3.1 KiB
C
93 lines
3.1 KiB
C
/* SPDX-License-Identifier: GPL-2.0 */
|
|
#ifndef __LINUX_SEQLOCK_TYPES_H
|
|
#define __LINUX_SEQLOCK_TYPES_H
|
|
|
|
#include <linux/lockdep_types.h>
|
|
#include <linux/mutex_types.h>
|
|
#include <linux/spinlock_types.h>
|
|
|
|
/*
|
|
* 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.
|
|
*
|
|
* If the write serialization mechanism is one of the common kernel
|
|
* locking primitives, use a sequence counter with associated lock
|
|
* (seqcount_LOCKNAME_t) instead.
|
|
*
|
|
* 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
|
|
*/
|
|
typedef struct seqcount {
|
|
unsigned sequence;
|
|
#ifdef CONFIG_DEBUG_LOCK_ALLOC
|
|
struct lockdep_map dep_map;
|
|
#endif
|
|
} seqcount_t;
|
|
|
|
/*
|
|
* 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)
|
|
#define __SEQ_LOCK(expr) expr
|
|
#else
|
|
#define __SEQ_LOCK(expr)
|
|
#endif
|
|
|
|
#define SEQCOUNT_LOCKNAME(lockname, locktype, preemptible, lockbase) \
|
|
typedef struct seqcount_##lockname { \
|
|
seqcount_t seqcount; \
|
|
__SEQ_LOCK(locktype *lock); \
|
|
} seqcount_##lockname##_t;
|
|
|
|
SEQCOUNT_LOCKNAME(raw_spinlock, raw_spinlock_t, false, raw_spin)
|
|
SEQCOUNT_LOCKNAME(spinlock, spinlock_t, __SEQ_RT, spin)
|
|
SEQCOUNT_LOCKNAME(rwlock, rwlock_t, __SEQ_RT, read)
|
|
SEQCOUNT_LOCKNAME(mutex, struct mutex, true, mutex)
|
|
#undef SEQCOUNT_LOCKNAME
|
|
|
|
/*
|
|
* 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
|
|
*/
|
|
typedef struct {
|
|
/*
|
|
* 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;
|
|
|
|
#endif /* __LINUX_SEQLOCK_TYPES_H */
|