1 #ifndef _ASM_X86_ATOMIC_H 2 #define _ASM_X86_ATOMIC_H 3 4 #include <linux/compiler.h> 5 #include <linux/types.h> 6 #include <asm/processor.h> 7 #include <asm/alternative.h> 8 #include <asm/cmpxchg.h> 9 10 /* 11 * Atomic operations that C can't guarantee us. Useful for 12 * resource counting etc.. 13 */ 14 15 #define ATOMIC_INIT(i) { (i) } 16 17 /** 18 * atomic_read - read atomic variable 19 * @v: pointer of type atomic_t 20 * 21 * Atomically reads the value of @v. 22 */ 23 static inline int atomic_read(const atomic_t *v) 24 { 25 return (*(volatile int *)&(v)->counter); 26 } 27 28 /** 29 * atomic_set - set atomic variable 30 * @v: pointer of type atomic_t 31 * @i: required value 32 * 33 * Atomically sets the value of @v to @i. 34 */ 35 static inline void atomic_set(atomic_t *v, int i) 36 { 37 v->counter = i; 38 } 39 40 /** 41 * atomic_add - add integer to atomic variable 42 * @i: integer value to add 43 * @v: pointer of type atomic_t 44 * 45 * Atomically adds @i to @v. 46 */ 47 static inline void atomic_add(int i, atomic_t *v) 48 { 49 asm volatile(LOCK_PREFIX "addl %1,%0" 50 : "+m" (v->counter) 51 : "ir" (i)); 52 } 53 54 /** 55 * atomic_sub - subtract integer from atomic variable 56 * @i: integer value to subtract 57 * @v: pointer of type atomic_t 58 * 59 * Atomically subtracts @i from @v. 60 */ 61 static inline void atomic_sub(int i, atomic_t *v) 62 { 63 asm volatile(LOCK_PREFIX "subl %1,%0" 64 : "+m" (v->counter) 65 : "ir" (i)); 66 } 67 68 /** 69 * atomic_sub_and_test - subtract value from variable and test result 70 * @i: integer value to subtract 71 * @v: pointer of type atomic_t 72 * 73 * Atomically subtracts @i from @v and returns 74 * true if the result is zero, or false for all 75 * other cases. 76 */ 77 static inline int atomic_sub_and_test(int i, atomic_t *v) 78 { 79 unsigned char c; 80 81 asm volatile(LOCK_PREFIX "subl %2,%0; sete %1" 82 : "+m" (v->counter), "=qm" (c) 83 : "ir" (i) : "memory"); 84 return c; 85 } 86 87 /** 88 * atomic_inc - increment atomic variable 89 * @v: pointer of type atomic_t 90 * 91 * Atomically increments @v by 1. 92 */ 93 static inline void atomic_inc(atomic_t *v) 94 { 95 asm volatile(LOCK_PREFIX "incl %0" 96 : "+m" (v->counter)); 97 } 98 99 /** 100 * atomic_dec - decrement atomic variable 101 * @v: pointer of type atomic_t 102 * 103 * Atomically decrements @v by 1. 104 */ 105 static inline void atomic_dec(atomic_t *v) 106 { 107 asm volatile(LOCK_PREFIX "decl %0" 108 : "+m" (v->counter)); 109 } 110 111 /** 112 * atomic_dec_and_test - decrement and test 113 * @v: pointer of type atomic_t 114 * 115 * Atomically decrements @v by 1 and 116 * returns true if the result is 0, or false for all other 117 * cases. 118 */ 119 static inline int atomic_dec_and_test(atomic_t *v) 120 { 121 unsigned char c; 122 123 asm volatile(LOCK_PREFIX "decl %0; sete %1" 124 : "+m" (v->counter), "=qm" (c) 125 : : "memory"); 126 return c != 0; 127 } 128 129 /** 130 * atomic_inc_and_test - increment and test 131 * @v: pointer of type atomic_t 132 * 133 * Atomically increments @v by 1 134 * and returns true if the result is zero, or false for all 135 * other cases. 136 */ 137 static inline int atomic_inc_and_test(atomic_t *v) 138 { 139 unsigned char c; 140 141 asm volatile(LOCK_PREFIX "incl %0; sete %1" 142 : "+m" (v->counter), "=qm" (c) 143 : : "memory"); 144 return c != 0; 145 } 146 147 /** 148 * atomic_add_negative - add and test if negative 149 * @i: integer value to add 150 * @v: pointer of type atomic_t 151 * 152 * Atomically adds @i to @v and returns true 153 * if the result is negative, or false when 154 * result is greater than or equal to zero. 155 */ 156 static inline int atomic_add_negative(int i, atomic_t *v) 157 { 158 unsigned char c; 159 160 asm volatile(LOCK_PREFIX "addl %2,%0; sets %1" 161 : "+m" (v->counter), "=qm" (c) 162 : "ir" (i) : "memory"); 163 return c; 164 } 165 166 /** 167 * atomic_add_return - add integer and return 168 * @i: integer value to add 169 * @v: pointer of type atomic_t 170 * 171 * Atomically adds @i to @v and returns @i + @v 172 */ 173 static inline int atomic_add_return(int i, atomic_t *v) 174 { 175 return i + xadd(&v->counter, i); 176 } 177 178 /** 179 * atomic_sub_return - subtract integer and return 180 * @v: pointer of type atomic_t 181 * @i: integer value to subtract 182 * 183 * Atomically subtracts @i from @v and returns @v - @i 184 */ 185 static inline int atomic_sub_return(int i, atomic_t *v) 186 { 187 return atomic_add_return(-i, v); 188 } 189 190 #define atomic_inc_return(v) (atomic_add_return(1, v)) 191 #define atomic_dec_return(v) (atomic_sub_return(1, v)) 192 193 static inline int atomic_cmpxchg(atomic_t *v, int old, int new) 194 { 195 return cmpxchg(&v->counter, old, new); 196 } 197 198 static inline int atomic_xchg(atomic_t *v, int new) 199 { 200 return xchg(&v->counter, new); 201 } 202 203 /** 204 * __atomic_add_unless - add unless the number is already a given value 205 * @v: pointer of type atomic_t 206 * @a: the amount to add to v... 207 * @u: ...unless v is equal to u. 208 * 209 * Atomically adds @a to @v, so long as @v was not already @u. 210 * Returns the old value of @v. 211 */ 212 static inline int __atomic_add_unless(atomic_t *v, int a, int u) 213 { 214 int c, old; 215 c = atomic_read(v); 216 for (;;) { 217 if (unlikely(c == (u))) 218 break; 219 old = atomic_cmpxchg((v), c, c + (a)); 220 if (likely(old == c)) 221 break; 222 c = old; 223 } 224 return c; 225 } 226 227 /** 228 * atomic_inc_short - increment of a short integer 229 * @v: pointer to type int 230 * 231 * Atomically adds 1 to @v 232 * Returns the new value of @u 233 */ 234 static inline short int atomic_inc_short(short int *v) 235 { 236 asm(LOCK_PREFIX "addw $1, %0" : "+m" (*v)); 237 return *v; 238 } 239 240 #ifdef CONFIG_X86_64 241 /** 242 * atomic_or_long - OR of two long integers 243 * @v1: pointer to type unsigned long 244 * @v2: pointer to type unsigned long 245 * 246 * Atomically ORs @v1 and @v2 247 * Returns the result of the OR 248 */ 249 static inline void atomic_or_long(unsigned long *v1, unsigned long v2) 250 { 251 asm(LOCK_PREFIX "orq %1, %0" : "+m" (*v1) : "r" (v2)); 252 } 253 #endif 254 255 /* These are x86-specific, used by some header files */ 256 #define atomic_clear_mask(mask, addr) \ 257 asm volatile(LOCK_PREFIX "andl %0,%1" \ 258 : : "r" (~(mask)), "m" (*(addr)) : "memory") 259 260 #define atomic_set_mask(mask, addr) \ 261 asm volatile(LOCK_PREFIX "orl %0,%1" \ 262 : : "r" ((unsigned)(mask)), "m" (*(addr)) \ 263 : "memory") 264 265 /* Atomic operations are already serializing on x86 */ 266 #define smp_mb__before_atomic_dec() barrier() 267 #define smp_mb__after_atomic_dec() barrier() 268 #define smp_mb__before_atomic_inc() barrier() 269 #define smp_mb__after_atomic_inc() barrier() 270 271 #ifdef CONFIG_X86_32 272 # include <asm/atomic64_32.h> 273 #else 274 # include <asm/atomic64_64.h> 275 #endif 276 277 #endif /* _ASM_X86_ATOMIC_H */ 278