reactos/drivers/filesystems/ext2_new/inc/linux/atomic.h

   1 #ifndef _LINUX_ATOMIC_H
   2 #define _LINUX_ATOMIC_H
   3
   4 #include <linux/types.h>
   5
   6 //
   7 // atomic
   8 //
   9
  10 typedef struct {
  11     volatile int counter;
  12 } atomic_t;
  13
  14 #define ATOMIC_INIT(i)  (i)
  15
  16 /**
  17  * atomic_read - read atomic variable
  18  * @v: pointer of type atomic_t
  19  *
  20  * Atomically reads the value of @v.  Note that the guaranteed
  21  * useful range of an atomic_t is only 24 bits.
  22  */
  23 #define atomic_read(v)          ((v)->counter)
  24
  25 /**
  26  * atomic_set - set atomic variable
  27  * @v: pointer of type atomic_t
  28  * @i: required value
  29  *
  30  * Atomically sets the value of @v to @i.  Note that the guaranteed
  31  * useful range of an atomic_t is only 24 bits.
  32  */
  33 #define atomic_set(v,i) InterlockedExchange((PLONG)(&(v)->counter), (LONG)(i))
  34
  35 /**
  36  * atomic_add - add integer to atomic variable
  37  * @i: integer value to add
  38  * @v: pointer of type atomic_t
  39  *
  40  * Atomically adds @i to @v.  Note that the guaranteed useful range
  41  * of an atomic_t is only 24 bits.
  42  */
  43 static inline void atomic_add(int volatile i, atomic_t volatile *v)
  44 {
  45     InterlockedExchangeAdd((PLONG)(&v->counter), (LONG) i);
  46 }
  47
  48 /**
  49  * atomic_sub - subtract the atomic variable
  50  * @i: integer value to subtract
  51  * @v: pointer of type atomic_t
  52  *
  53  * Atomically subtracts @i from @v.  Note that the guaranteed
  54  * useful range of an atomic_t is only 24 bits.
  55  */
  56 static inline void atomic_sub(int volatile i, atomic_t volatile *v)
  57 {
  58     InterlockedExchangeAdd((PLONG)(&v->counter), (LONG) (-1*i));
  59 }
  60
  61 /**
  62  * atomic_sub_and_test - subtract value from variable and test result
  63  * @i: integer value to subtract
  64  * @v: pointer of type atomic_t
  65  *
  66  * Atomically subtracts @i from @v and returns
  67  * true if the result is zero, or false for all
  68  * other cases.  Note that the guaranteed
  69  * useful range of an atomic_t is only 24 bits.
  70  */
  71 static inline int atomic_sub_and_test(int volatile i, atomic_t volatile *v)
  72 {
  73     int counter, result;
  74
  75     do {
  76
  77         counter = v->counter;
  78         result = counter - i;
  79
  80     } while ( InterlockedCompareExchange(
  81                   (PLONG) (&v->counter),
  82                   (LONG) result,
  83                   (LONG) counter) != counter);
  84
  85     return (result == 0);
  86 }
  87
  88 /**
  89  * atomic_inc - increment atomic variable
  90  * @v: pointer of type atomic_t
  91  *
  92  * Atomically increments @v by 1.  Note that the guaranteed
  93  * useful range of an atomic_t is only 24 bits.
  94  */
  95 static inline void atomic_inc(atomic_t volatile *v)
  96 {
  97     InterlockedIncrement((PLONG)(&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.  Note that the guaranteed
 105  * useful range of an atomic_t is only 24 bits.
 106  */
 107 static inline void atomic_dec(atomic_t volatile *v)
 108 {
 109     InterlockedDecrement((PLONG)(&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.  Note that the guaranteed
 119  * useful range of an atomic_t is only 24 bits.
 120  */
 121 static inline int atomic_dec_and_test(atomic_t volatile *v)
 122 {
 123     return (0 == InterlockedDecrement((PLONG)(&v->counter)));
 124 }
 125
 126 /**
 127  * atomic_inc_and_test - increment and test
 128  * @v: pointer of type atomic_t
 129  *
 130  * Atomically increments @v by 1
 131  * and returns true if the result is zero, or false for all
 132  * other cases.  Note that the guaranteed
 133  * useful range of an atomic_t is only 24 bits.
 134  */
 135 static inline int atomic_inc_and_test(atomic_t volatile *v)
 136 {
 137     return (0 == InterlockedIncrement((PLONG)(&v->counter)));
 138 }
 139
 140 /**
 141  * atomic_add_negative - add and test if negative
 142  * @v: pointer of type atomic_t
 143  * @i: integer value to add
 144  *
 145  * Atomically adds @i to @v and returns true
 146  * if the result is negative, or false when
 147  * result is greater than or equal to zero.  Note that the guaranteed
 148  * useful range of an atomic_t is only 24 bits.
 149  */
 150 static inline int atomic_add_negative(int volatile i, atomic_t volatile *v)
 151 {
 152     return (InterlockedExchangeAdd((PLONG)(&v->counter), (LONG) i) + i);
 153 }
 154
 155 #endif /* LINUX_ATOMIC_H */