何为原子 /*Liux 名词解释*/

本文知识点主要源自与网络：

原子意味着不可分割，所谓原子操作就是对变量的读写不能被打断的操作。
举个简单点儿的例子：
1. 假如在一个i386体系架构上；
2. 如果有一个进程要将一个int型的变量改成0x12345678；
3. 另一个进程也希望把这同一个变量改成0x87654321。
4. 如果这个变量的地址没有4字节对齐，那么cpu要改写它的值的话需要两次总线操作。
那么（假设下面的场景，即下列事件先后发生）：
1. 第一个进程刚把高字节写入（x=0x1234xxxx）内存（xxxx表示不确定）；
2. 第二进程就抢占了第一个进程的运行，把第一个进程改了一半的变量改成0x87654321。（当然他也需要两次总线操作，但我们假设他的优先级比第一个进程高）
3. 第二个进程结束运行后，第一个进程又得到了调度，它并不知道自己对变量的操作被另一个进程打断过，所以他会继续更改变量的低字节。
所以，最后这个变量的值就是0x87655678，显然这是两个进程都不想要得到的结果。通过上面的分析你应该知道问题的关键就在于对存储空间的访问被打断了造成的。所以在内核中定义了一系列的原子操作来保证对变量的操作是“原子”的。这种互斥不是高级语言能实现的，必须用汇编，而且依赖于体系架构。对i386来说就是在读写变量的时候先把总线锁住，你可以仔细看看ATOMIC_INIT这个宏的定义。

所谓原子操作，就是该操作绝不会在执行完毕前被任何其他任务或事件打断，也就说，它的最小的执行单位，不可能有比它更小的执行单位，因此这里的原子实际是使用了物理学里的物质微粒的概念。

　　原子操作需要硬件的支持，因此是架构相关的，其API和原子类型的定义都定义在内核源码树的include/asm/atomic.h文件中，它们都使用汇编语言实现，因为C语言并不能实现这样的操作。
　　原子操作主要用于实现资源计数，很多引用计数(refcnt)就是通过原子操作实现的。原子类型定义如下：
typedef struct 
{ 
volatile int counter; 
} 
atomic_t;
　　volatile修饰字段告诉gcc不要对该类型的数据做优化处理，对它的访问都是对内存的访问，而不是对寄存器的访问。 
　　原子操作API包括： 
atomic_read(atomic_t * v);
　　该函数对原子类型的变量进行原子读操作，它返回原子类型的变量v的值。 
atomic_set(atomic_t * v, int i);
　　该函数设置原子类型的变量v的值为i。 
void atomic_add(int i, atomic_t *v);
　　该函数给原子类型的变量v增加值i。 
atomic_sub(int i, atomic_t *v);
　　该函数从原子类型的变量v中减去i。 
int atomic_sub_and_test(int i, atomic_t *v);
　　该函数从原子类型的变量v中减去i，并判断结果是否为0，如果为0，返回真，否则返回假。 
void atomic_inc(atomic_t *v);
　　该函数对原子类型变量v原子地增加1。 
void atomic_dec(atomic_t *v);
　　该函数对原子类型的变量v原子地减1。 
int atomic_dec_and_test(atomic_t *v);
　　该函数对原子类型的变量v原子地减1，并判断结果是否为0，如果为0，返回真，否则返回假。 
int atomic_inc_and_test(atomic_t *v);
　　该函数对原子类型的变量v原子地增加1，并判断结果是否为0，如果为0，返回真，否则返回假。 
int atomic_add_negative(int i, atomic_t *v);
　　该函数对原子类型的变量v原子地增加I，并判断结果是否为负数，如果是，返回真，否则返回假。 
int atomic_add_return(int i, atomic_t *v);
　　该函数对原子类型的变量v原子地增加i，并且返回指向v的指针。 
int atomic_sub_return(int i, atomic_t *v);
　　该函数从原子类型的变量v中减去i，并且返回指向v的指针。 
int atomic_inc_return(atomic_t * v);
　　该函数对原子类型的变量v原子地增加1并且返回指向v的指针。 
int atomic_dec_return(atomic_t * v);
　　该函数对原子类型的变量v原子地减1并且返回指向v的指针。 
　　原子操作通常用于实现资源的引用计数，在TCP/IP协议栈
的IP碎片处理中，就使用了引用计数，碎片队列结构struct
ipq描述了一个IP碎片，字段refcnt就是引用计数器，它的类型为atomic_t，当创建IP碎片时（在函数ip_frag_create中），
使用atomic_set函数把它设置为1，当引用该IP碎片时，就使用函数atomic_inc把引用计数加1。 
　　当不需要引用
该IP碎片时，就使用函数ipq_put来释放该IP碎片，ipq_put使用函数atomic_dec_and_test把引用计数减1并判断引用计数
是否为0，如果是就释放IP碎片。函数ipq_kill把IP碎片从ipq队列中删除，并把该删除的IP碎片的引用计数减1（通过使用函数
atomic_dec实现）。

原子整数操作的使用：
    常见的用途是计数器，因为计数器是一个很简单的操作，所以无需复杂的锁机制；
    能使用原子操作的地方，尽量不使用复杂的锁机制；

对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")

下面举例说明原子操作的用法：
定义一个atomic_c类型的数据很简单，还可以定义时给它设定初值：
(1) atomic_t u;                     /*定义 u*/
(2) atomic_t v = ATOMIC_INIT(0)     /*定义 v 并把它初始化为0*/
对其操作：
(1) atomic_set(&v,4)                /* v = 4 ( 原子地)*/
(2) atomic_add(2,&v)                /* v = v + 2 = 6 (原子地) */
(3) atomic_inc(&v)                   /* v = v + 1 =7（原子地)*/
如果需要将atomic_t转换成int型，可以使用atomic_read()来完成：
       printk(“%d\n”,atomic_read(&v));    /* 会打印7*/
原子整数操作最常见的用途就是实现计数器。使用复杂的锁机制来保护一个单纯的计数器是很笨拙的，所以，开发者最好使用atomic_inc()和atomic_dec()这两个相对来说轻便一点的操作。
还可以用原子整数操作原子地执行一个操作并检查结果。一个常见的例子是原子的减操作和检查。
int atomic_dec_and_test(atomic_t *v)
这个函数让给定的原子变量减1，如果结果为0，就返回1；否则返回0

原子位操作
    操作函数的参数是一个指针和一个位号
    第0位是给定地址的最低有效位
    原子位操作中没有特殊的数据类型
        例如：set_bit(0, &word); 
如：标志寄存器EFLSGS的系统标志，用于控制I/O访问，可屏蔽硬件中断。共32位，不同的位代表不同的信息，对其中信息改变都是通过位操作实现的
原子操作中的位操作部分函数如下：
void set_bit(int nr, void *addr)        原子设置addr所指的第nr位
void clear_bit(int nr, void *addr)      原子的清空所指对象的第nr位
void change_bit(nr, void *addr)         原子的翻转addr所指的第nr位
int test_bit(nr, void *addr)            原子的返回addr位所指对象nr位
int test_and_set_bit(nr, void *addr)    原子设置addr所指对象的第nr位，并返回原先的值
int test_and_clear_bit(nr, void *addr)  原子清空addr所指对象的第nr位，并返回原先的值
int test_and_change_bit(nr, void *addr)  原子翻转addr所指对象的第nr位，并返回原先的值