arch/x86/include/asm/atomic_64.h

   1 #ifndef _ASM_X86_ATOMIC_64_H
   2 #define _ASM_X86_ATOMIC_64_H
   3
   4 #include <asm/alternative.h>
   5 #include <asm/cmpxchg.h>
   6
   7 /* atomic_t should be 32 bit signed type */
   8
   9 /*
  10  * Atomic operations that C can't guarantee us.  Useful for
  11  * resource counting etc..
  12  */
  13
  14 /*
  15  * Make sure gcc doesn't try to be clever and move things around
  16  * on us. We need to use _exactly_ the address the user gave us,
  17  * not some alias that contains the same information.
  18  */
  19 typedef struct {
  20         int counter;
  21 } atomic_t;
  22
  23 #define ATOMIC_INIT(i)  { (i) }
  24
  25 /**
  26  * atomic_read - read atomic variable
  27  * @v: pointer of type atomic_t
  28  *
  29  * Atomically reads the value of @v.
  30  */
  31 #define atomic_read(v)          ((v)->counter)
  32
  33 /**
  34  * atomic_set - set atomic variable
  35  * @v: pointer of type atomic_t
  36  * @i: required value
  37  *
  38  * Atomically sets the value of @v to @i.
  39  */
  40 #define atomic_set(v, i)                (((v)->counter) = (i))
  41
  42 /**
  43  * atomic_add - add integer to atomic variable
  44  * @i: integer value to add
  45  * @v: pointer of type atomic_t
  46  *
  47  * Atomically adds @i to @v.
  48  */
  49 static inline void atomic_add(int i, atomic_t *v)
  50 {
  51         asm volatile(LOCK_PREFIX "addl %1,%0"
  52                      : "=m" (v->counter)
  53                      : "ir" (i), "m" (v->counter));
  54 }
  55
  56 /**
  57  * atomic_sub - subtract the atomic variable
  58  * @i: integer value to subtract
  59  * @v: pointer of type atomic_t
  60  *
  61  * Atomically subtracts @i from @v.
  62  */
  63 static inline void atomic_sub(int i, atomic_t *v)
  64 {
  65         asm volatile(LOCK_PREFIX "subl %1,%0"
  66                      : "=m" (v->counter)
  67                      : "ir" (i), "m" (v->counter));
  68 }
  69
  70 /**
  71  * atomic_sub_and_test - subtract value from variable and test result
  72  * @i: integer value to subtract
  73  * @v: pointer of type atomic_t
  74  *
  75  * Atomically subtracts @i from @v and returns
  76  * true if the result is zero, or false for all
  77  * other cases.
  78  */
  79 static inline int atomic_sub_and_test(int i, atomic_t *v)
  80 {
  81         unsigned char c;
  82
  83         asm volatile(LOCK_PREFIX "subl %2,%0; sete %1"
  84                      : "=m" (v->counter), "=qm" (c)
  85                      : "ir" (i), "m" (v->counter) : "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(LOCK_PREFIX "incl %0"
  98                      : "=m" (v->counter)
  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(LOCK_PREFIX "decl %0"
 111                      : "=m" (v->counter)
 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(LOCK_PREFIX "decl %0; sete %1"
 128                      : "=m" (v->counter), "=qm" (c)
 129                      : "m" (v->counter) : "memory");
 130         return c != 0;
 131 }
 132
 133 /**
 134  * atomic_inc_and_test - increment and test
 135  * @v: pointer of type atomic_t
 136  *
 137  * Atomically increments @v by 1
 138  * and returns true if the result is zero, or false for all
 139  * other cases.
 140  */
 141 static inline int atomic_inc_and_test(atomic_t *v)
 142 {
 143         unsigned char c;
 144
 145         asm volatile(LOCK_PREFIX "incl %0; sete %1"
 146                      : "=m" (v->counter), "=qm" (c)
 147                      : "m" (v->counter) : "memory");
 148         return c != 0;
 149 }
 150
 151 /**
 152  * atomic_add_negative - add and test if negative
 153  * @i: integer value to add
 154  * @v: pointer of type atomic_t
 155  *
 156  * Atomically adds @i to @v and returns true
 157  * if the result is negative, or false when
 158  * result is greater than or equal to zero.
 159  */
 160 static inline int atomic_add_negative(int i, atomic_t *v)
 161 {
 162         unsigned char c;
 163
 164         asm volatile(LOCK_PREFIX "addl %2,%0; sets %1"
 165                      : "=m" (v->counter), "=qm" (c)
 166                      : "ir" (i), "m" (v->counter) : "memory");
 167         return c;
 168 }
 169
 170 /**
 171  * atomic_add_return - add and return
 172  * @i: integer value to add
 173  * @v: pointer of type atomic_t
 174  *
 175  * Atomically adds @i to @v and returns @i + @v
 176  */
 177 static inline int atomic_add_return(int i, atomic_t *v)
 178 {
 179         int __i = i;
 180         asm volatile(LOCK_PREFIX "xaddl %0, %1"
 181                      : "+r" (i), "+m" (v->counter)
 182                      : : "memory");
 183         return i + __i;
 184 }
 185
 186 static inline int atomic_sub_return(int i, atomic_t *v)
 187 {
 188         return atomic_add_return(-i, v);
 189 }
 190
 191 #define atomic_inc_return(v)  (atomic_add_return(1, v))
 192 #define atomic_dec_return(v)  (atomic_sub_return(1, v))
 193
 194 /* An 64bit atomic type */
 195
 196 typedef struct {
 197         long counter;
 198 } atomic64_t;
 199
 200 #define ATOMIC64_INIT(i)        { (i) }
 201
 202 /**
 203  * atomic64_read - read atomic64 variable
 204  * @v: pointer of type atomic64_t
 205  *
 206  * Atomically reads the value of @v.
 207  * Doesn't imply a read memory barrier.
 208  */
 209 #define atomic64_read(v)                ((v)->counter)
 210
 211 /**
 212  * atomic64_set - set atomic64 variable
 213  * @v: pointer to type atomic64_t
 214  * @i: required value
 215  *
 216  * Atomically sets the value of @v to @i.
 217  */
 218 #define atomic64_set(v, i)              (((v)->counter) = (i))
 219
 220 /**
 221  * atomic64_add - add integer to atomic64 variable
 222  * @i: integer value to add
 223  * @v: pointer to type atomic64_t
 224  *
 225  * Atomically adds @i to @v.
 226  */
 227 static inline void atomic64_add(long i, atomic64_t *v)
 228 {
 229         asm volatile(LOCK_PREFIX "addq %1,%0"
 230                      : "=m" (v->counter)
 231                      : "er" (i), "m" (v->counter));
 232 }
 233
 234 /**
 235  * atomic64_sub - subtract the atomic64 variable
 236  * @i: integer value to subtract
 237  * @v: pointer to type atomic64_t
 238  *
 239  * Atomically subtracts @i from @v.
 240  */
 241 static inline void atomic64_sub(long i, atomic64_t *v)
 242 {
 243         asm volatile(LOCK_PREFIX "subq %1,%0"
 244                      : "=m" (v->counter)
 245                      : "er" (i), "m" (v->counter));
 246 }
 247
 248 /**
 249  * atomic64_sub_and_test - subtract value from variable and test result
 250  * @i: integer value to subtract
 251  * @v: pointer to type atomic64_t
 252  *
 253  * Atomically subtracts @i from @v and returns
 254  * true if the result is zero, or false for all
 255  * other cases.
 256  */
 257 static inline int atomic64_sub_and_test(long i, atomic64_t *v)
 258 {
 259         unsigned char c;
 260
 261         asm volatile(LOCK_PREFIX "subq %2,%0; sete %1"
 262                      : "=m" (v->counter), "=qm" (c)
 263                      : "er" (i), "m" (v->counter) : "memory");
 264         return c;
 265 }
 266
 267 /**
 268  * atomic64_inc - increment atomic64 variable
 269  * @v: pointer to type atomic64_t
 270  *
 271  * Atomically increments @v by 1.
 272  */
 273 static inline void atomic64_inc(atomic64_t *v)
 274 {
 275         asm volatile(LOCK_PREFIX "incq %0"
 276                      : "=m" (v->counter)
 277                      : "m" (v->counter));
 278 }
 279
 280 /**
 281  * atomic64_dec - decrement atomic64 variable
 282  * @v: pointer to type atomic64_t
 283  *
 284  * Atomically decrements @v by 1.
 285  */
 286 static inline void atomic64_dec(atomic64_t *v)
 287 {
 288         asm volatile(LOCK_PREFIX "decq %0"
 289                      : "=m" (v->counter)
 290                      : "m" (v->counter));
 291 }
 292
 293 /**
 294  * atomic64_dec_and_test - decrement and test
 295  * @v: pointer to type atomic64_t
 296  *
 297  * Atomically decrements @v by 1 and
 298  * returns true if the result is 0, or false for all other
 299  * cases.
 300  */
 301 static inline int atomic64_dec_and_test(atomic64_t *v)
 302 {
 303         unsigned char c;
 304
 305         asm volatile(LOCK_PREFIX "decq %0; sete %1"
 306                      : "=m" (v->counter), "=qm" (c)
 307                      : "m" (v->counter) : "memory");
 308         return c != 0;
 309 }
 310
 311 /**
 312  * atomic64_inc_and_test - increment and test
 313  * @v: pointer to type atomic64_t
 314  *
 315  * Atomically increments @v by 1
 316  * and returns true if the result is zero, or false for all
 317  * other cases.
 318  */
 319 static inline int atomic64_inc_and_test(atomic64_t *v)
 320 {
 321         unsigned char c;
 322
 323         asm volatile(LOCK_PREFIX "incq %0; sete %1"
 324                      : "=m" (v->counter), "=qm" (c)
 325                      : "m" (v->counter) : "memory");
 326         return c != 0;
 327 }
 328
 329 /**
 330  * atomic64_add_negative - add and test if negative
 331  * @i: integer value to add
 332  * @v: pointer to type atomic64_t
 333  *
 334  * Atomically adds @i to @v and returns true
 335  * if the result is negative, or false when
 336  * result is greater than or equal to zero.
 337  */
 338 static inline int atomic64_add_negative(long i, atomic64_t *v)
 339 {
 340         unsigned char c;
 341
 342         asm volatile(LOCK_PREFIX "addq %2,%0; sets %1"
 343                      : "=m" (v->counter), "=qm" (c)
 344                      : "er" (i), "m" (v->counter) : "memory");
 345         return c;
 346 }
 347
 348 /**
 349  * atomic64_add_return - add and return
 350  * @i: integer value to add
 351  * @v: pointer to type atomic64_t
 352  *
 353  * Atomically adds @i to @v and returns @i + @v
 354  */
 355 static inline long atomic64_add_return(long i, atomic64_t *v)
 356 {
 357         long __i = i;
 358         asm volatile(LOCK_PREFIX "xaddq %0, %1;"
 359                      : "+r" (i), "+m" (v->counter)
 360                      : : "memory");
 361         return i + __i;
 362 }
 363
 364 static inline long atomic64_sub_return(long i, atomic64_t *v)
 365 {
 366         return atomic64_add_return(-i, v);
 367 }
 368
 369 #define atomic64_inc_return(v)  (atomic64_add_return(1, (v)))
 370 #define atomic64_dec_return(v)  (atomic64_sub_return(1, (v)))
 371
 372 #define atomic64_cmpxchg(v, old, new) (cmpxchg(&((v)->counter), (old), (new)))
 373 #define atomic64_xchg(v, new) (xchg(&((v)->counter), new))
 374
 375 #define atomic_cmpxchg(v, old, new) (cmpxchg(&((v)->counter), (old), (new)))
 376 #define atomic_xchg(v, new) (xchg(&((v)->counter), (new)))
 377
 378 /**
 379  * atomic_add_unless - add unless the number is a given value
 380  * @v: pointer of type atomic_t
 381  * @a: the amount to add to v...
 382  * @u: ...unless v is equal to u.
 383  *
 384  * Atomically adds @a to @v, so long as it was not @u.
 385  * Returns non-zero if @v was not @u, and zero otherwise.
 386  */
 387 static inline int atomic_add_unless(atomic_t *v, int a, int u)
 388 {
 389         int c, old;
 390         c = atomic_read(v);
 391         for (;;) {
 392                 if (unlikely(c == (u)))
 393                         break;
 394                 old = atomic_cmpxchg((v), c, c + (a));
 395                 if (likely(old == c))
 396                         break;
 397                 c = old;
 398         }
 399         return c != (u);
 400 }
 401
 402 #define atomic_inc_not_zero(v) atomic_add_unless((v), 1, 0)
 403
 404 /**
 405  * atomic64_add_unless - add unless the number is a given value
 406  * @v: pointer of type atomic64_t
 407  * @a: the amount to add to v...
 408  * @u: ...unless v is equal to u.
 409  *
 410  * Atomically adds @a to @v, so long as it was not @u.
 411  * Returns non-zero if @v was not @u, and zero otherwise.
 412  */
 413 static inline int atomic64_add_unless(atomic64_t *v, long a, long u)
 414 {
 415         long c, old;
 416         c = atomic64_read(v);
 417         for (;;) {
 418                 if (unlikely(c == (u)))
 419                         break;
 420                 old = atomic64_cmpxchg((v), c, c + (a));
 421                 if (likely(old == c))
 422                         break;
 423                 c = old;
 424         }
 425         return c != (u);
 426 }
 427
 428 /**
 429  * atomic_inc_short - increment of a short integer
 430  * @v: pointer to type int
 431  *
 432  * Atomically adds 1 to @v
 433  * Returns the new value of @u
 434  */
 435 static inline short int atomic_inc_short(short int *v)
 436 {
 437         asm(LOCK_PREFIX "addw $1, %0" : "+m" (*v));
 438         return *v;
 439 }
 440
 441 /**
 442  * atomic_or_long - OR of two long integers
 443  * @v1: pointer to type unsigned long
 444  * @v2: pointer to type unsigned long
 445  *
 446  * Atomically ORs @v1 and @v2
 447  * Returns the result of the OR
 448  */
 449 static inline void atomic_or_long(unsigned long *v1, unsigned long v2)
 450 {
 451         asm(LOCK_PREFIX "orq %1, %0" : "+m" (*v1) : "r" (v2));
 452 }
 453
 454 #define atomic64_inc_not_zero(v) atomic64_add_unless((v), 1, 0)
 455
 456 /* These are x86-specific, used by some header files */
 457 #define atomic_clear_mask(mask, addr)                                   \
 458         asm volatile(LOCK_PREFIX "andl %0,%1"                           \
 459                      : : "r" (~(mask)), "m" (*(addr)) : "memory")
 460
 461 #define atomic_set_mask(mask, addr)                                     \
 462         asm volatile(LOCK_PREFIX "orl %0,%1"                            \
 463                      : : "r" ((unsigned)(mask)), "m" (*(addr))          \
 464                      : "memory")
 465
 466 /* Atomic operations are already serializing on x86 */
 467 #define smp_mb__before_atomic_dec()     barrier()
 468 #define smp_mb__after_atomic_dec()      barrier()
 469 #define smp_mb__before_atomic_inc()     barrier()
 470 #define smp_mb__after_atomic_inc()      barrier()
 471
 472 #include <asm-generic/atomic.h>
 473 #endif /* _ASM_X86_ATOMIC_64_H */