Linux内核源码(asm/bitops/atomic.h)学习

在之前的一篇博客中，着重讲解了在Linux内核中同步方法－－对于整型的原子操作，除此之外，内核同步方法中还有对位的原子操作．下面我们来列举一下原子位操作的列表：

原子位操作	描述
void set_bit(int nr, volatile unsigned long *addr)	原子的设置addr所指对象的第nr位
void clear_bit(int nr, volatile unsigned long *addr)	原子的清空addr所指对象的第nr位
void change_bit(int nr, volatile unsigned long *addr)	原子的翻转addr所指对象的第nr位
int test_and_set_bit(int nr, volatile unsigned long *addr)	原子的设置addr所指对象的第nr位，并返回原先的值
int test_and_clear_bit(int nr, volatile unsigned long *addr)	原子的清空addr所指对象的第nr位，并返回原先的值
int test_and_change_bit(int nr, volatile unsigned long *addr)	原子的翻转addr所指对象的第nr位，并返回原先的值

好了，现在有了一个整体的了解之后，我就可以附上代码了，主要的解释都在代码的注释中．

#ifndef _ASM_GENERIC_BITOPS_ATOMIC_H_
#define _ASM_GENERIC_BITOPS_ATOMIC_H_

#include <asm/types.h>
#include <asm/system.h>

#ifdef CONFIG_SMP
#include <asm/spinlock.h>
#include <asm/cache.h>      /* we use L1_CACHE_BYTES 我们使用L1_CACHE_BYTES */

/* 　
　* 我们将下面用到的几个宏放在这里．
 *　#define L1_CACHE_SHIFT   5
　* #define L1_CACHE_BYTES   (1 << L1_CACHE_SHIFT)　
 * //BITS_PER_LONG 32
 * #define BIT(nr)  (1UL << (nr))
 * #define BIT_MASK(nr) (1UL << ((nr) % BITS_PER_LONG))
 * #define BIT_WORD(nr) ((nr) / BITS_PER_LONG)
 * #define BITS_PER_BYTE    8
 * #define BITS_TO_LONGS(nr) DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long))
 *
　*/

/* Use an array of spinlocks for our atomic_ts.
 * Hash function to index into a different SPINLOCK.
 * Since "a" is usually an address, use one spinlock per cacheline.
 *
 * 为我们的atomic_ts使用一个spinlocks的数组．
 *　使用哈希函数来索引到一个不同的SPINLOCK
 * "a"通常是一个地址，每一个缓存行使用一个spinlock
 */
#  define ATOMIC_HASH_SIZE 4
#  define ATOMIC_HASH(a) (&(__atomic_hash[ (((unsigned long) a)/L1_CACHE_BYTES) & (ATOMIC_HASH_SIZE-1) ]))

extern arch_spinlock_t __atomic_hash[ATOMIC_HASH_SIZE] __lock_aligned;

/* Can't use raw_spin_lock_irq because of #include problems, so
 * this is the substitute 
 * 不能使用raw_spin_lock_irq因为会出现#include 问题，所以
 *　下面这个是他的替代品．
　*/
#define _atomic_spin_lock_irqsave(l,f) do { \
    arch_spinlock_t *s = ATOMIC_HASH(l);    \
    local_irq_save(f);          \
    arch_spin_lock(s);          \
} while(0)

#define _atomic_spin_unlock_irqrestore(l,f) do {    \
    arch_spinlock_t *s = ATOMIC_HASH(l);        \
    arch_spin_unlock(s);            unsigned    \
    local_irq_restore(f);               \
} while(0)


#else
#  define _atomic_spin_lock_irqsave(l,f) do { local_irq_save(f); } while (0)
#  define _atomic_spin_unlock_irqrestore(l,f) do { local_irq_restore(f); } while (0)
#endif

/*
 * NMI events can occur at any time, including when interrupts have been
 * disabled by *_irqsave().  So you can get NMI events occurring while a
 * *_bit function is holding a spin lock.  If the NMI handler also wants
 * to do bit manipulation (and they do) then you can get a deadlock
 * between the original caller of *_bit() and the NMI handler.
 *
 * by Keith Owens
　*
 *　NMI事件随时是会发生的，包括当中断已经被 *_irqsave()禁止了．所以，当一个 *_bit
 * 函数正在使用一个spin锁的时候，NMI事件也可能会发生．如果NMI处理函数也想要进行
 * 位操作，那么在原来的 *_bit()调用者和NMI处理函数之间就会产生死锁．
 */

/**
 * set_bit - Atomically set a bit in memory
 * @nr: the bit to set
 * @addr: the address to start counting from
　* set_bit - 原子的在内存中设置一位
 *　@nr: 要被设置的那一位
 *　@addr: 开始计数的地址
 *
 * This function is atomic and may not be reordered.  See __set_bit()
 * if you do not require the atomic guarantees.
　* 这个函数是原子的，并且不能被重新排序．如果你不需要原子保证，可以
　* 看一下 __set_bit()这个函数．
 *
 * Note: there are no guarantees that this function will not be reordered
 * on non x86 architectures, so if you are writing portable code,
 * make sure not to rely on its reordering guarantees.
　* 注意：在非x86架构上，对这个函数不能被重新排序是不能被保证的．所以，如果你正在
 * 便携式的代码，一定要确定不能依赖于他的重新排序保障．
 * 
 * Note that @nr may be almost arbitrarily large; this function is not
 * restricted to acting on a single-word quantity.
 *
 *　注意：nr可能是任意大的；这个函数不是被限制在一个单字的量上的．
 */
static inline void set_bit(int nr, volatile unsigned long *addr)
{
    unsigned long mask = BIT_MASK(nr);
    unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
    unsigned long flags;

    _atomic_spin_lock_irqsave(p, flags);

　   //这个地方基本上是关于位的操作，相对来说比较简单，就是移位
    *p  |= mask;
    _atomic_spin_unlock_irqrestore(p, flags);
}

/**
 * clear_bit - Clears a bit in memory
 * @nr: Bit to clear
 * @addr: Address to start counting from
 *
 *　clear_bit - 清除内存中的一个位
 *　@nr: 要被清楚的那个位
 * @addr: 开始计数的位置
 *
 * clear_bit() is atomic and may not be reordered.  However, it does
 * not contain a memory barrier, so if it is used for locking purposes,
 * you should call smp_mb__before_clear_bit() and/or smp_mb__after_clear_bit()
 * in order to ensure changes are visible on other processors.
 *
 * clear_bit()是原子的并且不能被重新换顺序．然而，他并不包含一个内存屏障，所以，
 *　如果他被用来实现锁的目的，你应该调用smp_mb_before_clear_bit()或者是smp_mb_after_clear_bit()
 *  来确保在其他处理器上改变是可见的．
 */
static inline void clear_bit(int nr, volatile unsigned long *addr)
{
    unsigned long mask = BIT_MASK(nr);
    unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
    unsigned long flags;

    _atomic_spin_lock_irqsave(p, flags);
    *p &= ~mask;
    _atomic_spin_unlock_irqrestore(p, flags);
}

/**
 * change_bit - Toggle a bit in memory
 * @nr: Bit to change
 * @addr: Address to start counting from
 * change_bit - 在内存中切换一个位
 *　@nr: 要被改变的位 
 * @addr: 开始计数的地址
 *
 * change_bit() is atomic and may not be reordered. It may be
 * reordered on other architectures than x86.
 * Note that @nr may be almost arbitrarily large; this function is not
 * restricted to acting on a single-word quantity.
　*　同上．
 */
static inline void change_bit(int nr, volatile unsigned long *addr)
{
    unsigned long mask = BIT_MASK(nr);
    unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
    unsigned long flags;

    _atomic_spin_lock_irqsave(p, flags);
    *p ^= mask;
    _atomic_spin_unlock_irqrestore(p, flags);
}

/**
 * test_and_set_bit - Set a bit and return its old value
 * @nr: Bit to set
 * @addr: Address to count from
 * test_and_set_bit - 设置一个位并且返回他的原来的值
 *　@nr: 被设置的位
 *　@addr: 开始计数的地址
 *
 * This operation is atomic and cannot be reordered.
 * It may be reordered on other architectures than x86.
 * It also implies a memory barrier.
 * 该操作是原子的并且不能被重新排序．他可能在其他架构中
　* 被重新排序而不是在x86架构上．他也包含了一个内存屏障．
 */
static inline int test_and_set_bit(int nr, volatile unsigned long *addr)
{
    unsigned long mask = BIT_MASK(nr);
    unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
    unsigned long old;
    unsigned long flags;

    _atomic_spin_lock_irqsave(p, flags);
    old = *p;
    *p = old | mask;
    _atomic_spin_unlock_irqrestore(p, flags);

    return (old & mask) != 0;
}

/**
 * test_and_clear_bit - Clear a bit and return its old value
 * @nr: Bit to clear
 * @addr: Address to count from
 * test_and_clear_bit - 清楚一个位并且返回他原来的值
 *　@nr: 被清除的位
 *　@addr: 开始计数的地址
 *
 * This operation is atomic and cannot be reordered.
 * It can be reorderdered on other architectures other than x86.
 * It also implies a memory barrier.
　* 该操作是原子的并且不能被重新排序．他可能在其他架构中
　* 被重新排序而不是在x86架构上．他也包含了一个内存屏障．
 */
static inline int test_and_clear_bit(int nr, volatile unsigned long *addr)
{
    unsigned long mask = BIT_MASK(nr);
    unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
    unsigned long old;
    unsigned long flags;

    _atomic_spin_lock_irqsave(p, flags);
    old = *p;
    *p = old & ~mask;
    _atomic_spin_unlock_irqrestore(p, flags);

    return (old & mask) != 0;
}

/**
 * test_and_change_bit - Change a bit and return its old value
 * @nr: Bit to change
 * @addr: Address to count from
 * test_and_change_bit - 改变一个位并且返回他原来的值
 *　@nr: 被改变的值
 *　@addr: 开始计数的位置
 *
 * This operation is atomic and cannot be reordered.
 * It also implies a memory barrier.
　* 该操作是原子的并且不能被重新排序．他也包含了一个内存屏障．
 */
static inline int test_and_change_bit(int nr, volatile unsigned long *addr)
{
    unsigned long mask = BIT_MASK(nr);
    unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
    unsigned long old;
    unsigned long flags;

    _atomic_spin_lock_irqsave(p, flags);
    old = *p;
    *p = old ^ mask;
    _atomic_spin_unlock_irqrestore(p, flags);

    return (old & mask) != 0;
}

#endif /* _ASM_GENERIC_BITOPS_ATOMIC_H */

这就是所有的原子位操作，主要是通过位移动来实现的．