1 #ifndef __ARCH_I386_ATOMIC__ 2 #define __ARCH_I386_ATOMIC__ 3 4 #include <linux/compiler.h> 5 #include <asm/processor.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 /* 14 * Make sure gcc doesn't try to be clever and move things around 15 * on us. We need to use _exactly_ the address the user gave us, 16 * not some alias that contains the same information. 17 */ 18 typedef struct { int counter; } atomic_t; 19 20 #define ATOMIC_INIT(i) { (i) } 21 22 /** 23 * atomic_read - read atomic variable 24 * @v: pointer of type atomic_t 25 * 26 * Atomically reads the value of @v. 27 */ 28 #define atomic_read(v) ((v)->counter) 29 30 /** 31 * atomic_set - set atomic variable 32 * @v: pointer of type atomic_t 33 * @i: required value 34 * 35 * Atomically sets the value of @v to @i. 36 */ 37 #define atomic_set(v,i) (((v)->counter) = (i)) 38 39 /** 40 * atomic_add - add integer to atomic variable 41 * @i: integer value to add 42 * @v: pointer of type atomic_t 43 * 44 * Atomically adds @i to @v. 45 */ 46 static __inline__ void atomic_add(int i, atomic_t *v) 47 { 48 __asm__ __volatile__( 49 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__( 64 LOCK_PREFIX "subl %1,%0" 65 :"+m" (v->counter) 66 :"ir" (i)); 67 } 68 69 /** 70 * atomic_sub_and_test - subtract value from variable and test result 71 * @i: integer value to subtract 72 * @v: pointer of type atomic_t 73 * 74 * Atomically subtracts @i from @v and returns 75 * true if the result is zero, or false for all 76 * other cases. 77 */ 78 static __inline__ int atomic_sub_and_test(int i, atomic_t *v) 79 { 80 unsigned char c; 81 82 __asm__ __volatile__( 83 LOCK_PREFIX "subl %2,%0; sete %1" 84 :"+m" (v->counter), "=qm" (c) 85 :"ir" (i) : "memory"); 86 return c; 87 } 88 89 /** 90 * atomic_inc - increment atomic variable 91 * @v: pointer of type atomic_t 92 * 93 * Atomically increments @v by 1. 94 */ 95 static __inline__ void atomic_inc(atomic_t *v) 96 { 97 __asm__ __volatile__( 98 LOCK_PREFIX "incl %0" 99 :"+m" (v->counter)); 100 } 101 102 /** 103 * atomic_dec - decrement atomic variable 104 * @v: pointer of type atomic_t 105 * 106 * Atomically decrements @v by 1. 107 */ 108 static __inline__ void atomic_dec(atomic_t *v) 109 { 110 __asm__ __volatile__( 111 LOCK_PREFIX "decl %0" 112 :"+m" (v->counter)); 113 } 114 115 /** 116 * atomic_dec_and_test - decrement and test 117 * @v: pointer of type atomic_t 118 * 119 * Atomically decrements @v by 1 and 120 * returns true if the result is 0, or false for all other 121 * cases. 122 */ 123 static __inline__ int atomic_dec_and_test(atomic_t *v) 124 { 125 unsigned char c; 126 127 __asm__ __volatile__( 128 LOCK_PREFIX "decl %0; sete %1" 129 :"+m" (v->counter), "=qm" (c) 130 : : "memory"); 131 return c != 0; 132 } 133 134 /** 135 * atomic_inc_and_test - increment and test 136 * @v: pointer of type atomic_t 137 * 138 * Atomically increments @v by 1 139 * and returns true if the result is zero, or false for all 140 * other cases. 141 */ 142 static __inline__ int atomic_inc_and_test(atomic_t *v) 143 { 144 unsigned char c; 145 146 __asm__ __volatile__( 147 LOCK_PREFIX "incl %0; sete %1" 148 :"+m" (v->counter), "=qm" (c) 149 : : "memory"); 150 return c != 0; 151 } 152 153 /** 154 * atomic_add_negative - add and test if negative 155 * @v: pointer of type atomic_t 156 * @i: integer value to add 157 * 158 * Atomically adds @i to @v and returns true 159 * if the result is negative, or false when 160 * result is greater than or equal to zero. 161 */ 162 static __inline__ int atomic_add_negative(int i, atomic_t *v) 163 { 164 unsigned char c; 165 166 __asm__ __volatile__( 167 LOCK_PREFIX "addl %2,%0; sets %1" 168 :"+m" (v->counter), "=qm" (c) 169 :"ir" (i) : "memory"); 170 return c; 171 } 172 173 /** 174 * atomic_add_return - add integer and return 175 * @v: pointer of type atomic_t 176 * @i: integer value to add 177 * 178 * Atomically adds @i to @v and returns @i + @v 179 */ 180 static __inline__ int atomic_add_return(int i, atomic_t *v) 181 { 182 int __i; 183 #ifdef CONFIG_M386 184 unsigned long flags; 185 if(unlikely(boot_cpu_data.x86 <= 3)) 186 goto no_xadd; 187 #endif 188 /* Modern 486+ processor */ 189 __i = i; 190 __asm__ __volatile__( 191 LOCK_PREFIX "xaddl %0, %1" 192 :"+r" (i), "+m" (v->counter) 193 : : "memory"); 194 return i + __i; 195 196 #ifdef CONFIG_M386 197 no_xadd: /* Legacy 386 processor */ 198 local_irq_save(flags); 199 __i = atomic_read(v); 200 atomic_set(v, i + __i); 201 local_irq_restore(flags); 202 return i + __i; 203 #endif 204 } 205 206 /** 207 * atomic_sub_return - subtract integer and return 208 * @v: pointer of type atomic_t 209 * @i: integer value to subtract 210 * 211 * Atomically subtracts @i from @v and returns @v - @i 212 */ 213 static __inline__ int atomic_sub_return(int i, atomic_t *v) 214 { 215 return atomic_add_return(-i,v); 216 } 217 218 #define atomic_cmpxchg(v, old, new) (cmpxchg(&((v)->counter), (old), (new))) 219 #define atomic_xchg(v, new) (xchg(&((v)->counter), (new))) 220 221 /** 222 * atomic_add_unless - add unless the number is already a given value 223 * @v: pointer of type atomic_t 224 * @a: the amount to add to v... 225 * @u: ...unless v is equal to u. 226 * 227 * Atomically adds @a to @v, so long as @v was not already @u. 228 * Returns non-zero if @v was not @u, and zero otherwise. 229 */ 230 static __inline__ int atomic_add_unless(atomic_t *v, int a, int u) 231 { 232 int c, old; 233 c = atomic_read(v); 234 for (;;) { 235 if (unlikely(c == (u))) 236 break; 237 old = atomic_cmpxchg((v), c, c + (a)); 238 if (likely(old == c)) 239 break; 240 c = old; 241 } 242 return c != (u); 243 } 244 245 #define atomic_inc_not_zero(v) atomic_add_unless((v), 1, 0) 246 247 #define atomic_inc_return(v) (atomic_add_return(1,v)) 248 #define atomic_dec_return(v) (atomic_sub_return(1,v)) 249 250 /* These are x86-specific, used by some header files */ 251 #define atomic_clear_mask(mask, addr) \ 252 __asm__ __volatile__(LOCK_PREFIX "andl %0,%1" \ 253 : : "r" (~(mask)),"m" (*addr) : "memory") 254 255 #define atomic_set_mask(mask, addr) \ 256 __asm__ __volatile__(LOCK_PREFIX "orl %0,%1" \ 257 : : "r" (mask),"m" (*(addr)) : "memory") 258 259 /* Atomic operations are already serializing on x86 */ 260 #define smp_mb__before_atomic_dec() barrier() 261 #define smp_mb__after_atomic_dec() barrier() 262 #define smp_mb__before_atomic_inc() barrier() 263 #define smp_mb__after_atomic_inc() barrier() 264 265 #include <asm-generic/atomic.h> 266 #endif 267
