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 */ 23static 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 */ 35static 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 */ 47static 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 */ 61static 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 */ 77static 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 */ 93static 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 */ 105static 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 */ 119static 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 */ 137static 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 */ 156static 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 */ 173static 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 189no_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 */ 205static 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 213static inline int atomic_cmpxchg(atomic_t *v, int old, int new) 214{ 215 return cmpxchg(&v->counter, old, new); 216} 217 218static 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 */ 232static 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 */ 256static 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 */ 279static 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 */ 294static 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