atomic.h File Reference

#include <linux/types.h>

Include dependency graph for atomic.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	atomic_t

Macros
#define	ATOMIC_INIT(i)   (i)
#define	atomic_read(v)   ((v)->counter)
#define	atomic_set(v, i)   InterlockedExchange((PLONG)(&(v)->counter), (LONG)(i))

Functions
static void	atomic_add (int volatile i, atomic_t volatile *v)
static void	atomic_sub (int volatile i, atomic_t volatile *v)
static int	atomic_sub_and_test (int volatile i, atomic_t volatile *v)
static void	atomic_inc (atomic_t volatile *v)
static void	atomic_dec (atomic_t volatile *v)
static int	atomic_dec_and_test (atomic_t volatile *v)
static int	atomic_inc_and_test (atomic_t volatile *v)
static int	atomic_add_negative (int volatile i, atomic_t volatile *v)

Macro Definition Documentation

ATOMIC_INIT

#define ATOMIC_INIT

(

i

)

(i)

Definition at line 14 of file atomic.h.

atomic_read

#define atomic_read

(

v

)

((v)->counter)

atomic_read - read atomic variable @v: pointer of type atomic_t

Atomically reads the value of @v. Note that the guaranteed useful range of an atomic_t is only 24 bits.

Definition at line 23 of file atomic.h.

atomic_set

#define atomic_set	(		v,
			i
	)		InterlockedExchange((PLONG)(&(v)->counter), (LONG)(i))

atomic_set - set atomic variable @v: pointer of type atomic_t @i: required value

Atomically sets the value of @v to @i. Note that the guaranteed useful range of an atomic_t is only 24 bits.

Definition at line 33 of file atomic.h.

Function Documentation

atomic_add()

static void atomic_add ( int volatile  i, atomic_t volatile *  v  )

inlinestatic

atomic_add - add integer to atomic variable @i: integer value to add @v: pointer of type atomic_t

Atomically adds @i to @v. Note that the guaranteed useful range of an atomic_t is only 24 bits.

Definition at line 43 of file atomic.h.

{
    InterlockedExchangeAdd((PLONG)(&v->counter), (LONG) i);
}

Referenced by __xmlGlobalInitMutexLock(), and tcp_set_owner_r().

atomic_add_negative()

static int atomic_add_negative ( int volatile  i, atomic_t volatile *  v  )

inlinestatic

atomic_add_negative - add and test if negative @v: pointer of type atomic_t @i: integer value to add

Atomically adds @i to @v and returns true if the result is negative, or false when result is greater than or equal to zero. Note that the guaranteed useful range of an atomic_t is only 24 bits.

Definition at line 150 of file atomic.h.

{
    return (InterlockedExchangeAdd((PLONG)(&v->counter), (LONG) i) + i);
}

atomic_dec()

static void atomic_dec ( atomic_t volatile *  v )

inlinestatic

atomic_dec - decrement atomic variable @v: pointer of type atomic_t

Atomically decrements @v by 1. Note that the guaranteed useful range of an atomic_t is only 24 bits.

Definition at line 107 of file atomic.h.

{
    InterlockedDecrement((PLONG)(&v->counter));
}

Referenced by free_buffer_head(), journal_free_journal_head(), and kmem_cache_free().

atomic_dec_and_test()

static int atomic_dec_and_test ( atomic_t volatile *  v )

inlinestatic

atomic_dec_and_test - decrement and test @v: pointer of type atomic_t

Atomically decrements @v by 1 and returns true if the result is 0, or false for all other cases. Note that the guaranteed useful range of an atomic_t is only 24 bits.

Definition at line 121 of file atomic.h.

{
    return (0 == InterlockedDecrement((PLONG)(&v->counter)));
}

Referenced by __brelse(), iput(), kfree_skb(), kfree_skb_fast(), tcp_listen_unlock(), and tcp_tw_put().

atomic_inc()

static void atomic_inc ( atomic_t volatile *  v )

inlinestatic

atomic_inc - increment atomic variable @v: pointer of type atomic_t

Atomically increments @v by 1. Note that the guaranteed useful range of an atomic_t is only 24 bits.

Definition at line 95 of file atomic.h.

{
    InterlockedIncrement((PLONG)(&v->counter));
}

Referenced by ext4_get_group_desc(), get_bh(), iget(), journal_alloc_journal_head(), kmem_cache_alloc(), new_buffer_head(), skb_get(), and tcp_listen_lock().

atomic_inc_and_test()

static int atomic_inc_and_test ( atomic_t volatile *  v )

inlinestatic

atomic_inc_and_test - increment and test @v: pointer of type atomic_t

Atomically increments @v by 1 and returns true if the result is zero, or false for all other cases. Note that the guaranteed useful range of an atomic_t is only 24 bits.

Definition at line 135 of file atomic.h.

{
    return (0 == InterlockedIncrement((PLONG)(&v->counter)));
}

atomic_sub()

static void atomic_sub ( int volatile  i, atomic_t volatile *  v  )

inlinestatic

atomic_sub - subtract the atomic variable @i: integer value to subtract @v: pointer of type atomic_t

Atomically subtracts @i from @v. Note that the guaranteed useful range of an atomic_t is only 24 bits.

Definition at line 56 of file atomic.h.

{
    InterlockedExchangeAdd((PLONG)(&v->counter), (LONG) (-1*i));
}

atomic_sub_and_test()

static int atomic_sub_and_test ( int volatile  i, atomic_t volatile *  v  )

inlinestatic

atomic_sub_and_test - subtract value from variable and test result @i: integer value to subtract @v: pointer of type atomic_t

Atomically subtracts @i from @v and returns true if the result is zero, or false for all other cases. Note that the guaranteed useful range of an atomic_t is only 24 bits.

Definition at line 71 of file atomic.h.

{
    int counter, result;

    do {

        counter = v->counter;
        result = counter - i;

    } while ( InterlockedCompareExchange(
                  (PLONG) (&v->counter),
                  (LONG) result,
                  (LONG) counter) != counter);

    return (result == 0);
}