git.oblomov.eu Git - linux-2.6/blob - arch/x86/include/asm/atomic_32.h

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