linux内核之spinlock

数据结构

typedef struct spinlock {
	union {
		struct raw_spinlock rlock;

#ifdef CONFIG_DEBUG_LOCK_ALLOC
# define LOCK_PADSIZE (offsetof(struct raw_spinlock, dep_map))
		struct {
			u8 __padding[LOCK_PADSIZE];
			struct lockdep_map dep_map;
		};
#endif
	};
} spinlock_t;

raw_spinlock

typedef struct raw_spinlock {
	arch_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;
#endif
} raw_spinlock_t;

arch_spinlock_t

typedef struct {
	union {
		u32 slock;
		struct __raw_tickets {
#ifdef __ARMEB__
			u16 next;
			u16 owner;
#else
			u16 owner;
			u16 next;
#endif
		} tickets;
	};
} arch_spinlock_t;

在linux2.6.25之前spinlock数据结构就是一个简单的无符号类型变量，slock为１表示锁未被持有，为０或负数为表示锁被持有，linux2.6.25后，spinlock实现了名为FIFO ticket-based算法的spinlock机制，这里称为排队自旋锁

static inline void __raw_spin_lock(raw_spinlock_t *lock)
{
	preempt_disable();
	spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);
	LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock);
}

static inline void do_raw_spin_lock(raw_spinlock_t *lock) __acquires(lock)
{
	__acquire(lock);
	arch_spin_lock(&lock->raw_lock);
}

进程调用的是__raw_spin_lock，最终调用的是具体机器架构相关代码
arch_spin_lock，其中首先禁用内核抢占，这个spinlock实现的关键点之一，
反设成立：临界区内允许抢占，持有的锁睡眠
１.若允许抢占，则相当于持有锁的进程睡眠，违背了此类锁不能休眠和快速执行的设计目标
２.抢占调试进程也可能去申请锁，会造成死锁
因此在临界区必须禁用抢占

以ARM32为例

static inline void arch_spin_lock(arch_spinlock_t *lock)
{
	unsigned long tmp;
	u32 newval;
	arch_spinlock_t lockval;

	prefetchw(&lock->slock);
	__asm__ __volatile__(
"1:	ldrex	%0, [%3]\n"
"	add	%1, %0, %4\n"
"	strex	%2, %1, [%3]\n"
"	teq	%2, #0\n"
"	bne	1b"
	: "=&r" (lockval), "=&r" (newval), "=&r" (tmp)
	: "r" (&lock->slock), "I" (1 << TICKET_SHIFT)
	: "cc");

	while (lockval.tickets.next != lockval.tickets.owner) {
		wfe();
		lockval.tickets.owner = ACCESS_ONCE(lock->tickets.owner);
	}

	smp_mb();
}

刚开始lockval及lock中的tickets.next与tickets.owner里面的值都为０，执行
ldrex %0, [%3]后，lockval为的owner next为０，执行
" add %1, %0, %4\n"
" strex %2, %1, [%3]\n"
后，lock->slock的next加１，lockval.tickets.next＝＝lockval.tickets.owner　＝＝　０；
若再有其他进程第二次申请这个资源时，lockval.tickets.next (1)不等于　lockval.tickets.owner(0)则在while循环里打转，进入执行wfe();睡眠，申请锁不成功
当第一次进程解锁时，lock->tickets.owner+１后也等于１，唤醒第二个进程所在CPU后，进行因此执行lockval.tickets.owner = ACCESS_ONCE(lock->tickets.owner);此时lockval.tickets.owner(1),再循环时，lockval.tickets.next (1)等于lockval.tickets.owner(1)退出循环，因此第二次申请锁及所在资源时成功

static inline void arch_spin_unlock(arch_spinlock_t *lock)
{
	smp_mb();
	lock->tickets.owner++;
	dsb_sev();
}