1/* SPDX-License-Identifier: GPL-2.0 */
2#ifndef __LINUX_SEQLOCK_TYPES_H
3#define __LINUX_SEQLOCK_TYPES_H
4
5#include <linux/lockdep_types.h>
6#include <linux/mutex_types.h>
7#include <linux/spinlock_types.h>
8
9/*
10 * Sequence counters (seqcount_t)
11 *
12 * This is the raw counting mechanism, without any writer protection.
13 *
14 * Write side critical sections must be serialized and non-preemptible.
15 *
16 * If readers can be invoked from hardirq or softirq contexts,
17 * interrupts or bottom halves must also be respectively disabled before
18 * entering the write section.
19 *
20 * This mechanism can't be used if the protected data contains pointers,
21 * as the writer can invalidate a pointer that a reader is following.
22 *
23 * If the write serialization mechanism is one of the common kernel
24 * locking primitives, use a sequence counter with associated lock
25 * (seqcount_LOCKNAME_t) instead.
26 *
27 * If it's desired to automatically handle the sequence counter writer
28 * serialization and non-preemptibility requirements, use a sequential
29 * lock (seqlock_t) instead.
30 *
31 * See Documentation/locking/seqlock.rst
32 */
33typedef struct seqcount {
34 unsigned sequence;
35#ifdef CONFIG_DEBUG_LOCK_ALLOC
36 struct lockdep_map dep_map;
37#endif
38} seqcount_t;
39
40/*
41 * For PREEMPT_RT, seqcount_LOCKNAME_t write side critical sections cannot
42 * disable preemption. It can lead to higher latencies, and the write side
43 * sections will not be able to acquire locks which become sleeping locks
44 * (e.g. spinlock_t).
45 *
46 * To remain preemptible while avoiding a possible livelock caused by the
47 * reader preempting the writer, use a different technique: let the reader
48 * detect if a seqcount_LOCKNAME_t writer is in progress. If that is the
49 * case, acquire then release the associated LOCKNAME writer serialization
50 * lock. This will allow any possibly-preempted writer to make progress
51 * until the end of its writer serialization lock critical section.
52 *
53 * This lock-unlock technique must be implemented for all of PREEMPT_RT
54 * sleeping locks. See Documentation/locking/locktypes.rst
55 */
56#if defined(CONFIG_LOCKDEP) || defined(CONFIG_PREEMPT_RT)
57#define __SEQ_LOCK(expr) expr
58#else
59#define __SEQ_LOCK(expr)
60#endif
61
62#define SEQCOUNT_LOCKNAME(lockname, locktype, preemptible, lockbase) \
63typedef struct seqcount_##lockname { \
64 seqcount_t seqcount; \
65 __SEQ_LOCK(locktype *lock); \
66} seqcount_##lockname##_t;
67
68SEQCOUNT_LOCKNAME(raw_spinlock, raw_spinlock_t, false, raw_spin)
69SEQCOUNT_LOCKNAME(spinlock, spinlock_t, __SEQ_RT, spin)
70SEQCOUNT_LOCKNAME(rwlock, rwlock_t, __SEQ_RT, read)
71SEQCOUNT_LOCKNAME(mutex, struct mutex, true, mutex)
72#undef SEQCOUNT_LOCKNAME
73
74/*
75 * Sequential locks (seqlock_t)
76 *
77 * Sequence counters with an embedded spinlock for writer serialization
78 * and non-preemptibility.
79 *
80 * For more info, see:
81 * - Comments on top of seqcount_t
82 * - Documentation/locking/seqlock.rst
83 */
84typedef struct {
85 /*
86 * Make sure that readers don't starve writers on PREEMPT_RT: use
87 * seqcount_spinlock_t instead of seqcount_t. Check __SEQ_LOCK().
88 */
89 seqcount_spinlock_t seqcount;
90 spinlock_t lock;
91} seqlock_t;
92
93#endif /* __LINUX_SEQLOCK_TYPES_H */
94