順序鎖

順序鎖與讀寫自旋鎖很是相似，只是賦予了寫者較高的優先級：即便在讀者正在讀的時候也容許寫者繼續運行。這樣的好處是寫者不用等待（除非另外一個寫者正在寫），缺點是有些時候讀者不得不反覆屢次讀相同的數據直到它得到有效的副本。

每一個順序鎖就是包括兩個字段的seqlock_t結構：一個類型爲spinlock_t的lock字段和一個整型類型的sequence字段，第二個字段是一個順序計數器。每一個讀者都必須在讀數據先後兩次讀順序計數器，並檢查兩次讀到的值是否相同，若是不相同，說明新的寫者已經開始寫並增長了順序計數器，所以暗示讀者剛讀到的數據是無效的。

如下是Linux-2.6.30版本實現seqlock.h代碼：

#ifndef __LINUX_SEQLOCK_H
#define __LINUX_SEQLOCK_H
/*
 * Reader/writer consistent mechanism without starving writers. This type of
 * lock for data where the reader wants a consistent set of information
 * and is willing to retry if the information changes.  Readers never
 * block but they may have to retry if a writer is in
 * progress. Writers do not wait for readers. 
 *
 * This is not as cache friendly as brlock. Also, this will not work
 * for data that contains pointers, because any writer could
 * invalidate a pointer that a reader was following.
 *
 * Expected reader usage:
 *  do {
 *      seq = read_seqbegin(&foo);
 *  ...
 *      } while (read_seqretry(&foo, seq));
 *
 *
 * On non-SMP the spin locks disappear but the writer still needs
 * to increment the sequence variables because an interrupt routine could
 * change the state of the data.
 *
 * Based on x86_64 vsyscall gettimeofday 
 * by Keith Owens and Andrea Arcangeli
 */

#include <linux/spinlock.h>
#include <linux/preempt.h>

typedef struct {
    unsigned sequence;  // 順序計數器
    spinlock_t lock;    //鎖
} seqlock_t;

/*
 * These macros triggered gcc-3.x compile-time problems.  We think these are
 * OK now.  Be cautious.
 */
#define __SEQLOCK_UNLOCKED(lockname) \
         { 0, __SPIN_LOCK_UNLOCKED(lockname) }

#define SEQLOCK_UNLOCKED \
         __SEQLOCK_UNLOCKED(old_style_seqlock_init)

// 順序鎖初始化
#define seqlock_init(x)                 \
    do {                        \
        (x)->sequence = 0;          \
        spin_lock_init(&(x)->lock);     \
    } while (0)

#define DEFINE_SEQLOCK(x) \
        seqlock_t x = __SEQLOCK_UNLOCKED(x)

/* Lock out other writers and update the count.
 * Acts like a normal spin_lock/unlock.
 * Don't need preempt_disable() because that is in the spin_lock already.
 */
static inline void write_seqlock(seqlock_t *sl)    //寫加鎖
{
    spin_lock(&sl->lock);   //利用自旋鎖加鎖
    ++sl->sequence;         //增長順序計數器，值總爲奇數，代表寫者正在寫
    smp_wmb();
}

static inline void write_sequnlock(seqlock_t *sl)    //寫解鎖
{
    smp_wmb();
    sl->sequence++;     //遞增順序計數器，寫結束時再遞增一次，值總爲偶數，代表寫者結束寫操做了。
    spin_unlock(&sl->lock);
}

static inline int write_tryseqlock(seqlock_t *sl)
{
    int ret = spin_trylock(&sl->lock);

    if (ret) {
        ++sl->sequence;
        smp_wmb();
    }
    return ret;
}

/* Start of read calculation -- fetch last complete writer token */
static __always_inline unsigned read_seqbegin(const seqlock_t *sl)  //開始讀
{
    unsigned ret;

repeat:
    ret = sl->sequence;
    smp_rmb();
    // 奇偶數判斷，若是是奇數，說明寫者尚未完成寫操做，讀者須要重複讀取順序計數器直到值爲偶數，說明寫者操做完成了。
    if (unlikely(ret & 1)) {    
        cpu_relax();
        goto repeat;
    }

    return ret;
}

/*
 * Test if reader processed invalid data.
 *
 * If sequence value changed then writer changed data while in section.
 */
static __always_inline int read_seqretry(const seqlock_t *sl, unsigned start)  // 再次讀取順序計數器，與以前的作對比，檢測是否有寫者修改
{
    smp_rmb();

    return (sl->sequence != start);
}


/*
 * Version using sequence counter only.
 * This can be used when code has its own mutex protecting the
 * updating starting before the write_seqcountbeqin() and ending
 * after the write_seqcount_end().
 */
// 順序鎖簡化版本，若是外部代碼實現了鎖保證
typedef struct seqcount {
    unsigned sequence;
} seqcount_t;

#define SEQCNT_ZERO { 0 }
#define seqcount_init(x)    do { *(x) = (seqcount_t) SEQCNT_ZERO; } while (0)

/* Start of read using pointer to a sequence counter only.  */
static inline unsigned read_seqcount_begin(const seqcount_t *s)
{
    unsigned ret;

repeat:
    ret = s->sequence;
    smp_rmb();
    if (unlikely(ret & 1)) {
        cpu_relax();
        goto repeat;
    }
    return ret;
}

/*
 * Test if reader processed invalid data because sequence number has changed.
 */
static inline int read_seqcount_retry(const seqcount_t *s, unsigned start)
{
    smp_rmb();

    return s->sequence != start;
}


/*
 * Sequence counter only version assumes that callers are using their
 * own mutexing.
 */
static inline void write_seqcount_begin(seqcount_t *s)
{
    s->sequence++;
    smp_wmb();
}

static inline void write_seqcount_end(seqcount_t *s)
{
    smp_wmb();
    s->sequence++;
}

/*
 * Possible sw/hw IRQ protected versions of the interfaces.
 */
#define write_seqlock_irqsave(lock, flags)              \
    do { local_irq_save(flags); write_seqlock(lock); } while (0)
#define write_seqlock_irq(lock)                     \
    do { local_irq_disable();   write_seqlock(lock); } while (0)
#define write_seqlock_bh(lock)                      \
        do { local_bh_disable();    write_seqlock(lock); } while (0)

#define write_sequnlock_irqrestore(lock, flags)             \
    do { write_sequnlock(lock); local_irq_restore(flags); } while(0)
#define write_sequnlock_irq(lock)                   \
    do { write_sequnlock(lock); local_irq_enable(); } while(0)
#define write_sequnlock_bh(lock)                    \
    do { write_sequnlock(lock); local_bh_enable(); } while(0)

#define read_seqbegin_irqsave(lock, flags)              \
    ({ local_irq_save(flags);   read_seqbegin(lock); })

#define read_seqretry_irqrestore(lock, iv, flags)           \
    ({                              \
        int ret = read_seqretry(lock, iv);          \
        local_irq_restore(flags);               \
        ret;                            \
    })

#endif /* __LINUX_SEQLOCK_H */

用法示例：

/*
寫者:
write_seqlock(seq);
修改keyvalue
write_sequnlock(seq);
 
讀者:
do {
    seq = read_seqbegin(&foo);
    讀取keyvalue
} while (read_seqretry(&foo, seq));
*/

可關注微信公衆號：讓我思考一下，與我交流互鑑。