]> pilppa.org Git - linux-2.6-omap-h63xx.git/blob - include/linux/seqlock.h
Merge branch 'master'
[linux-2.6-omap-h63xx.git] / include / linux / seqlock.h
1 #ifndef __LINUX_SEQLOCK_H
2 #define __LINUX_SEQLOCK_H
3 /*
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. 
9  *
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.
13  *
14  * Expected reader usage:
15  *      do {
16  *          seq = read_seqbegin(&foo);
17  *      ...
18  *      } while (read_seqretry(&foo, seq));
19  *
20  *
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.
24  *
25  * Based on x86_64 vsyscall gettimeofday 
26  * by Keith Owens and Andrea Arcangeli
27  */
28
29 #include <linux/config.h>
30 #include <linux/spinlock.h>
31 #include <linux/preempt.h>
32
33 typedef struct {
34         unsigned sequence;
35         spinlock_t lock;
36 } seqlock_t;
37
38 /*
39  * These macros triggered gcc-3.x compile-time problems.  We think these are
40  * OK now.  Be cautious.
41  */
42 #define SEQLOCK_UNLOCKED { 0, SPIN_LOCK_UNLOCKED }
43 #define seqlock_init(x) do { *(x) = (seqlock_t) SEQLOCK_UNLOCKED; } while (0)
44
45
46 /* Lock out other writers and update the count.
47  * Acts like a normal spin_lock/unlock.
48  * Don't need preempt_disable() because that is in the spin_lock already.
49  */
50 static inline void write_seqlock(seqlock_t *sl)
51 {
52         spin_lock(&sl->lock);
53         ++sl->sequence;
54         smp_wmb();                      
55 }       
56
57 static inline void write_sequnlock(seqlock_t *sl) 
58 {
59         smp_wmb();
60         sl->sequence++;
61         spin_unlock(&sl->lock);
62 }
63
64 static inline int write_tryseqlock(seqlock_t *sl)
65 {
66         int ret = spin_trylock(&sl->lock);
67
68         if (ret) {
69                 ++sl->sequence;
70                 smp_wmb();                      
71         }
72         return ret;
73 }
74
75 /* Start of read calculation -- fetch last complete writer token */
76 static __always_inline unsigned read_seqbegin(const seqlock_t *sl)
77 {
78         unsigned ret = sl->sequence;
79         smp_rmb();
80         return ret;
81 }
82
83 /* Test if reader processed invalid data.
84  * If initial values is odd, 
85  *      then writer had already started when section was entered
86  * If sequence value changed
87  *      then writer changed data while in section
88  *    
89  * Using xor saves one conditional branch.
90  */
91 static __always_inline int read_seqretry(const seqlock_t *sl, unsigned iv)
92 {
93         smp_rmb();
94         return (iv & 1) | (sl->sequence ^ iv);
95 }
96
97
98 /*
99  * Version using sequence counter only.
100  * This can be used when code has its own mutex protecting the
101  * updating starting before the write_seqcountbeqin() and ending
102  * after the write_seqcount_end().
103  */
104
105 typedef struct seqcount {
106         unsigned sequence;
107 } seqcount_t;
108
109 #define SEQCNT_ZERO { 0 }
110 #define seqcount_init(x)        do { *(x) = (seqcount_t) SEQCNT_ZERO; } while (0)
111
112 /* Start of read using pointer to a sequence counter only.  */
113 static inline unsigned read_seqcount_begin(const seqcount_t *s)
114 {
115         unsigned ret = s->sequence;
116         smp_rmb();
117         return ret;
118 }
119
120 /* Test if reader processed invalid data.
121  * Equivalent to: iv is odd or sequence number has changed.
122  *                (iv & 1) || (*s != iv)
123  * Using xor saves one conditional branch.
124  */
125 static inline int read_seqcount_retry(const seqcount_t *s, unsigned iv)
126 {
127         smp_rmb();
128         return (iv & 1) | (s->sequence ^ iv);
129 }
130
131
132 /*
133  * Sequence counter only version assumes that callers are using their
134  * own mutexing.
135  */
136 static inline void write_seqcount_begin(seqcount_t *s)
137 {
138         s->sequence++;
139         smp_wmb();
140 }
141
142 static inline void write_seqcount_end(seqcount_t *s)
143 {
144         smp_wmb();
145         s->sequence++;
146 }
147
148 /*
149  * Possible sw/hw IRQ protected versions of the interfaces.
150  */
151 #define write_seqlock_irqsave(lock, flags)                              \
152         do { local_irq_save(flags); write_seqlock(lock); } while (0)
153 #define write_seqlock_irq(lock)                                         \
154         do { local_irq_disable();   write_seqlock(lock); } while (0)
155 #define write_seqlock_bh(lock)                                          \
156         do { local_bh_disable();    write_seqlock(lock); } while (0)
157
158 #define write_sequnlock_irqrestore(lock, flags)                         \
159         do { write_sequnlock(lock); local_irq_restore(flags); } while(0)
160 #define write_sequnlock_irq(lock)                                       \
161         do { write_sequnlock(lock); local_irq_enable(); } while(0)
162 #define write_sequnlock_bh(lock)                                        \
163         do { write_sequnlock(lock); local_bh_enable(); } while(0)
164
165 #define read_seqbegin_irqsave(lock, flags)                              \
166         ({ local_irq_save(flags);   read_seqbegin(lock); })
167
168 #define read_seqretry_irqrestore(lock, iv, flags)                       \
169         ({                                                              \
170                 int ret = read_seqretry(lock, iv);                      \
171                 local_irq_restore(flags);                               \
172                 ret;                                                    \
173         })
174
175 #endif /* __LINUX_SEQLOCK_H */