asm-generic: rename atomic.h to atomic-long.h
[sfrench/cifs-2.6.git] / arch / x86 / include / asm / atomic_64.h
1 #ifndef _ASM_X86_ATOMIC_64_H
2 #define _ASM_X86_ATOMIC_64_H
3
4 #include <linux/types.h>
5 #include <asm/alternative.h>
6 #include <asm/cmpxchg.h>
7
8 /*
9  * Atomic operations that C can't guarantee us.  Useful for
10  * resource counting etc..
11  */
12
13 #define ATOMIC_INIT(i)  { (i) }
14
15 /**
16  * atomic_read - read atomic variable
17  * @v: pointer of type atomic_t
18  *
19  * Atomically reads the value of @v.
20  */
21 #define atomic_read(v)          ((v)->counter)
22
23 /**
24  * atomic_set - set atomic variable
25  * @v: pointer of type atomic_t
26  * @i: required value
27  *
28  * Atomically sets the value of @v to @i.
29  */
30 #define atomic_set(v, i)                (((v)->counter) = (i))
31
32 /**
33  * atomic_add - add integer to atomic variable
34  * @i: integer value to add
35  * @v: pointer of type atomic_t
36  *
37  * Atomically adds @i to @v.
38  */
39 static inline void atomic_add(int i, atomic_t *v)
40 {
41         asm volatile(LOCK_PREFIX "addl %1,%0"
42                      : "=m" (v->counter)
43                      : "ir" (i), "m" (v->counter));
44 }
45
46 /**
47  * atomic_sub - subtract the atomic variable
48  * @i: integer value to subtract
49  * @v: pointer of type atomic_t
50  *
51  * Atomically subtracts @i from @v.
52  */
53 static inline void atomic_sub(int i, atomic_t *v)
54 {
55         asm volatile(LOCK_PREFIX "subl %1,%0"
56                      : "=m" (v->counter)
57                      : "ir" (i), "m" (v->counter));
58 }
59
60 /**
61  * atomic_sub_and_test - subtract value from variable and test result
62  * @i: integer value to subtract
63  * @v: pointer of type atomic_t
64  *
65  * Atomically subtracts @i from @v and returns
66  * true if the result is zero, or false for all
67  * other cases.
68  */
69 static inline int atomic_sub_and_test(int i, atomic_t *v)
70 {
71         unsigned char c;
72
73         asm volatile(LOCK_PREFIX "subl %2,%0; sete %1"
74                      : "=m" (v->counter), "=qm" (c)
75                      : "ir" (i), "m" (v->counter) : "memory");
76         return c;
77 }
78
79 /**
80  * atomic_inc - increment atomic variable
81  * @v: pointer of type atomic_t
82  *
83  * Atomically increments @v by 1.
84  */
85 static inline void atomic_inc(atomic_t *v)
86 {
87         asm volatile(LOCK_PREFIX "incl %0"
88                      : "=m" (v->counter)
89                      : "m" (v->counter));
90 }
91
92 /**
93  * atomic_dec - decrement atomic variable
94  * @v: pointer of type atomic_t
95  *
96  * Atomically decrements @v by 1.
97  */
98 static inline void atomic_dec(atomic_t *v)
99 {
100         asm volatile(LOCK_PREFIX "decl %0"
101                      : "=m" (v->counter)
102                      : "m" (v->counter));
103 }
104
105 /**
106  * atomic_dec_and_test - decrement and test
107  * @v: pointer of type atomic_t
108  *
109  * Atomically decrements @v by 1 and
110  * returns true if the result is 0, or false for all other
111  * cases.
112  */
113 static inline int atomic_dec_and_test(atomic_t *v)
114 {
115         unsigned char c;
116
117         asm volatile(LOCK_PREFIX "decl %0; sete %1"
118                      : "=m" (v->counter), "=qm" (c)
119                      : "m" (v->counter) : "memory");
120         return c != 0;
121 }
122
123 /**
124  * atomic_inc_and_test - increment and test
125  * @v: pointer of type atomic_t
126  *
127  * Atomically increments @v by 1
128  * and returns true if the result is zero, or false for all
129  * other cases.
130  */
131 static inline int atomic_inc_and_test(atomic_t *v)
132 {
133         unsigned char c;
134
135         asm volatile(LOCK_PREFIX "incl %0; sete %1"
136                      : "=m" (v->counter), "=qm" (c)
137                      : "m" (v->counter) : "memory");
138         return c != 0;
139 }
140
141 /**
142  * atomic_add_negative - add and test if negative
143  * @i: integer value to add
144  * @v: pointer of type atomic_t
145  *
146  * Atomically adds @i to @v and returns true
147  * if the result is negative, or false when
148  * result is greater than or equal to zero.
149  */
150 static inline int atomic_add_negative(int i, atomic_t *v)
151 {
152         unsigned char c;
153
154         asm volatile(LOCK_PREFIX "addl %2,%0; sets %1"
155                      : "=m" (v->counter), "=qm" (c)
156                      : "ir" (i), "m" (v->counter) : "memory");
157         return c;
158 }
159
160 /**
161  * atomic_add_return - add and return
162  * @i: integer value to add
163  * @v: pointer of type atomic_t
164  *
165  * Atomically adds @i to @v and returns @i + @v
166  */
167 static inline int atomic_add_return(int i, atomic_t *v)
168 {
169         int __i = i;
170         asm volatile(LOCK_PREFIX "xaddl %0, %1"
171                      : "+r" (i), "+m" (v->counter)
172                      : : "memory");
173         return i + __i;
174 }
175
176 static inline int atomic_sub_return(int i, atomic_t *v)
177 {
178         return atomic_add_return(-i, v);
179 }
180
181 #define atomic_inc_return(v)  (atomic_add_return(1, v))
182 #define atomic_dec_return(v)  (atomic_sub_return(1, v))
183
184 /* The 64-bit atomic type */
185
186 #define ATOMIC64_INIT(i)        { (i) }
187
188 /**
189  * atomic64_read - read atomic64 variable
190  * @v: pointer of type atomic64_t
191  *
192  * Atomically reads the value of @v.
193  * Doesn't imply a read memory barrier.
194  */
195 #define atomic64_read(v)                ((v)->counter)
196
197 /**
198  * atomic64_set - set atomic64 variable
199  * @v: pointer to type atomic64_t
200  * @i: required value
201  *
202  * Atomically sets the value of @v to @i.
203  */
204 #define atomic64_set(v, i)              (((v)->counter) = (i))
205
206 /**
207  * atomic64_add - add integer to atomic64 variable
208  * @i: integer value to add
209  * @v: pointer to type atomic64_t
210  *
211  * Atomically adds @i to @v.
212  */
213 static inline void atomic64_add(long i, atomic64_t *v)
214 {
215         asm volatile(LOCK_PREFIX "addq %1,%0"
216                      : "=m" (v->counter)
217                      : "er" (i), "m" (v->counter));
218 }
219
220 /**
221  * atomic64_sub - subtract the atomic64 variable
222  * @i: integer value to subtract
223  * @v: pointer to type atomic64_t
224  *
225  * Atomically subtracts @i from @v.
226  */
227 static inline void atomic64_sub(long i, atomic64_t *v)
228 {
229         asm volatile(LOCK_PREFIX "subq %1,%0"
230                      : "=m" (v->counter)
231                      : "er" (i), "m" (v->counter));
232 }
233
234 /**
235  * atomic64_sub_and_test - subtract value from variable and test result
236  * @i: integer value to subtract
237  * @v: pointer to type atomic64_t
238  *
239  * Atomically subtracts @i from @v and returns
240  * true if the result is zero, or false for all
241  * other cases.
242  */
243 static inline int atomic64_sub_and_test(long i, atomic64_t *v)
244 {
245         unsigned char c;
246
247         asm volatile(LOCK_PREFIX "subq %2,%0; sete %1"
248                      : "=m" (v->counter), "=qm" (c)
249                      : "er" (i), "m" (v->counter) : "memory");
250         return c;
251 }
252
253 /**
254  * atomic64_inc - increment atomic64 variable
255  * @v: pointer to type atomic64_t
256  *
257  * Atomically increments @v by 1.
258  */
259 static inline void atomic64_inc(atomic64_t *v)
260 {
261         asm volatile(LOCK_PREFIX "incq %0"
262                      : "=m" (v->counter)
263                      : "m" (v->counter));
264 }
265
266 /**
267  * atomic64_dec - decrement atomic64 variable
268  * @v: pointer to type atomic64_t
269  *
270  * Atomically decrements @v by 1.
271  */
272 static inline void atomic64_dec(atomic64_t *v)
273 {
274         asm volatile(LOCK_PREFIX "decq %0"
275                      : "=m" (v->counter)
276                      : "m" (v->counter));
277 }
278
279 /**
280  * atomic64_dec_and_test - decrement and test
281  * @v: pointer to type atomic64_t
282  *
283  * Atomically decrements @v by 1 and
284  * returns true if the result is 0, or false for all other
285  * cases.
286  */
287 static inline int atomic64_dec_and_test(atomic64_t *v)
288 {
289         unsigned char c;
290
291         asm volatile(LOCK_PREFIX "decq %0; sete %1"
292                      : "=m" (v->counter), "=qm" (c)
293                      : "m" (v->counter) : "memory");
294         return c != 0;
295 }
296
297 /**
298  * atomic64_inc_and_test - increment and test
299  * @v: pointer to type atomic64_t
300  *
301  * Atomically increments @v by 1
302  * and returns true if the result is zero, or false for all
303  * other cases.
304  */
305 static inline int atomic64_inc_and_test(atomic64_t *v)
306 {
307         unsigned char c;
308
309         asm volatile(LOCK_PREFIX "incq %0; sete %1"
310                      : "=m" (v->counter), "=qm" (c)
311                      : "m" (v->counter) : "memory");
312         return c != 0;
313 }
314
315 /**
316  * atomic64_add_negative - add and test if negative
317  * @i: integer value to add
318  * @v: pointer to type atomic64_t
319  *
320  * Atomically adds @i to @v and returns true
321  * if the result is negative, or false when
322  * result is greater than or equal to zero.
323  */
324 static inline int atomic64_add_negative(long i, atomic64_t *v)
325 {
326         unsigned char c;
327
328         asm volatile(LOCK_PREFIX "addq %2,%0; sets %1"
329                      : "=m" (v->counter), "=qm" (c)
330                      : "er" (i), "m" (v->counter) : "memory");
331         return c;
332 }
333
334 /**
335  * atomic64_add_return - add and return
336  * @i: integer value to add
337  * @v: pointer to type atomic64_t
338  *
339  * Atomically adds @i to @v and returns @i + @v
340  */
341 static inline long atomic64_add_return(long i, atomic64_t *v)
342 {
343         long __i = i;
344         asm volatile(LOCK_PREFIX "xaddq %0, %1;"
345                      : "+r" (i), "+m" (v->counter)
346                      : : "memory");
347         return i + __i;
348 }
349
350 static inline long atomic64_sub_return(long i, atomic64_t *v)
351 {
352         return atomic64_add_return(-i, v);
353 }
354
355 #define atomic64_inc_return(v)  (atomic64_add_return(1, (v)))
356 #define atomic64_dec_return(v)  (atomic64_sub_return(1, (v)))
357
358 #define atomic64_cmpxchg(v, old, new) (cmpxchg(&((v)->counter), (old), (new)))
359 #define atomic64_xchg(v, new) (xchg(&((v)->counter), new))
360
361 #define atomic_cmpxchg(v, old, new) (cmpxchg(&((v)->counter), (old), (new)))
362 #define atomic_xchg(v, new) (xchg(&((v)->counter), (new)))
363
364 /**
365  * atomic_add_unless - add unless the number is a given value
366  * @v: pointer of type atomic_t
367  * @a: the amount to add to v...
368  * @u: ...unless v is equal to u.
369  *
370  * Atomically adds @a to @v, so long as it was not @u.
371  * Returns non-zero if @v was not @u, and zero otherwise.
372  */
373 static inline int atomic_add_unless(atomic_t *v, int a, int u)
374 {
375         int c, old;
376         c = atomic_read(v);
377         for (;;) {
378                 if (unlikely(c == (u)))
379                         break;
380                 old = atomic_cmpxchg((v), c, c + (a));
381                 if (likely(old == c))
382                         break;
383                 c = old;
384         }
385         return c != (u);
386 }
387
388 #define atomic_inc_not_zero(v) atomic_add_unless((v), 1, 0)
389
390 /**
391  * atomic64_add_unless - add unless the number is a given value
392  * @v: pointer of type atomic64_t
393  * @a: the amount to add to v...
394  * @u: ...unless v is equal to u.
395  *
396  * Atomically adds @a to @v, so long as it was not @u.
397  * Returns non-zero if @v was not @u, and zero otherwise.
398  */
399 static inline int atomic64_add_unless(atomic64_t *v, long a, long u)
400 {
401         long c, old;
402         c = atomic64_read(v);
403         for (;;) {
404                 if (unlikely(c == (u)))
405                         break;
406                 old = atomic64_cmpxchg((v), c, c + (a));
407                 if (likely(old == c))
408                         break;
409                 c = old;
410         }
411         return c != (u);
412 }
413
414 /**
415  * atomic_inc_short - increment of a short integer
416  * @v: pointer to type int
417  *
418  * Atomically adds 1 to @v
419  * Returns the new value of @u
420  */
421 static inline short int atomic_inc_short(short int *v)
422 {
423         asm(LOCK_PREFIX "addw $1, %0" : "+m" (*v));
424         return *v;
425 }
426
427 /**
428  * atomic_or_long - OR of two long integers
429  * @v1: pointer to type unsigned long
430  * @v2: pointer to type unsigned long
431  *
432  * Atomically ORs @v1 and @v2
433  * Returns the result of the OR
434  */
435 static inline void atomic_or_long(unsigned long *v1, unsigned long v2)
436 {
437         asm(LOCK_PREFIX "orq %1, %0" : "+m" (*v1) : "r" (v2));
438 }
439
440 #define atomic64_inc_not_zero(v) atomic64_add_unless((v), 1, 0)
441
442 /* These are x86-specific, used by some header files */
443 #define atomic_clear_mask(mask, addr)                                   \
444         asm volatile(LOCK_PREFIX "andl %0,%1"                           \
445                      : : "r" (~(mask)), "m" (*(addr)) : "memory")
446
447 #define atomic_set_mask(mask, addr)                                     \
448         asm volatile(LOCK_PREFIX "orl %0,%1"                            \
449                      : : "r" ((unsigned)(mask)), "m" (*(addr))          \
450                      : "memory")
451
452 /* Atomic operations are already serializing on x86 */
453 #define smp_mb__before_atomic_dec()     barrier()
454 #define smp_mb__after_atomic_dec()      barrier()
455 #define smp_mb__before_atomic_inc()     barrier()
456 #define smp_mb__after_atomic_inc()      barrier()
457
458 #include <asm-generic/atomic-long.h>
459 #endif /* _ASM_X86_ATOMIC_64_H */