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  */
33 typedef 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)	\
63 typedef struct seqcount_##lockname {					\
64 	seqcount_t		seqcount;				\
65 	__SEQ_LOCK(locktype	*lock);					\
66 } seqcount_##lockname##_t;
67 
68 SEQCOUNT_LOCKNAME(raw_spinlock, raw_spinlock_t,  false,    raw_spin)
69 SEQCOUNT_LOCKNAME(spinlock,     spinlock_t,      __SEQ_RT, spin)
70 SEQCOUNT_LOCKNAME(rwlock,       rwlock_t,        __SEQ_RT, read)
71 SEQCOUNT_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  */
84 typedef 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