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