History

seqlock: Reorder seqcount_t and seqlock_t API definitions

The seqlock.h seqcount_t and seqlock_t API definitions are presented in the chronological order of their development rather than the order that makes most sense to readers. This makes it hard to follow and understand the header file code. Group and reorder all of the exported seqlock.h functions according to their function. First, group together the seqcount_t standard read path functions: - __read_seqcount_begin() - raw_read_seqcount_begin() - read_seqcount_begin() since each function is implemented exactly in terms of the one above it. Then, group the special-case seqcount_t readers on their own as: - raw_read_seqcount() - raw_seqcount_begin() since the only difference between the two functions is that the second one masks the sequence counter LSB while the first one does not. Note that raw_seqcount_begin() can actually be implemented in terms of raw_read_seqcount(), which will be done in a follow-up commit. Then, group the seqcount_t write path functions, instead of injecting unrelated seqcount_t latch functions between them, and order them as: - raw_write_seqcount_begin() - raw_write_seqcount_end() - write_seqcount_begin_nested() - write_seqcount_begin() - write_seqcount_end() - raw_write_seqcount_barrier() - write_seqcount_invalidate() which is the expected natural order. This also isolates the seqcount_t latch functions into their own area, at the end of the sequence counters section, and before jumping to the next one: sequential locks (seqlock_t). Do a similar grouping and reordering for seqlock_t "locking" readers vs. the "conditionally locking or lockless" ones. No implementation code was changed in any of the reordering above.

Ahmed S. Darwish committed 6 years ago

Commit f4a27cb1 parent d3b35b81 file · +78 −80Browse files

Showing the changes to include/linux (1 of 1 file). Show all

Unified · Split

include/linux/seqlock.h+78−80
@@ -128,23 +128,6 @@ repeat: · 127 unmodified lines
128 return ret;128 return ret;
129}129}
130 130
131/**
132 * raw_read_seqcount - Read the raw seqcount
133 * @s: pointer to seqcount_t
134 * Returns: count to be passed to read_seqcount_retry
135 *
136 * raw_read_seqcount opens a read critical section of the given
137 * seqcount without any lockdep checking and without checking or
138 * masking the LSB. Calling code is responsible for handling that.
139 */
140static inline unsigned raw_read_seqcount(const seqcount_t *s)
141{
142 unsigned ret = READ_ONCE(s->sequence);
143 smp_rmb();
144 kcsan_atomic_next(KCSAN_SEQLOCK_REGION_MAX);
145 return ret;
146}
147
148/**131/**
149 * raw_read_seqcount_begin - start seq-read critical section w/o lockdep132 * raw_read_seqcount_begin - start seq-read critical section w/o lockdep
150 * @s: pointer to seqcount_t133 * @s: pointer to seqcount_t
@@ -176,6 +159,23 @@ static inline unsigned read_seqcount_begin(const seqcount_t *s) · 25 unmodified lines
176 return raw_read_seqcount_begin(s);159 return raw_read_seqcount_begin(s);
177}160}
178 161
162/**
163 * raw_read_seqcount - Read the raw seqcount
164 * @s: pointer to seqcount_t
165 * Returns: count to be passed to read_seqcount_retry
166 *
167 * raw_read_seqcount opens a read critical section of the given
168 * seqcount without any lockdep checking and without checking or
169 * masking the LSB. Calling code is responsible for handling that.
170 */
171static inline unsigned raw_read_seqcount(const seqcount_t *s)
172{
173 unsigned ret = READ_ONCE(s->sequence);
174 smp_rmb();
175 kcsan_atomic_next(KCSAN_SEQLOCK_REGION_MAX);
176 return ret;
177}
178
179/**179/**
180 * raw_seqcount_begin - begin a seq-read critical section180 * raw_seqcount_begin - begin a seq-read critical section
181 * @s: pointer to seqcount_t181 * @s: pointer to seqcount_t
@@ -234,8 +234,6 @@ static inline int read_seqcount_retry(const seqcount_t *s, unsigned start) · 52 unmodified lines
234 return __read_seqcount_retry(s, start);234 return __read_seqcount_retry(s, start);
235}235}
236 236
237
238
239static inline void raw_write_seqcount_begin(seqcount_t *s)237static inline void raw_write_seqcount_begin(seqcount_t *s)
240{238{
241 kcsan_nestable_atomic_begin();239 kcsan_nestable_atomic_begin();
@@ -250,6 +248,23 @@ static inline void raw_write_seqcount_end(seqcount_t *s) · 8 unmodified lines
250 kcsan_nestable_atomic_end();248 kcsan_nestable_atomic_end();
251}249}
252 250
251static inline void write_seqcount_begin_nested(seqcount_t *s, int subclass)
252{
253 raw_write_seqcount_begin(s);
254 seqcount_acquire(&s->dep_map, subclass, 0, _RET_IP_);
255}
256
257static inline void write_seqcount_begin(seqcount_t *s)
258{
259 write_seqcount_begin_nested(s, 0);
260}
261
262static inline void write_seqcount_end(seqcount_t *s)
263{
264 seqcount_release(&s->dep_map, _RET_IP_);
265 raw_write_seqcount_end(s);
266}
267
253/**268/**
254 * raw_write_seqcount_barrier - do a seq write barrier269 * raw_write_seqcount_barrier - do a seq write barrier
255 * @s: pointer to seqcount_t270 * @s: pointer to seqcount_t
@@ -300,6 +315,21 @@ static inline void raw_write_seqcount_barrier(seqcount_t *s) · 44 unmodified lines
300 kcsan_nestable_atomic_end();315 kcsan_nestable_atomic_end();
301}316}
302 317
318/**
319 * write_seqcount_invalidate - invalidate in-progress read-side seq operations
320 * @s: pointer to seqcount_t
321 *
322 * After write_seqcount_invalidate, no read-side seq operations will complete
323 * successfully and see data older than this.
324 */
325static inline void write_seqcount_invalidate(seqcount_t *s)
326{
327 smp_wmb();
328 kcsan_nestable_atomic_begin();
329 s->sequence+=2;
330 kcsan_nestable_atomic_end();
331}
332
303static inline int raw_read_seqcount_latch(seqcount_t *s)333static inline int raw_read_seqcount_latch(seqcount_t *s)
304{334{
305 /* Pairs with the first smp_wmb() in raw_write_seqcount_latch() */335 /* Pairs with the first smp_wmb() in raw_write_seqcount_latch() */
@@ -395,38 +425,6 @@ static inline void raw_write_seqcount_latch(seqcount_t *s) · 89 unmodified lines
395 smp_wmb(); /* increment "sequence" before following stores */425 smp_wmb(); /* increment "sequence" before following stores */
396}426}
397 427
398static inline void write_seqcount_begin_nested(seqcount_t *s, int subclass)
399{
400 raw_write_seqcount_begin(s);
401 seqcount_acquire(&s->dep_map, subclass, 0, _RET_IP_);
402}
403
404static inline void write_seqcount_begin(seqcount_t *s)
405{
406 write_seqcount_begin_nested(s, 0);
407}
408
409static inline void write_seqcount_end(seqcount_t *s)
410{
411 seqcount_release(&s->dep_map, _RET_IP_);
412 raw_write_seqcount_end(s);
413}
414
415/**
416 * write_seqcount_invalidate - invalidate in-progress read-side seq operations
417 * @s: pointer to seqcount_t
418 *
419 * After write_seqcount_invalidate, no read-side seq operations will complete
420 * successfully and see data older than this.
421 */
422static inline void write_seqcount_invalidate(seqcount_t *s)
423{
424 smp_wmb();
425 kcsan_nestable_atomic_begin();
426 s->sequence+=2;
427 kcsan_nestable_atomic_end();
428}
429
430/*428/*
431 * Sequential locks (seqlock_t)429 * Sequential locks (seqlock_t)
432 *430 *
@@ -555,35 +553,6 @@ static inline void read_sequnlock_excl(seqlock_t *sl) · 122 unmodified lines
555 spin_unlock(&sl->lock);553 spin_unlock(&sl->lock);
556}554}
557 555
558/**
559 * read_seqbegin_or_lock - begin a sequence number check or locking block
560 * @lock: sequence lock
561 * @seq : sequence number to be checked
562 *
563 * First try it once optimistically without taking the lock. If that fails,
564 * take the lock. The sequence number is also used as a marker for deciding
565 * whether to be a reader (even) or writer (odd).
566 * N.B. seq must be initialized to an even number to begin with.
567 */
568static inline void read_seqbegin_or_lock(seqlock_t *lock, int *seq)
569{
570 if (!(*seq & 1)) /* Even */
571 *seq = read_seqbegin(lock);
572 else /* Odd */
573 read_seqlock_excl(lock);
574}
575
576static inline int need_seqretry(seqlock_t *lock, int seq)
577{
578 return !(seq & 1) && read_seqretry(lock, seq);
579}
580
581static inline void done_seqretry(seqlock_t *lock, int seq)
582{
583 if (seq & 1)
584 read_sequnlock_excl(lock);
585}
586
587static inline void read_seqlock_excl_bh(seqlock_t *sl)556static inline void read_seqlock_excl_bh(seqlock_t *sl)
588{557{
589 spin_lock_bh(&sl->lock);558 spin_lock_bh(&sl->lock);
@@ -621,6 +590,35 @@ read_sequnlock_excl_irqrestore(seqlock_t *sl, unsigned long flags) · 31 unmodified lines
621 spin_unlock_irqrestore(&sl->lock, flags);590 spin_unlock_irqrestore(&sl->lock, flags);
622}591}
623 592
593/**
594 * read_seqbegin_or_lock - begin a sequence number check or locking block
595 * @lock: sequence lock
596 * @seq : sequence number to be checked
597 *
598 * First try it once optimistically without taking the lock. If that fails,
599 * take the lock. The sequence number is also used as a marker for deciding
600 * whether to be a reader (even) or writer (odd).
601 * N.B. seq must be initialized to an even number to begin with.
602 */
603static inline void read_seqbegin_or_lock(seqlock_t *lock, int *seq)
604{
605 if (!(*seq & 1)) /* Even */
606 *seq = read_seqbegin(lock);
607 else /* Odd */
608 read_seqlock_excl(lock);
609}
610
611static inline int need_seqretry(seqlock_t *lock, int seq)
612{
613 return !(seq & 1) && read_seqretry(lock, seq);
614}
615
616static inline void done_seqretry(seqlock_t *lock, int seq)
617{
618 if (seq & 1)
619 read_sequnlock_excl(lock);
620}
621
624static inline unsigned long622static inline unsigned long
625read_seqbegin_or_lock_irqsave(seqlock_t *lock, int *seq)623read_seqbegin_or_lock_irqsave(seqlock_t *lock, int *seq)
626{624{

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t