4 * Reader/writer consistent mechanism without starving writers. This type of
5 * lock for data where the reader wants a consitent set of information
6 * and is willing to retry if the information changes. Readers never
7 * block but they may have to retry if a writer is in
8 * progress. Writers do not wait for readers.
10 * This is not as cache friendly as brlock. Also, this will not work
11 * for data that contains pointers, because any writer could
12 * invalidate a pointer that a reader was following.
14 * Expected reader usage:
16 * seq = read_seqbegin(&foo);
18 * } while (read_seqretry(&foo, seq));
21 * On non-SMP the spin locks disappear but the writer still needs
22 * to increment the sequence variables because an interrupt routine could
23 * change the state of the data.
25 * Based on x86_64 vsyscall gettimeofday
26 * by Keith Owens and Andrea Arcangeli
29 #include <lwk/spinlock.h>
37 * These macros triggered gcc-3.x compile-time problems. We think these are
38 * OK now. Be cautious.
40 #define SEQLOCK_UNLOCKED { 0, SPIN_LOCK_UNLOCKED }
41 #define seqlock_init(x) do { *(x) = (seqlock_t) SEQLOCK_UNLOCKED; } while (0)
44 /* Lock out other writers and update the count.
45 * Acts like a normal spin_lock/unlock.
47 static inline void write_seqlock(seqlock_t *sl)
54 static inline void write_sequnlock(seqlock_t *sl)
58 spin_unlock(&sl->lock);
61 static inline int write_tryseqlock(seqlock_t *sl)
63 int ret = spin_trylock(&sl->lock);
72 /* Start of read calculation -- fetch last complete writer token */
73 static __always_inline unsigned read_seqbegin(const seqlock_t *sl)
75 unsigned ret = sl->sequence;
80 /* Test if reader processed invalid data.
81 * If initial values is odd,
82 * then writer had already started when section was entered
83 * If sequence value changed
84 * then writer changed data while in section
86 * Using xor saves one conditional branch.
88 static __always_inline int read_seqretry(const seqlock_t *sl, unsigned iv)
91 return (iv & 1) | (sl->sequence ^ iv);
96 * Version using sequence counter only.
97 * This can be used when code has its own mutex protecting the
98 * updating starting before the write_seqcountbeqin() and ending
99 * after the write_seqcount_end().
102 typedef struct seqcount {
106 #define SEQCNT_ZERO { 0 }
107 #define seqcount_init(x) do { *(x) = (seqcount_t) SEQCNT_ZERO; } while (0)
109 /* Start of read using pointer to a sequence counter only. */
110 static inline unsigned read_seqcount_begin(const seqcount_t *s)
112 unsigned ret = s->sequence;
117 /* Test if reader processed invalid data.
118 * Equivalent to: iv is odd or sequence number has changed.
119 * (iv & 1) || (*s != iv)
120 * Using xor saves one conditional branch.
122 static inline int read_seqcount_retry(const seqcount_t *s, unsigned iv)
125 return (iv & 1) | (s->sequence ^ iv);
130 * Sequence counter only version assumes that callers are using their
133 static inline void write_seqcount_begin(seqcount_t *s)
139 static inline void write_seqcount_end(seqcount_t *s)
146 * Possible sw/hw IRQ protected versions of the interfaces.
148 #define write_seqlock_irqsave(lock, flags) \
149 do { local_irq_save(flags); write_seqlock(lock); } while (0)
150 #define write_seqlock_irq(lock) \
151 do { local_irq_disable(); write_seqlock(lock); } while (0)
152 #define write_seqlock_bh(lock) \
153 do { local_bh_disable(); write_seqlock(lock); } while (0)
155 #define write_sequnlock_irqrestore(lock, flags) \
156 do { write_sequnlock(lock); local_irq_restore(flags); } while(0)
157 #define write_sequnlock_irq(lock) \
158 do { write_sequnlock(lock); local_irq_enable(); } while(0)
159 #define write_sequnlock_bh(lock) \
160 do { write_sequnlock(lock); local_bh_enable(); } while(0)
162 #define read_seqbegin_irqsave(lock, flags) \
163 ({ local_irq_save(flags); read_seqbegin(lock); })
165 #define read_seqretry_irqrestore(lock, iv, flags) \
167 int ret = read_seqretry(lock, iv); \
168 local_irq_restore(flags); \
172 #endif /* _LWK_SEQLOCK_H */