Linux内核同步方法——自旋锁（spin lock）

最新推荐文章于 2024-07-28 11:29:54 发布

渔舟唱晚_hanpan

最新推荐文章于 2024-07-28 11:29:54 发布

阅读量3.1w

点赞数 10

分类专栏： Linux 文章标签： spin_lock

本文链接：https://blog.csdn.net/hhhanpan/article/details/80624244

版权

Linux 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

自旋锁

Linux的的内核最常见的锁是自旋锁。自旋锁最多只能被一个可执行线程持有。如果一个执行线程试图获得一个被已经持有（争用）的自旋锁，那么该线程就会一直进行忙循环-旋转-等待锁重新可用要是锁未被争用，请求锁的执行线程就可以立即得到它，继续执行。

在任意时间，自旋锁都可以防止多于一个的执行线程同时进入临界区。

同一个锁可以用在多个位置，例如，对于给定数据的所有访问都可以得到保护和同步。

-------------------------------------------------- -------------------------------------------

在Linux的2.6.11.12内核版本中，自旋锁的实现接口定义在包含\ linux的\ <spinlock.h>中，与体系结构相关的代码定义包含在\ ASM \ <spinlock.h>中。

基本结构

自旋锁的结构体是spinlock_t，

typedef struct {
	/**
	 * 该字段表示自旋锁的状态，值为1表示未加锁，任何负数和0都表示加锁
	 */
	volatile unsigned int slock;
#ifdef CONFIG_DEBUG_SPINLOCK
	unsigned magic;
#endif
#ifdef CONFIG_PREEMPT
	/**
	 * 表示进程正在忙等待自旋锁。
	 * 只有内核支持SMP和内核抢占时才使用本标志。
	 */
	unsigned int break_lock;
#endif
} spinlock_t;

spin_lock（）

/**
 * 当内核不可抢占时，spin_lock的实现过程。
 */
#define _spin_lock(lock)	\
do { \
	/**
	 * 调用preempt_disable禁用抢占。
	 */
	preempt_disable(); \
	/**
	 * _raw_spin_lock对自旋锁的slock字段执行原子性的测试和设置操作。
	 */
	_raw_spin_lock(lock); \
	__acquire(lock); \
} while(0)

函数_raw_spin_lock（）对自旋锁的SLOCK字段执行原子性的测试和设置操作。

#define _raw_spin_lock(x)		\
	do { \
	 	CHECK_LOCK(x); \
		if ((x)->lock&&(x)->babble) { \
			(x)->babble--; \
			printk("%s:%d: spin_lock(%s:%p) already locked by %s/%d\n", \
					__FILE__,__LINE__, (x)->module, \
					(x), (x)->owner, (x)->oline); \
		} \
		(x)->lock = 1; \
		(x)->owner = __FILE__; \
		(x)->oline = __LINE__; \
	} while (0)

spin_unlock（）

#define _spin_unlock(lock) \
do { \
	_raw_spin_unlock(lock); \
	preempt_enable(); \
	__release(lock); \
} while (0)

static inline void _raw_spin_unlock(spinlock_t *lock)
{
#ifdef CONFIG_DEBUG_SPINLOCK
	BUG_ON(lock->magic != SPINLOCK_MAGIC);
	BUG_ON(!spin_is_locked(lock));
#endif
	__asm__ __volatile__(
		spin_unlock_string
	);
}

宏函数spin_unlock_string

在spin_unlock_string中，％0即为锁 - > s 锁，movb指令将锁 - > s 锁定为1，movb指令本身就是原子操作，所以不需要锁总线。

#define spin_unlock_string \
	"movb $1,%0" \
		:"=m" (lock->slock) : : "memory"

自旋锁在同一时刻至多被一个执行线程持有，所以一个时刻只有一个线程位于临界区内，这就为多处理器机器提供了防止并发访问所需的保护机制。

在单处理机器上，编译的时候不会加入自旋锁，仅会被当作一个设置内核抢占机制是否被启用的开关。如果禁止内核抢占，那么在编译时自旋锁就会被剔除出内核。

内核提供的禁止中断同时请求锁的接口

（1）_spin_lock_irqsave（）

保存中断的当前状态，并禁止本地中断，然后再去获取指定的锁。

unsigned long __lockfunc _spin_lock_irqsave(spinlock_t *lock)
{
	unsigned long flags;

	local_irq_save(flags);
	preempt_disable();
	_raw_spin_lock_flags(lock, flags);
	return flags;
}

（2）_spin_unlock_irqrestore（）

对指定的锁解锁，然后让中断恢复到加锁前的状态

void __lockfunc _write_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
{
	_raw_write_unlock(lock);
	local_irq_restore(flags);
	preempt_enable();
}

如果能确定中断在加锁前是激活的，那就不需要在解锁后恢复中断以前的状态。也就可以无条件地在解锁时激活中断。这时可以使用spin_lock_irq（）和spin_unlock_irq（）。

_spin_lock_irq（）

禁止本地中断并获取指定的锁。

void __lockfunc _read_lock_irq(rwlock_t *lock)
{
	local_irq_disable();
	preempt_disable();
	_raw_read_lock(lock);
}

_spin_unlock_irq（）

释放指定的锁，并激活本地中断。

void __lockfunc _spin_unlock_irq(spinlock_t *lock)
{
	_raw_spin_unlock(lock);
	local_irq_enable();
	preempt_enable();
}

在使用spin_lock_irq（）方法时，需要确定中断原来是否处于激活状态。一般不建议使用。

spin_lock_init（）

动态初始化指定的spinlock_t，（此时只有一个指向spinlock_t类型地指针，没有它的实体）

#define spin_lock_init(lock)	do { (void)(lock); } while(0)

spin_try_lock（）

试图获的某个特定的自旋锁。如果该锁已经被争用，那么该函数立即返回一个非0值，而不会自旋等待锁被释放;

如果成功地获得了这个自旋锁，该函数返回0。

int __lockfunc _spin_trylock(spinlock_t *lock)
{
	preempt_disable();	//使抢占计数加1
	if (_raw_spin_trylock(lock))
		return 1;
	
	preempt_enable();	// 使抢占计数减1，并在thread_info描述符的TIF_NEED_RESCHED标志被置为1的情况下，调用preempt_schedule()
	return 0;
}

spin_is_locked（）

用于检查特定的锁当前是否已被占用，如果已被占用，返回非0值;否则返回0。

#define spin_is_locked(x) \
	({ \
	 	CHECK_LOCK(x); \
		if ((x)->lock&&(x)->babble) { \
			(x)->babble--; \
			printk("%s:%d: spin_is_locked(%s:%p) already locked by %s/%d\n", \
					__FILE__,__LINE__, (x)->module, \
					(x), (x)->owner, (x)->oline); \
		} \
		0; \
	})

-------------------------------------------------- ----------------