linux 原子整數操做詳解 及 volatile (二)

原子操做，顧名思義，就是說像原子同樣不可再細分不可被中途打斷。一個操做是原子操做，意思就是說這個操做是以原子的方式被執行，要一口氣執行完，執行過程不可以被OS的其餘行爲打斷，是一個總體的過程，在其執行過程當中，OS的其它行爲是插不進來的。
在linux中提供了兩種形式的原子操做：
    一種是對整數進行的操做
    一種是對單獨的位進行操做
在linux中有一個專門的atomic_t類型(一個24位原子訪問計數器)和一些對atomic類型變量進行相應操做的的函數
其atomic_t原型以下：
    typedef struct { volatile int counter; } atomic_t;
它是一個只含有一個volatile類型的成員變量的結構體；所以編譯器不對相應的值進行訪問優化(由於是volatile類型的)。
原子整數操做的使用：
    常見的用途是計數器，由於計數器是一個很簡單的操做，因此無需複雜的鎖機制；
    能使用原子操做的地方，儘可能不使用複雜的鎖機制；
對atomic_t類型的變量的使用方法以及對其所能進行的操做：
下面是相應的函數及其原型：

小提示：
******
在其函數的實現體中，有一個LOCK_PREFIX宏定義，若是選了CONFIG_SMP，就會定義這麼一個宏，與SMP相關的一些設置，不然LOCK_PREFIX的定義就爲空；
******

//原子的讀取atomic_t變量的值，v是這個變量的地址
#define atomic_read(v)        ((v)->counter)

//原子的設置atomic_t變量的值，v是這個變量的地址，i要設置的新值；
#define atomic_set(v,i)        (((v)->counter) = (i))

//原子的增長atomic_t變量的值，i是要增長的數值，v是這個變量的地址
static __inline__ void atomic_add(int i, atomic_t *v)
{
    __asm__ __volatile__(
        LOCK_PREFIX "addl %1,%0"
        :"=m" (v->counter)
        :"ir" (i), "m" (v->counter));
}

//原子的減小atomic_t變量的值，i是要減小的數值，v是這個變量的地址；
static __inline__ void atomic_sub(int i, atomic_t *v)
{
    __asm__ __volatile__(
        LOCK_PREFIX "subl %1,%0"
        :"=m" (v->counter)
        :"ir" (i), "m" (v->counter));
}

//原子的對atomic_t變量的值進行減小i的操做，而且檢測其結果是否爲0；若爲0，返回true，不然，返回false；
//i是要減小的數值，v是這個變量的地址；
static __inline__ int atomic_sub_and_test(int i, atomic_t *v)
{
    unsigned char c;

    __asm__ __volatile__(
        LOCK_PREFIX "subl %2,%0; sete %1"
        :"=m" (v->counter), "=qm" (c)
        :"ir" (i), "m" (v->counter) : "memory");
    return c;
}

//原子的對atomic_t變量的值進行加1的操做，v是這個變量的地址；
static __inline__ void atomic_inc(atomic_t *v)
{
    __asm__ __volatile__(
        LOCK_PREFIX "incl %0"
        :"=m" (v->counter)
        :"m" (v->counter));
}

//原子的對atomic_t變量的值進行減1的操做，v是這個變量的地址；
static __inline__ void atomic_dec(atomic_t *v)
{
    __asm__ __volatile__(
        LOCK_PREFIX "decl %0"
        :"=m" (v->counter)
        :"m" (v->counter));
}

//原子的對atomic_t變量的值進行減小1的操做，而且檢測其結果是否爲0；若爲0，返回true，不然，返回false；
//v是這個變量的地址；
static __inline__ int atomic_dec_and_test(atomic_t *v)
{
    unsigned char c;

    __asm__ __volatile__(
        LOCK_PREFIX "decl %0; sete %1"
        :"=m" (v->counter), "=qm" (c)
        :"m" (v->counter) : "memory");
    return c != 0;
}

//原子的對atomic_t變量的值進行加1的操做，而且檢測其結果是否爲0；若爲0，返回true，不然，返回false；
//v是這個變量的地址；
static __inline__ int atomic_inc_and_test(atomic_t *v)
{
    unsigned char c;

    __asm__ __volatile__(
        LOCK_PREFIX "incl %0; sete %1"
        :"=m" (v->counter), "=qm" (c)
        :"m" (v->counter) : "memory");
    return c != 0;
}

//原子的對atomic_t變量的值進行加i的操做，而且檢測其結果是否爲負；若爲負，返回true，不然，返回false；
//i是要增長的數值，v是這個變量的地址；
static __inline__ int atomic_add_negative(int i, atomic_t *v)
{
    unsigned char c;

    __asm__ __volatile__(
        LOCK_PREFIX "addl %2,%0; sets %1"
        :"=m" (v->counter), "=qm" (c)
        :"ir" (i), "m" (v->counter) : "memory");
    return c;
}

//原子的對atomic_t變量的值進行加i的操做，而且將所得結果返回；
//i是要增長的數值，v是這個變量的地址；
static __inline__ int atomic_add_return(int i, atomic_t *v)
{
    int __i;
#ifdef CONFIG_M386
    unsigned long flags;
    if(unlikely(boot_cpu_data.x86==3))
        goto no_xadd;
#endif
    /* Modern 486+ processor */
    __i = i;
    __asm__ __volatile__(
        LOCK_PREFIX "xaddl %0, %1;"
        :"=r"(i)
        :"m"(v->counter), "0"(i));
    return i + __i;

#ifdef CONFIG_M386
no_xadd: /* Legacy 386 processor */
    local_irq_save(flags);
    __i = atomic_read(v);
    atomic_set(v, i + __i);
    local_irq_restore(flags);
    return i + __i;
#endif
}
//原子的對atomic_t變量的值進行減i的操做，而且將所得結果返回；
//i是要減小的數值，v是這個變量的地址；
static __inline__ int atomic_sub_return(int i, atomic_t *v)
{
    return atomic_add_return(-i,v);
}

//原子的比較old與v是否相等，若相等，則把new的值寫入到v中，而且返回old的值；
#define atomic_cmpxchg(v, old, new) ((int)cmpxchg(&((v)->counter), old, new))

//原子的比較
#define atomic_xchg(v, new) (xchg(&((v)->counter), new))

/**
 * atomic_add_unless - add unless the number is a given value
 * @v : pointer of type atomic_t
 * @a : the amount to add to v...
 * @u : ...unless v is equal to u.
 *
 * Atomically adds @a  to @v , so long as it was not @u.
 * Returns non-zero if @v was not @u, and zero otherwise.
 */
//原子的對atomic_t變量的值進行加a的操做，直到v等於u，若是v與u不等，返回非零值；不然返回0；
//a是要增長的數值，v是這個變量的地址，u是要比較的值；
#define atomic_add_unless(v, a, u)                \
({                                \
    int c, old;                        \
    c = atomic_read(v);                    \
    for (;;) {                        \
        if (unlikely(c == (u)))                \
            break;                    \
        old = atomic_cmpxchg((v), c, c + (a));        \
        if (likely(old == c))                \
            break;                    \
        c = old;                    \
    }                            \
    c != (u);                        \
})
#define atomic_inc_not_zero(v) atomic_add_unless((v), 1, 0)

#define atomic_inc_return(v)  (atomic_add_return(1,v))
#define atomic_dec_return(v)  (atomic_sub_return(1,v))

//掩碼
/* These are x86-specific, used by some header files */
#define atomic_clear_mask(mask, addr) \
__asm__ __volatile__(LOCK_PREFIX "andl %0,%1" \
: : "r" (~(mask)),"m" (*addr) : "memory")

#define atomic_set_mask(mask, addr) \
__asm__ __volatile__(LOCK_PREFIX "orl %0,%1" \
: : "r" (mask),"m" (*(addr)) : "memory")