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 */

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