linux 信号量（semaphore）

1 概述

在Linux中，信号量是一种用于实现进程间同步和互斥的机制。信号量通常用于控制对共享资源的访问，以确保多个进程之间不会同时访问关键资源，从而避免竞态条件和数据损坏。

1.1 Linux中信号量的主要类型包括

• 二进制信号量（Binary Semaphore）：也称为互斥锁（Mutex），只有两个状态，通常用于实现互斥访问共享资源。
• 计数信号量（Counting Semaphore）：可以具有多个不同的整数值，通常用于控制对一组资源的访问。

2 用户空间信号量使用

• sem_init：初始化信号量，设置其初始值。
• sem_wait：等待信号量，如果信号量的值大于零，则将其减一，否则阻塞进程直到信号量变为非零。
• sem_post：增加信号量的值，如果有等待的进程，其中一个将被唤醒。
• sem_destroy：销毁信号量，释放相关资源。

2.1 代码实例

#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>

// 全局变量和信号量
int count = 0;
sem_t sem;

// 增加计数的线程函数
void *increment(void *arg) {
    int i;
    for (i = 0; i < 5; i++) {
        sem_wait(&sem); // 等待信号量
        count++;
        printf("Increment: %d\n", count);
        sem_post(&sem); // 释放信号量
    }
    return NULL;
}

// 减少计数的线程函数
void *decrement(void *arg) {
    int i;
    for (i = 0; i < 5; i++) {
        sem_wait(&sem); // 等待信号量
        count--;
        printf("Decrement: %d\n", count);
        sem_post(&sem); // 释放信号量
    }
    return NULL;
}

int main() {
    pthread_t thread1, thread2;

    // 初始化信号量
    sem_init(&sem, 0, 1);

    // 创建线程
    pthread_create(&thread1, NULL, increment, NULL);
    pthread_create(&thread2, NULL, decrement, NULL);

    // 等待线程结束
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    // 销毁信号量
    sem_destroy(&sem);

    return 0;
}

3 内核空间信号量使用

• sema_init：用于初始化信号量。
• down_interruptible/down：用于等待信号量，如果线程被中断，它会返回错误码。
• up：用于释放信号量。

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/kthread.h>
#include <linux/semaphore.h>

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("Kernel Module with Semaphore");

static struct semaphore my_semaphore;
static int shared_data = 0;

static struct task_struct *thread1, *thread2;

// 第一个内核线程的函数
int thread_function1(void *data) {
    while (!kthread_should_stop()) {
        // 等待信号量
        if (down_interruptible(&my_semaphore))
            return -ERESTARTSYS; // 如果线程被中断，则返回错误码
        shared_data++;
        pr_info("Thread 1: Incremented shared_data to %d\n", shared_data);
        // 释放信号量
        up(&my_semaphore);
        msleep(1000); // 暂停1秒
    }
    return 0;
}

// 第二个内核线程的函数
int thread_function2(void *data) {
    while (!kthread_should_stop()) {
        // 等待信号量
        if (down_interruptible(&my_semaphore))
            return -ERESTARTSYS; // 如果线程被中断，则返回错误码
        shared_data--;
        pr_info("Thread 2: Decremented shared_data to %d\n", shared_data);
        // 释放信号量
        up(&my_semaphore);
        msleep(1000); // 暂停1秒
    }
    return 0;
}

static int __init semaphore_init(void) {
    sema_init(&my_semaphore, 1); // 初始化信号量为1

    // 创建两个内核线程
    thread1 = kthread_run(thread_function1, NULL, "thread1");
    thread2 = kthread_run(thread_function2, NULL, "thread2");

    if (IS_ERR(thread1) || IS_ERR(thread2)) {
        pr_err("Thread creation failed\n");
        return -ENOMEM;
    }

    pr_info("Semaphore example module loaded\n");
    return 0;
}

static void __exit semaphore_exit(void) {
    kthread_stop(thread1);
    kthread_stop(thread2);

    pr_info("Semaphore example module unloaded\n");
}

module_init(semaphore_init);
module_exit(semaphore_exit);

3.1 down/down_interruptible区别

1. 中断处理方式：
   down_interruptible：允许线程在等待过程中被信号中断。如果线程被信号中断，函数会返回一个特定的错误码（通常是-EINTR），以指示中断发生。
   down：不允许线程在等待过程中被信号中断，如果线程被信号中断，它将一直等待直到信号量可用，不返回错误码。
2. 安全性和可靠性：
   down_interruptible：更安全，因为它允许线程在等待期间响应信号。这对于某些情况下需要及时响应的线程来说很有用，但需要更复杂的错误处理代码，以处理中断情况。
   down：更可靠，因为它会一直等待信号量，不允许线程在等待期间被中断。这可以确保线程不会被中断，但可能导致线程在某些情况下永远等待。

通常情况下，如果你的内核模块需要等待信号量并希望能够响应信号中断，那么可以使用down_interruptible。如果你需要确保线程不会被信号中断，并且可以信赖信号量会变为可用，那么可以使用down。

3.2 down_interruptible如何被中断

• 用户发送信号：用户可以使用命令如kill或killall来向进程发送信号。如果一个线程正在等待信号量，并且接收到了由用户发送的信号（如SIGINT或SIGTERM），那么线程就会被中断以响应信号。
• 内核事件：内核中的某些事件或条件可能导致线程被中断。例如，一个线程可能会等待某个资源，但当内核决定放弃等待时，它会中断线程以执行其他任务。
• 超时：在某些情况下，线程可能会使用带有超时参数的down_interruptible函数等待信号量。如果超过指定的时间限制，线程将被中断，以便执行其他任务或进行错误处理。
• 资源不可用：线程可能等待一个资源，但如果该资源永远不可用，或者等待条件不再成立，线程可能会被中断，以避免永久阻塞。