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 int __i; 176 #ifdef CONFIG_M386 177 unsigned long flags; 178 if (unlikely(boot_cpu_data.x86 <= 3)) 179 goto no_xadd; 180 #endif 181 /* Modern 486+ processor */ 182 __i = i; 183 asm volatile(LOCK_PREFIX "xaddl %0, %1" 184 : "+r" (i), "+m" (v->counter) 185 : : "memory"); 186 return i + __i; 187 188 #ifdef CONFIG_M386 189 no_xadd: /* Legacy 386 processor */ 190 raw_local_irq_save(flags); 191 __i = atomic_read(v); 192 atomic_set(v, i + __i); 193 raw_local_irq_restore(flags); 194 return i + __i; 195 #endif 196 } 197 198 /** 199 * atomic_sub_return - subtract integer and return 200 * @v: pointer of type atomic_t 201 * @i: integer value to subtract 202 * 203 * Atomically subtracts @i from @v and returns @v - @i 204 */ 205 static inline int atomic_sub_return(int i, atomic_t *v) 206 { 207 return atomic_add_return(-i, v); 208 } 209 210 #define atomic_inc_return(v) (atomic_add_return(1, v)) 211 #define atomic_dec_return(v) (atomic_sub_return(1, v)) 212 213 static inline int atomic_cmpxchg(atomic_t *v, int old, int new) 214 { 215 return cmpxchg(&v->counter, old, new); 216 } 217 218 static inline int atomic_xchg(atomic_t *v, int new) 219 { 220 return xchg(&v->counter, new); 221 } 222 223 /** 224 * atomic_add_unless - add unless the number is already a given value 225 * @v: pointer of type atomic_t 226 * @a: the amount to add to v... 227 * @u: ...unless v is equal to u. 228 * 229 * Atomically adds @a to @v, so long as @v was not already @u. 230 * Returns non-zero if @v was not @u, and zero otherwise. 231 */ 232 static inline int atomic_add_unless(atomic_t *v, int a, int u) 233 { 234 int c, old; 235 c = atomic_read(v); 236 for (;;) { 237 if (unlikely(c == (u))) 238 break; 239 old = atomic_cmpxchg((v), c, c + (a)); 240 if (likely(old == c)) 241 break; 242 c = old; 243 } 244 return c != (u); 245 } 246 247 #define atomic_inc_not_zero(v) atomic_add_unless((v), 1, 0) 248 249 /* 250 * atomic_dec_if_positive - decrement by 1 if old value positive 251 * @v: pointer of type atomic_t 252 * 253 * The function returns the old value of *v minus 1, even if 254 * the atomic variable, v, was not decremented. 255 */ 256 static inline int atomic_dec_if_positive(atomic_t *v) 257 { 258 int c, old, dec; 259 c = atomic_read(v); 260 for (;;) { 261 dec = c - 1; 262 if (unlikely(dec < 0)) 263 break; 264 old = atomic_cmpxchg((v), c, dec); 265 if (likely(old == c)) 266 break; 267 c = old; 268 } 269 return dec; 270 } 271 272 /** 273 * atomic_inc_short - increment of a short integer 274 * @v: pointer to type int 275 * 276 * Atomically adds 1 to @v 277 * Returns the new value of @u 278 */ 279 static inline short int atomic_inc_short(short int *v) 280 { 281 asm(LOCK_PREFIX "addw $1, %0" : "+m" (*v)); 282 return *v; 283 } 284 285 #ifdef CONFIG_X86_64 286 /** 287 * atomic_or_long - OR of two long integers 288 * @v1: pointer to type unsigned long 289 * @v2: pointer to type unsigned long 290 * 291 * Atomically ORs @v1 and @v2 292 * Returns the result of the OR 293 */ 294 static inline void atomic_or_long(unsigned long *v1, unsigned long v2) 295 { 296 asm(LOCK_PREFIX "orq %1, %0" : "+m" (*v1) : "r" (v2)); 297 } 298 #endif 299 300 /* These are x86-specific, used by some header files */ 301 #define atomic_clear_mask(mask, addr) \ 302 asm volatile(LOCK_PREFIX "andl %0,%1" \ 303 : : "r" (~(mask)), "m" (*(addr)) : "memory") 304 305 #define atomic_set_mask(mask, addr) \ 306 asm volatile(LOCK_PREFIX "orl %0,%1" \ 307 : : "r" ((unsigned)(mask)), "m" (*(addr)) \ 308 : "memory") 309 310 /* Atomic operations are already serializing on x86 */ 311 #define smp_mb__before_atomic_dec() barrier() 312 #define smp_mb__after_atomic_dec() barrier() 313 #define smp_mb__before_atomic_inc() barrier() 314 #define smp_mb__after_atomic_inc() barrier() 315 316 #ifdef CONFIG_X86_32 317 # include "atomic64_32.h" 318 #else 319 # include "atomic64_64.h" 320 #endif 321 322 #include <asm-generic/atomic-long.h> 323 #endif /* _ASM_X86_ATOMIC_H */ 324