linux驱动开发-自旋锁

• 自旋锁
• 自旋锁的特点
• 工作原理
• 适用场景
• 优点
• 缺点
• API
• 实现注意事项
• 调试和分析
• 最佳实践
• 自旋锁在中断上下文中的使用
  • 使用自旋锁的最佳做法

自旋锁

自旋锁是一种轻量级的锁机制，用于保护共享资源，它是多线程或多核环境中实现并发访问控制的一种方式。
自旋锁通过忙等待的方式来获取锁，不会使线程进入睡眠状态。

自旋锁的特点

自旋锁针对多核有效

自旋锁获取不到资源的时候会处于自旋锁状态

自旋锁会产生死锁

自旋锁保护的临界区要尽可能的小，在自旋锁保护的临界区中

不能够有延时，耗时，甚至休眠的操作。在自旋锁保护的临界区

中不能够使用copy_to_user/copy_from_user等函数。

自旋锁可以在中断上下文使用

自旋锁在上锁前会关闭抢占

工作原理

自旋锁的基本原理是：当一个线程尝试获取自旋锁时，如果锁已经被其他线程持有，

该线程不会进入休眠，而是会不断循环检查锁的状态。

这种方式称为“自旋”，因为线程在循环中持续占用CPU，直到锁可用为止。

适用场景

自旋锁适用于以下场景：

短暂的临界区：自旋锁适合被持有时间非常短的临界区，因为长时间占用锁会导致等待的线程占用CPU资源，降低系统性能。

多核处理器：在多核处理器中，一个核可以在短时间内等待另一个核释放锁。自旋锁避免了上下文切换的开销，提升效率。

无频繁上下文切换的情境：在某些情况下，线程间的上下文切换本身可能会造成性能损失，而自旋锁可以减少这些切换的需要。

优点

开销小：自旋锁相比较于互斥锁，在获取锁时不需要进行上下文切换，因此开销相对较小。

适用于忙等待：可以高效利用CPU资源，适合短时间持有锁的场景。

缺点

占用CPU：自旋锁会导致等待线程占用CPU，因此在锁被持有较长时间时会浪费CPU资源。

不适合单线程环境：在单核或低并发的环境中，自旋锁通常不如互斥锁高效，因为线程会一直自旋而无法有效利用CPU。

优先级反转问题：在某些情况下，低优先级线程持有自旋锁时，高优先级线程等待获取同样的锁，可能导致高优先级线程的饥饿现象。

API

在Linux内核中，自旋锁的相关API主要包括：

1. 初始化自旋锁

DEFINE_SPINLOCK(lock);
DEFINE_SPINLOCK 宏用于静态初始化一个自旋锁。


spinlock_t lock;
spin_lock_init(&lock);
spin_lock_init 函数用于动态初始化一个自旋锁。

2. 获取自旋锁

spin_lock(&lock);
spin_lock 函数用于获取自旋锁。如果锁已经被其他线程持有，当前线程会一直自旋，直到锁被释放。

3. 释放自旋锁

spin_unlock(&lock);
spin_unlock 函数用于释放自旋锁。

4. 获取自旋锁并禁用中断

spin_lock_irqsave(&lock, flags);
spin_lock_irqsave 函数用于获取自旋锁，并在获取锁之前保存当前的中断状态，然后禁用中断。flags 用于保存中断状态。

5. 释放自旋锁并恢复中断

spin_unlock_irqrestore(&lock, flags);
spin_unlock_irqrestore 函数用于释放自旋锁，并在释放锁之后恢复之前保存的中断状态。

6. 获取自旋锁并禁用本地CPU的中断

spin_lock_irq(&lock);
spin_lock_irq 函数用于获取自旋锁，并在获取锁之前禁用本地CPU的中断。

7. 释放自旋锁并启用本地CPU的中断

spin_unlock_irq(&lock);
spin_unlock_irq 函数用于释放自旋锁，并在释放锁之后启用本地CPU的中断。

8. 获取自旋锁并禁用软中断

spin_lock_bh(&lock);
spin_lock_bh 函数用于获取自旋锁，并在获取锁之前禁用软中断。

9. 释放自旋锁并启用软中断

spin_unlock_bh(&lock);
spin_unlock_bh 函数用于释放自旋锁，并在释放锁之后启用软中断。

10. 尝试获取自旋锁

spin_trylock(&lock);
spin_trylock 函数用于尝试获取自旋锁。如果锁已经被其他线程持有，该函数会立即返回 false，否则返回 true。

11. 尝试获取自旋锁并禁用中断

spin_trylock_irqsave(&lock, flags);
spin_trylock_irqsave 函数用于尝试获取自旋锁，并在尝试获取锁之前保存当前的中断状态，然后禁用中断。flags 用于保存中断状态。如果锁已经被其他线程持有，该函数会立即返回 false，否则返回 true。

12. 尝试获取自旋锁并禁用本地CPU的中断

spin_trylock_irq(&lock);
spin_trylock_irq 函数用于尝试获取自旋锁，并在尝试获取锁之前禁用本地CPU的中断。如果锁已经被其他线程持有，该函数会立即返回 false，否则返回 true。

13. 尝试获取自旋锁并禁用软中断

spin_trylock_bh(&lock);
spin_trylock_bh 函数用于尝试获取自旋锁，并在尝试获取锁之前禁用软中断。如果锁已经被其他线程持有，该函数会立即返回 false，否则返回 true。

#include <linux/module.h>
#include <linux/init.h>
#include <linux/spinlock.h>
#include <linux/slab.h>

// 定义自旋锁
DEFINE_SPINLOCK(my_lock);

// 共享资源
int shared_resource = 0;

// 线程函数
void my_thread_func(void *data) {
    int i;

    for (i = 0; i < 1000000; i++) {
        // 获取自旋锁
        spin_lock(&my_lock);

        // 访问共享资源
        shared_resource++;

        // 释放自旋锁
        spin_unlock(&my_lock);
    }
}

// 模块初始化函数
static int __init my_spinlock_init(void) {
    struct task_struct *thread1, *thread2;

    // 创建两个内核线程
    thread1 = kthread_run(my_thread_func, NULL, "my_thread1");
    thread2 = kthread_run(my_thread_func, NULL, "my_thread2");

    if (IS_ERR(thread1) || IS_ERR(thread2)) {
        printk(KERN_ERR "my_spinlock: Failed to create kernel threads\n");
        return -1;
    }

    printk(KERN_INFO "my_spinlock: Module initialized\n");
    return 0;
}

// 模块退出函数
static void __exit my_spinlock_exit(void) {
    printk(KERN_INFO "my_spinlock: Module exited\n");
}

module_init(my_spinlock_init);
module_exit(my_spinlock_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("gopher");
MODULE_DESCRIPTION("A simple spinlock example");

实现注意事项

避免过度自旋：

对于可能长时间持有自旋锁的操作，不应使用自旋锁，而应采用互斥锁等其他同步机制。

避免锁嵌套：

如果在持锁状态下再试图获取同一把锁，会导致死锁。设计时应确保自旋锁的获取与释放不应相互嵌套。

优先级反转（Priority Inversion）：

使用自旋锁可能会引入优先级反转问题。这是由于低优先级线程持有锁，导致高优先级线程程序被阻塞，进而影响系统整体响应。

自旋锁与中断上下文：

自旋锁不能在中断上下文中持有，尤其是在长时间运行的操作中。若当前上下文为中断处理程序，推荐使用其他机制（如互斥锁）。

调试和分析

检测自旋锁的竞争：

通过监测自旋锁的竞争情况，可以识别系统在并发访问中出现的性能问题。例如，使用dmesg命令可以查看锁的相关统计信息。

自旋锁的调试信息：

在内核调试中，可以通过printk等机制输出自旋锁的获取和释放的相关信息。这有助于检测潜在的死锁和竞争状态

最佳实践

限制自旋次数：

设置自旋的最大次数后自动放弃锁的获取，避免无限自旋，这样更能合理利用CPU。

使用条件变量：

在某些情况下，可以使用条件变量与自旋锁配合，允许更复杂的同步条件。

选择合适的锁：

在适合的场景下使用互斥锁弹性替代自旋锁。互斥锁会在获取锁时睡眠，而不是持续占用CPU。

代码审查：

在代码审查中关注自旋锁的使用，确保其符合上述原则，如确保不会造成优先级反转和死锁等问题。

自旋锁在中断上下文中的使用

自旋锁的可用性：

自旋锁可以在中断上下文中使用，这是因为自旋锁不会让线程进入睡眠状态。因此，中断处理程序可以通过自旋锁来保护共享资源，以防止在中断处理期间发生数据竞态。

小心持锁时间：

在中断上下文中持有自旋锁的时间必须尽可能短。如果在持有自旋锁时执行需要较长时间的操作，会导致性能下降，甚至导致优先级反转。这是因为在一个高优先级的中断处理程序中持有自旋锁，低优先级线程可能无法获取锁，从而影响系统响应。

避免使用容易阻塞的操作：

在中断上下文中，应避免任何可能导致线程阻塞的操作。这意味着在中断上下文中持有自旋锁时，绝对不应该调用会在用户空间进行 I/O 操作的函数（如 copy_to_user 或 copy_from_user）。

使用自旋锁的最佳做法

使用合适的上下文：

一般情况下，尽量避免在中断处理程序中进行复杂的计算或持有自旋锁过长时间。可以将需要的操作简单化，并在必要时使用消息传递或队列系统来处理复杂任务。

限制临界区：

在中断处理程序中持有自旋锁时，只应执行极少量的代码，确保在获取自旋锁后尽快释放它，以提高系统的并发性能。

使用不同的锁机制：

如果在中断上下文中需要长时间处理共享资源，可以考虑使用其他同步机制，比如使用消息队列和工作队列，这样可避免在中断上下文中持有锁。