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