一 应用接口函数
spinlock_t my_lock;
unsigned long irqflags;
spin_lock_init(&my_lock);
spin_lock_irqsave(&my_lock, irqflags);
spin_unlock_irqrestore(&my_lock, irqflags);
二 详细说明
1 数据结构
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;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;typedef struct {
union {
u32 slock;
struct __raw_tickets {
#ifdef __ARMEB__
u16 next;
u16 owner;
#else
u16 owner;
u16 next;
#endif
} tickets;
};
} arch_spinlock_t;arch_spinlock_t是架构相关的type，其中包括slock和__raw_tickets两个成员。__ARMEB__代表Big-Endian，这样slock被划分成两部分：
u32 slock
-----------------------------------------------------------------------------------
| u16 next | u16 owner |
-----------------------------------------------------------------------------------
bit31 bit16 bit15 bit0
2 spin_lock_init()
#define spin_lock_init(_lock) \
do { \
spinlock_check(_lock); \
raw_spin_lock_init(&(_lock)->rlock); \
} while (0)static inline raw_spinlock_t *spinlock_check(spinlock_t *lock)
{
return &lock->rlock;
}# define raw_spin_lock_init(lock) \
do { *(lock) = __RAW_SPIN_LOCK_UNLOCKED(lock); } while (0)#define __RAW_SPIN_LOCK_UNLOCKED(lockname) \
(raw_spinlock_t) __RAW_SPIN_LOCK_INITIALIZER(lockname)#define __RAW_SPIN_LOCK_INITIALIZER(lockname) \
{ \
.raw_lock = __ARCH_SPIN_LOCK_UNLOCKED, \
SPIN_DEBUG_INIT(lockname) \
SPIN_DEP_MAP_INIT(lockname) }#define __ARCH_SPIN_LOCK_UNLOCKED { { 0 } }typedef struct {
union {
u32 slock;
struct __raw_tickets {
#ifdef __ARMEB__
u16 next;
u16 owner;
#else
u16 owner;
u16 next;
#endif
} tickets;
};
} arch_spinlock_t;3 spin_lock_irqsave()
#define spin_lock_irqsave(lock, flags) \
do { \
raw_spin_lock_irqsave(spinlock_check(lock), flags); \
} while (0)#define raw_spin_lock_irqsave(lock, flags) \
do { \
typecheck(unsigned long, flags); \
flags = _raw_spin_lock_irqsave(lock); \
} while (0)unsigned long __lockfunc _raw_spin_lock_irqsave(raw_spinlock_t *lock)
{
return __raw_spin_lock_irqsave(lock);
}
static inline unsigned long __raw_spin_lock_irqsave(raw_spinlock_t *lock)
{
unsigned long flags;
local_irq_save(flags);//禁止中断
preempt_disable();
/*关闭调度器的抢占,原因是避免在当前进程持有lock的情况下，CPU被中断后，会调到执行另一个进程，这样，当另一进程也试图spin_lock，因为spin_lock本身不会sleep，就会产生死锁现象。所以要暂时关闭调度器抢占性。*/
spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);
/*
* On lockdep we dont want the hand-coded irq-enable of
* do_raw_spin_lock_flags() code, because lockdep assumes
* that interrupts are not re-enabled during lock-acquire:
*/
#ifdef CONFIG_LOCKDEP
LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock);
#else
do_raw_spin_lock_flags(lock, &flags);
#endif
return flags;
}#ifdef CONFIG_DEBUG_LOCK_ALLOC
# ifdef CONFIG_PROVE_LOCKING
# define spin_acquire(l, s, t, i) lock_acquire(l, s, t, 0, 2, NULL, i)
# define spin_acquire_nest(l, s, t, n, i) lock_acquire(l, s, t, 0, 2, n, i)
# else
# define spin_acquire(l, s, t, i) lock_acquire(l, s, t, 0, 1, NULL, i)
# define spin_acquire_nest(l, s, t, n, i) lock_acquire(l, s, t, 0, 1, NULL, i)
# endif
# define spin_release(l, n, i) lock_release(l, n, i)
#else
# define spin_acquire(l, s, t, i) do { } while (0)
# define spin_release(l, n, i) do { } while (0)
#endif
spin_acquire()是供debug时使用，正常时定义为空。
#ifdef CONFIG_LOCK_STAT
extern void lock_contended(struct lockdep_map *lock, unsigned long ip);
extern void lock_acquired(struct lockdep_map *lock, unsigned long ip);
LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock);
#define LOCK_CONTENDED(_lock, try, lock) \
do { \
if (!try(_lock)) { \
lock_contended(&(_lock)->dep_map, _RET_IP_); \
lock(_lock); \
} \
lock_acquired(&(_lock)->dep_map, _RET_IP_); \
} while (0)
/*先调用do_raw_spin_trylock()尝试获取lock。如果没有拿到lock，才会调用do_raw_spin_lock()自旋lock，这里会sleep。
*/
#else /* CONFIG_LOCK_STAT */
#define lock_contended(lockdep_map, ip) do {} while (0)
#define lock_acquired(lockdep_map, ip) do {} while (0)
#define LOCK_CONTENDED(_lock, try, lock) \
lock(_lock)
#endif /* CONFIG_LOCK_STAT */3.1 spin_trylock
static inline int do_raw_spin_trylock(raw_spinlock_t *lock)
{
return arch_spin_trylock(&(lock)->raw_lock);
}static inline int arch_spin_trylock(arch_spinlock_t *lock)
{
unsigned long tmp;
u32 slock;
__asm__ __volatile__(
" ldrex %0, [%2]\n" //%0表示第0个操作数，以此类推
" subs %1, %0, %0, ror #16\n"
" addeq %0, %0, %3\n"
" strexeq %1, %0, [%2]"
: "=&r" (slock), "=&r" (tmp) //以下是操作数说明，“=”表示输出
: "r" (&lock->slock), "I" (1 << TICKET_SHIFT)
: "cc");
if (tmp == 0) {
smp_mb();
return 1;
} else {
return 0;
}
}slock = lock->slock;
tmp = slock - cpu_to_le32;(slock)//ror是循环右移，锁可用tmp=0，否则tmp=1
if (tmp == 0) slock = slock + (1 << 16);//相当于slock.tickets.next+1
strex和ldrex是一对指令，只有ARM core版本>=6才有。可以请bus监控从ldrex到strex之间有无其他的CPU或DMA来存取这个位址，若有的话，strex会在第一个寄存器里设定值为1（non-exclusive by this CPU）并且令store动作失败，若没有，strex会在第一个寄存器里设定值为0（exclusive access by this CPU），并且令store动作成功。
if (tmp == 0) lock->slock = slock; tmp = 0; strex保证了原子的操作，如果check到锁可用，并上锁tmp=0；如果上锁失败，tmp = 1。
arch_spin_trylock()函数是一个原子操作，它测试lock是否被上锁，若未上锁，上锁；返回1；否则返回0。
3.2 spin_lock
void do_raw_spin_lock(raw_spinlock_t *lock)
{
debug_spin_lock_before(lock);
if (unlikely(!arch_spin_trylock(&lock->raw_lock)))
__spin_lock_debug(lock);
debug_spin_lock_after(lock);
}static inline void do_raw_spin_lock(raw_spinlock_t *lock) __acquires(lock)
{
__acquire(lock);
arch_spin_lock(&lock->raw_lock);
}static inline void arch_spin_lock(arch_spinlock_t *lock)
{
unsigned long tmp;
u32 newval;
arch_spinlock_t lockval;
__asm__ __volatile__(
"1: ldrex %0, [%3]\n"
" add %1, %0, %4\n"
" strex %2, %1, [%3]\n"
" teq %2, #0\n" //影响cpsr->Z
" 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->slock;
newval = lockval + (1 << TICKET_SHIFT);//相当于lockval.tickets.next+1
lock->slock = newval;//tmp的值取决于该原则操作是否成功，成功为0
if (tmp != 0) 跳转到第一个tag(标号1)处，goto 1;//store 失败就不停地跳回去
标号f: 表示往前跳，顺序执行的话是没有运行过的程序，front的意思。
标号b: 表示跳转到以前执行过的语句，第一个1标号处，back的意思。
if (lockval.tickets.next != lockval.tickets.owner)，代表锁已被锁定，则执行wfe指令。则通过wfe指令进入suspend mode(clock停止)，直到该锁被释放时发出的sev指令，CPU才会跳出suspend mode，然后检查，if (lockval.tickets.next != lockval.tickets.owner)就继续等。
4 spin_unlock_irqrestore()
static inline void spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags)
{
raw_spin_unlock_irqrestore(&lock->rlock, flags);
}#define raw_spin_unlock_irqrestore(lock, flags) \
do { \
typecheck(unsigned long, flags); \
_raw_spin_unlock_irqrestore(lock, flags); \
} while (0)void __lockfunc _raw_spin_unlock_irqrestore(raw_spinlock_t *lock, unsigned long flags)
{
__raw_spin_unlock_irqrestore(lock, flags);
}static inline void __raw_spin_unlock_irqrestore(raw_spinlock_t *lock,
unsigned long flags)
{
spin_release(&lock->dep_map, 1, _RET_IP_);
do_raw_spin_unlock(lock);
local_irq_restore(flags);//允许中断
preempt_enable();//允许抢占
}static inline void do_raw_spin_unlock(raw_spinlock_t *lock) __releases(lock)
{
arch_spin_unlock(&lock->raw_lock);
__release(lock);
}static inline void arch_spin_unlock(arch_spinlock_t *lock)
{
smp_mb();
lock->tickets.owner++;
dsb_sev();
}static inline void dsb_sev(void)
{
#if __LINUX_ARM_ARCH__ >= 7
__asm__ __volatile__ (
"dsb\n"
SEV
);
#else
__asm__ __volatile__ (
"mcr p15, 0, %0, c7, c10, 4\n"
SEV
: : "r" (0)
);
#endif
}
对于armv7以上的架构，是调用dsb命令，保证它执行完毕后，才会执行程序中位于此指令后的指令。
可以看出，如果有其他的task再次调用spin_lock，就会因为lock时的lockval.tickets.next++，
从而，lockval.tickets.next != lockval.tickets.owner一直在loop中。直到持锁的task调用spin_unlock，lockval.tickets.owner++后，才会跳出loop。
这个机制是在Linux-2.6.25中加入内核，Linux-3.6中加入ARM架构的，也就是接下来介绍的，大名鼎鼎的 Ticket spinlocks排队自旋锁。
可以看出，如果有其他的task再次调用spin_lock，就会因为lock时的lockval.tickets.next++，
从而，lockval.tickets.next != lockval.tickets.owner一直在loop中。直到持锁的task调用spin_unlock，lockval.tickets.owner++后，才会跳出loop。
这个机制是在Linux-2.6.25中加入内核，Linux-3.6中加入ARM架构的，也就是接下来介绍的，大名鼎鼎的 Ticket spinlocks排队自旋锁。
三 Ticket spinlocks
传统自旋锁的“不公平”问题在锁竞争激烈的服务器系统中尤为严重，因此 Linux 内核开发者 Nick Piggin 在 Linux 内核 2.6.25 版本中引入了排队自旋锁：通过保存执行线程申请锁的顺序信息来解决“不公平”问题。
排队自旋锁仍然使用原有的raw_spinlock_t数据结构，但是赋予slock域新的含义。为了保存顺序信息，slock域被分成两部分，分别保存锁持有者和未来锁申请者的排队序号(Ticket Number)，如下所示：
owner和next域均为16位，其中owner域为slock的低 16 位。可见排队自旋锁最多支持 2^16=65536个处理器。只有next域与owner域相等时，才表明锁处于未使用状态（此时也无人申请该锁）。排队自旋锁初始化时slock被置为0，即owner和next置为0。内核执行线程申请自旋锁时，原子地将next域加1，并将原next值作为自己的排队序号。如果该排队序号等于申请时的owner值，说明自旋锁处于未使用状态，则直接获得锁；否则，该线程忙等待检查owner域是否等于自己持有的排队序号，一旦相等，则表明锁轮到自己获取。线程释放锁时，原子地将owner域加1即可，下一个线程将会发现这一变化，从忙等待状态中退出。线程将严格地按照申请顺序依次获取排队自旋锁，从而完全解决了“不公平”问题。
排队自旋锁仍然使用原有的raw_spinlock_t数据结构，但是赋予slock域新的含义。为了保存顺序信息，slock域被分成两部分，分别保存锁持有者和未来锁申请者的排队序号(Ticket Number)，如下所示：
u32 slock
-----------------------------------------------------------------------------------
| u16 next | u16 owner |
-----------------------------------------------------------------------------------
bit31 bit16 bit15 bit0
owner和next域均为16位，其中owner域为slock的低 16 位。可见排队自旋锁最多支持 2^16=65536个处理器。只有next域与owner域相等时，才表明锁处于未使用状态（此时也无人申请该锁）。排队自旋锁初始化时slock被置为0，即owner和next置为0。内核执行线程申请自旋锁时，原子地将next域加1，并将原next值作为自己的排队序号。如果该排队序号等于申请时的owner值，说明自旋锁处于未使用状态，则直接获得锁；否则，该线程忙等待检查owner域是否等于自己持有的排队序号，一旦相等，则表明锁轮到自己获取。线程释放锁时，原子地将owner域加1即可，下一个线程将会发现这一变化，从忙等待状态中退出。线程将严格地按照申请顺序依次获取排队自旋锁，从而完全解决了“不公平”问题。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
