- Spinlock 是内核中提供的一种比较常见的锁机制，自旋锁是“原地等待”的方式解决资源冲突的，即，一个线程获取了一个自旋锁后，另外一个线程期望获取该自旋锁，获取不到，只能够原地“打转”（忙等待）。由于自旋锁的这个忙等待的特性，注定了它使用场景上的限制 —— 自旋锁不应该被长时间的持有（消耗 CPU 资源）。
- 为了避免因为调度可能自旋的线程而浪费CPU，可以尝试获取从运行队列移出的其他线程持有的锁，只要持有自旋锁的代码正在运行，内核就会禁止抢占。禁止抢占可以防止自旋锁持有者被移出运行队列，这会导致等待进程长时间自旋而消耗CPU。
- 只要有一个任务持有自旋锁，其他任务就可能在等待的时候自旋。用自旋锁时，必须确保不会长时间持有它。可能有人会说在循环中自旋所浪费CPU时间，比线程进入睡眠，上下文切换到其他线程或进程，然后再唤醒所浪费的CPU更好一些。在一个处理器上自旋意味着在该处理器上不能再运行其他任何任务；在单核机器上使用自旋锁是没有任何意义的。最佳情况下，系统可能会变慢，最糟情况下，和互斥锁一样会造成死锁。正是因为这个原因，内核在处理单个处理器上的spin_lock(spinlock_t *lock)调用时将禁止抢占。在单个处理器（核）系统上，应该使用spin_lock_irqsave()和spin_unlock_ irqrestore()，它们分别禁用处理器上中断，防止中断并发。
- 由于事先并不知道所写驱动程序运行在什么系统上，因此建议使用spin_lock_irqsave (spinlock_t *lock, unsigned long flags)获取自旋锁，该函数会在获取自旋锁之前，禁止当前处理器（调用该函数的处理器）上中断。spin_lock_irqsave在内部调用local_irq_save (flags)和preempt_disable()，前者是一个依赖于体系结构的函数，用于保存IRQ状态，后者禁止在相关CPU上发生抢占。然后应该用spin_unlock_irqrestore()释放锁，它执行的操作与我们前面列举的相反。
自旋锁的特点
1.当发生访问资源冲突的时候，可以有两个选择：一个是死等，一个是挂起当前进程，调度其他进程执行。spin lock是一种死等的机制.
2.只允许一个thread进入。semaphore可以允许多个thread进入，spin lock不行，一次只能有一个thread获取锁并进入临界区，其他的thread都是在门口不断的尝试。
3.临界区执行时间要短，临界区执行时间过长，等待该自旋锁空等的时间越长，浪费CPU资源。
4.可以在中断上下文执行。由于不睡眠，因此spin lock可以在中断上下文中适用。
自旋锁的定义
struct liblockdep_pthread_mutex {
pthread_mutex_t mutex;
struct lock_class_key key;
struct lockdep_map dep_map;
};
typedef struct liblockdep_pthread_mutex liblockdep_pthread_mutex_t;
#define pthread_mutex_t liblockdep_pthread_mutex_t
#define spinlock_t pthread_mutex_t
static __always_inline void spin_lock(spinlock_t *lock)
{
raw_spin_lock(&lock->rlock);
}
spin_lock的调用关系
spin_lock
|
+ -----> raw_spin_lock
|
+------> _raw_spin_lock
|
+--------> __raw_spin_lock
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);
}
spin_lock_irq的调用关系
spin_lock_irq
|
+ -----> raw_spin_lock_irq
|
+------> _raw_spin_lock_irq
|
+--------> __raw_spin_lock_irq
static inline void __raw_spin_lock_irq(raw_spinlock_t *lock)
{
local_irq_disable();
preempt_disable();
spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);
LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock);
}
spin_trylock最终调用的是__raw_spin_trylock，成功返回1，获取失败返回0
static inline int __raw_spin_trylock(raw_spinlock_t *lock)
{
preempt_disable();
if (do_raw_spin_trylock(lock)) {
spin_acquire(&lock->dep_map, 0, 1, _RET_IP_);
return 1;
}
preempt_enable();
return 0;
}
自旋锁的使用
1 定义自旋锁变量 spinlock_t testlock；
2 初始化锁 spin_lock_init(&testlock)；
以上两步也可以通过DEFINE_SPINLOCK(testlock)来实现
3 获取锁 spin_lock/spin_lock_irq/spin_lock_irqsave
4 释放锁 spin_unlock/spin_unlock_irq/spin_unlock_restore
实例
drivers/input/keyboard/gpio_keys.c
struct gpio_button_data {
......
spinlock_t lock;
......
};
spin_lock_init(&bdata->lock);
static irqreturn_t gpio_keys_irq_isr(int irq, void *dev_id)
{
struct gpio_button_data *bdata = dev_id;
struct input_dev *input = bdata->input;
unsigned long flags;
BUG_ON(irq != bdata->irq);
spin_lock_irqsave(&bdata->lock, flags);
if (!bdata->key_pressed) {
if (bdata->button->wakeup)
pm_wakeup_event(bdata->input->dev.parent, 0);
input_event(input, EV_KEY, *bdata->code, 1);
input_sync(input);
if (!bdata->release_delay) {
input_event(input, EV_KEY, *bdata->code, 0);
input_sync(input);
goto out;
}
bdata->key_pressed = true;
}
if (bdata->release_delay)
hrtimer_start(&bdata->release_timer,
ms_to_ktime(bdata->release_delay),
HRTIMER_MODE_REL_HARD);
out:
spin_unlock_irqrestore(&bdata->lock, flags);
return IRQ_HANDLED;
}
drivers/cpuidle/cpuidle-ux500.c
void nv50_crc_handle_vblank(struct nv50_head *head)
{
......
/*
* We don't lose events if we aren't able to report CRCs until the
* next vblank, so only report CRCs if the locks we need aren't
* contended to prevent missing an actual vblank event
*/
if (!spin_trylock(&crc->lock))
return;
if (!crc->src)
goto out;
out:
spin_unlock(&crc->lock);
}
