spinlock_t pgd_lock = SPIN_LOCK_UNLOCKED;　//锁初始化
void pgd_dtor(void *pgd, kmem_cache_t *cache, unsigned long unused) { unsigned long flags; //能从中断上下文中被调用   spin_lock_irqsave(&pgd_lock, flags);//加锁 pgd_list_del(pgd); spin_unlock_irqrestore(&pgd_lock, flags);//解锁 }

typedef struct {raw_spinlock_t raw_lock;
#ifdef CONFIG_GENERIC_LOCKBREAK    /*引入另一个自旋锁*/unsigned int break_lock; #endif #ifdef CONFIG_DEBUG_SPINLOCK /*用于调试自旋锁*/ unsigned int magic, owner_cpu; void *owner; #endif #ifdef CONFIG_DEBUG_LOCK_ALLOC struct lockdep_map dep_map; /*映射lock实例到lock-class对象 #endif } spinlock_t;

typedef struct {volatile unsigned int slock; } raw_spinlock_t;

# define spin_lock_init(lock)                    /do { *(lock) = SPIN_LOCK_UNLOCKED; } while (0)

# define __SPIN_LOCK_UNLOCKED(lockname) /(spinlock_t) {   .raw_lock = __RAW_SPIN_LOCK_UNLOCKED,  /SPIN_DEP_MAP_INIT(lockname) }#define __RAW_SPIN_LOCK_UNLOCKED  { 1 }

#define spin_lock_irqsave(lock, flags)  flags = _spin_lock_irqsave(lock)

unsigned long __lockfunc _spin_lock_irqsave(spinlock_t *lock)
{ unsigned long flags;   local_irq_save(flags); //将状态寄存器的值写入flags保存 preempt_disable(); //关闭内核抢占，内核抢占锁加1 spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);   #ifdef CONFIG_LOCKDEP LOCK_CONTENDED(lock, _raw_spin_trylock, _raw_spin_lock); #else _raw_spin_lock_flags(lock, &flags); #endif return flags; }

#define local_irq_save(x) __asm__ __volatile__("pushfl ; popl %0 ; cli":"=g" (x): /* no input */ :"memory")

# define _raw_spin_lock_flags(lock, flags) /__raw_spin_lock_flags(&(lock)->raw_lock, *(flags�

#define __raw_spin_lock_flags(lock, flags) __raw_spin_lock(lock)
static __always_inline void __raw_spin_lock(raw_spinlock_t *lock) { int inc = 0x00010000; int tmp; /*指令前缀lock用来锁住内存控制器，不让其他处理器访问，保证指令执行的原子性*/ asm volatile("lock ; xaddl %0, %1/n" // lock->slock=lock->slock+inc "movzwl %w0, %2/n/t" //tmp=inc "shrl $16, %0/n/t" //inc >> 16 后，inc=1 "1:/t" "cmpl %0, %2/n/t" //比较inc与lock->slock "je 2f/n/t" //如果inc与lock->slock相等，跳转到2 "rep ; nop/n/t" //空操作 "movzwl %1, %2/n/t" //tmp=lock->slock /* 这里不需要读内存屏障指令lfence，因为装载是排序的*/ "jmp 1b/n" //跳转到1 "2:" : "+Q" (inc), "+m" (lock->slock), "=r" (tmp) : : "memory", "cc"); }

#define spin_unlock_irqrestore(lock, flags) _spin_unlock_irqrestore(lock, flags)

void __lockfunc _spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags) { spin_release(&lock->dep_map, 1, _RET_IP_); _raw_spin_unlock(lock); //解锁 local_irq_restore(flags); //开中断，将flag的值存入状态寄存器 preempt_enable(); //开启内核抢占 }   # define _raw_spin_unlock(lock) __raw_spin_unlock(&(lock)->raw_lock)

static __always_inline void __raw_spin_unlock(raw_spinlock_t *lock)
{ asm volatile(UNLOCK_LOCK_PREFIX "incw %0" // lock->slock= lock->slock +1 : "+m" (lock->slock) : : "memory", "cc"); }

读/写自旋锁

"读/写自旋锁"用来解决读者/写者问题。如果有多个线程（进程、中断处理程序、底半部例程）以只读的方式访问一个临界区数据，读/写自旋锁允许多个线程同时读取数据。如果一个线程需要对临界区数据进行写操作，它必须获取写锁，只有在没有读者或写者进行操作时，写者才独占临界区数据进行写操作。读操作时需要获取读锁，写操作时需要获取写锁。

Linux内核为读/写自旋锁提供了操作API函数初始化、测试和设置自旋锁。API函数功能说明如表5。

表5 读/写自旋锁API函数功能说明

用户使用读/写自旋锁，应先自旋锁的状态值初始化为锁初始化为RW_LOCK_BIAS，即0x01000000，表示为未锁状态。

读/写自旋锁用结构rwlock_t描述，它的主要成员为锁状态值变量lock，结构rwlock_t列出如下（在include/linux/spinlock_types.h中）：

typedef struct {raw_rwlock_t raw_lock;……
} rwlock_t;   typedef struct { unsigned int lock; } raw_rwlock_t;

在结构raw_rwlock_t中，读/写自旋锁状态变量lock为32位，它分为2个部分，0~23位是一个24位计数器，表示对临界数据区进行并发读操作的线程数，线程数以补码形式存入计数器；第24位为表示"未锁"的状态位，在没有线程读或写临界区时，设置为1，否则，设置为0。

如果自旋锁设置了"未锁"状态且无读者，那么lock值为0x01000000；如果写者已获得自旋锁且无读者，则未锁状态位清0，lock值为0x00000000。如果有一个、2个或多个线程获取锁对临界数据区进行读操作，则lock值为0x00ffffff、0x00fffffe等（第24位清0表示未锁，第0~23位为读者个数的补码）。

下面说明读/写自旋锁API函数的实现：

# define rwlock_init(lock)                 /do { *(lock) = RW_LOCK_UNLOCKED; } while (0)#define RW_LOCK_UNLOCKED  __RW_LOCK_UNLOCKED(old_style_rw_init)
#define __RW_LOCK_UNLOCKED(lockname) /(rwlock_t)    {   .raw_lock = __RAW_RW_LOCK_UNLOCKED,    /RW_DEP_MAP_INIT(lockname) }#define __RAW_RW_LOCK_UNLOCKED      { RW_LOCK_BIAS }
#define RW_LOCK_BIAS         0x01000000

#define read_lock(lock)           _read_lock(lock)

void __lockfunc _read_lock(rwlock_t *lock)
{preempt_disable(); //关闭内核抢占 rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_); /*用于自旋锁调试*/ /*下面语句相当于_raw_read_lock（lock）*/ LOCK_CONTENDED(lock, _raw_read_trylock, _raw_read_lock); } # define _raw_read_lock(rwlock) __raw_read_lock(&(rwlock)->raw_lock)

static inline void __raw_read_lock(raw_rwlock_t *rw) { asm volatile(LOCK_PREFIX " subl $1,(%0)/n/t" //*rw=*rw-1 "jns 1f/n" //如果符号位为0，跳转到1 "call __read_lock_failed/n/t" "1:/n" ::LOCK_PTR_REG (rw) : "memory"); }

/* rdi指向rwlock_t */
ENTRY(__read_lock_failed)CFI_STARTPROC           //即：#define CFI_STARTPROC .cfi_startproc LOCK_PREFIX incl (%rdi) // *rw=*rw+1，值为0x00000000 1: rep //循环等待*rw值被写者修改为0x01000000 nop cmpl $1,(%rdi) // *rw-1 js 1b //如果符号位为1，表明*rw值还为0x00000000，跳转到1进行循环等待 LOCK_PREFIX /* 运行到这里，说明写者操作完成，*rw值为0x01000000 */ decl (%rdi) //执行加读者锁操作*rw＝*rw-1 js __read_lock_failed//如果符号位为1，表明*rw值为0x00000000，跳转到函数开头进行循环等待 ret CFI_ENDPROC //即：#define CFI_ENDPROC .cfi_endproc END(__read_lock_failed)

# define read_unlock(lock) /
do {__raw_read_unlock(&(lock)->raw_lock); __release(lock); } while (0)
# define __release(x)   __context__(x,-1)
static inline void __raw_read_unlock(raw_rwlock_t *rw) { /* rw->lock= rw->lock +1*/ asm volatile(LOCK_PREFIX "incl %0" :"+m" (rw->lock) : : "memory"); }

#define write_lock(lock)      _write_lock(lock)

void __lockfunc _write_lock(rwlock_t *lock)
{preempt_disable(); /*关闭内核抢占*/ rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_); /*用于自旋锁调试*/ /*下面语句相当于_raw_write_lock(lock)*/ LOCK_CONTENDED(lock, _raw_write_trylock, _raw_write_lock); }   # define _raw_write_lock(rwlock) __raw_write_lock(&(rwlock)->raw_lock)   static inline void __raw_write_lock(raw_rwlock_t *rw) { asm volatile(LOCK_PREFIX " subl %1,(%0)/n/t" /* RW_LOCK_BIAS-rw*/ /* 如果没有读者或写者，*rw为0x01000000，RW_LOCK_BIAS-rw为0 */ "jz 1f/n" /*值为0，跳转到1*/ "call __write_lock_failed/n/t" /*加写者锁失败*/ "1:/n" /* RW_LOCK_BIAS定义为0x01000000*/ ::LOCK_PTR_REG (rw), "i" (RW_LOCK_BIAS) : "memory"); }

/* rdi: pointer to rwlock_t */
ENTRY(__write_lock_failed)CFI_STARTPROC         /*用于调试时将调用帧信息写入 LOCK_PREFIX addl $RW_LOCK_BIAS,(%rdi) // *rw=*rw+$RW_LOCK_BIAS，还原为尝试加锁前的状态值 1: rep nop cmpl $RW_LOCK_BIAS,(%rdi) //比较结果 = *rw-$RW_LOCK_BIAS jne 1b //比较结果不为0，说明有写者或读者在访问临界区，跳转到1进行循环等待 LOCK_PREFIX //锁内存管理器，确保原子操作 /*运行到这里，说明锁空闲，*rw值为0x010000，执行加写者锁操作*/ subl $RW_LOCK_BIAS,(%rdi) //*rw=*rw-RW_LOCK_BIAS jnz __write_lock_failed /*如果*rw不为0，说明加写者锁失败，跳转到函数头循环等待*/ ret CFI_ENDPROC END(__write_lock_failed)

# define write_unlock(lock) /do {__raw_write_unlock(&(lock)->raw_lock); __release(lock); } while (0)

void __lockfunc _write_unlock(rwlock_t *lock)
{rwlock_release(&lock->dep_map, 1, _RET_IP_); _raw_write_unlock(lock); preempt_enable(); /*打开内核抢占*/ }   # define _raw_write_unlock(rwlock) __raw_write_unlock(&(rwlock)->raw_lock)

static inline void __raw_write_unlock(raw_rwlock_t *rw) { asm volatile(LOCK_PREFIX "addl %1, %0" /* RW_LOCK_BIAS+rw*/ : "+m" (rw->lock) : "i" (RW_LOCK_BIAS) : "memory"); }

u64 get_jiffies_64(void)
{unsigned long seq; u64 ret;   do { seq = read_seqbegin(&xtime_lock); //获取当前的顺序号 ret = jiffies_64; //读取临界区数据 /*检查seq值与当前顺序号是否相等，若不等，说明有写者开始工作，函数read_seqretry返回1，继续循环*/ } while (read_seqretry(&xtime_lock, seq)); return ret; }

typedef struct {unsigned sequence;spinlock_t lock; } seqlock_t;

do {seq = read_seqbegin(&foo); //返回当前的顺序号 ... //临界区数据操作 } while (read_seqretry(&foo, seq));

#define seqlock_init(x)                 /do {                       /(x)->sequence = 0;         /spin_lock_init(&(x)->lock);     /} while (0)

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(); //加上SMP写内存屏障 sl->sequence++; //顺序号加1 spin_unlock(&sl->lock); //解开自旋锁 }

static __always_inline unsigned read_seqbegin(const seqlock_t *sl) { unsigned ret;   repeat: ret = sl->sequence; smp_rmb(); //加上SMP读内存屏障 if (unlikely(ret & 1)) { //如果ret & 1为true，表示顺序号为奇数，写者正在写操作 cpu_relax(); //空操作 goto repeat; }   return ret; }

static __always_inline int read_seqretry(const seqlock_t *sl, unsigned start) { smp_rmb();//加上SMP读内存屏障   return (sl->sequence != start); //顺序锁的顺序号值与读操作开始时的顺序号值start不一致 }

struct task_struct {……int lock_depth;     /* BKL锁深度*/
……
}

static  __cacheline_aligned_in_smp DEFINE_SPINLOCK(kernel_flag);