1
// 共享变量
2
int counter = 0;
3

4
// 任务A和任务B都执行这段代码
5
void increment(void) {
6
    counter++;  // 这不是原子操作！
7
}

1
typedef struct
2
{
3
    volatile uint32_t lock;           // 0: 未锁定, 1: 锁定
4
    volatile uint32_t interrupt_mask; // 保存中断状态（用于中断安全版本）
5
} spinlock_t;
6

7
#define LOCKED_YES 1
8
#define LOCKED_NO 0

1
/**
2
 * spinlock_lock - 纯线程间抢锁（不能在 ISR 里使用）
3
 * @splock: 锁对象
4
 *
5
 * 使用原子交换操作实现忙等待锁获取
6
 */
7
void spinlock_lock(spinlock_t *splock)
8
{
9
  /* 如果锁已被占用，会一直空转直到持有者释放 */
10
  while (atomic_exchange(&splock->lock, LOCKED_YES) != LOCKED_NO)
11
  {
12
    /* 单核空转时不需要 pause，因为不会有第二个核释放锁 */
13
  }
14
}
15

16
/**
17
 * spinlock_unlock - 释放锁（纯线程版本）
18
 * @splock: 锁对象
19
 *
20
 * 对齐的 32 位写入在 x86 上是原子的，可以直接赋值释放
21
 */
22
void spinlock_unlock(spinlock_t *splock)
23
{
24
  splock->lock = LOCKED_NO;
25
}

1
/**
2
 * spinlock_lock_irqsave - 带"关中断"功能的抢锁
3
 * @splock: 锁对象
4
 *
5
 * 执行步骤：
6
 * 1. 保存当前 EFLAGS 的 IF 位
7
 * 2. 执行 cli 关闭本地中断
8
 * 3. 用原子交换抢锁
9
 * 4. 解锁时根据 interrupt_mask 决定是否重新 sti
10
 */
11
void spinlock_lock_irqsave(spinlock_t *splock)
12
{
13
  uint32_t eflags = get_eflags();               /* 读取进入前的完整标志寄存器 */
14
  disable_interrupts();                         /* cli：本地 CPU 不再响应 IRQ */
15
  splock->interrupt_mask = (eflags & (1 << 9)); /* 只保留 IF 位 */
16

17
  /* 下面与 spinlock_lock 完全相同 */
18
  while (atomic_exchange(&splock->lock, LOCKED_YES) != LOCKED_NO)
19
  {
20
  }
21
}
22

23
/**
24
 * spinlock_unlock_irqrestore - 释放锁并恢复中断状态
25
 * @splock: 锁对象
26
 *
27
 * 恢复顺序：先放锁 → 再恢复中断，防止在临界区里被中断插进来
28
 */
29
void spinlock_unlock_irqrestore(spinlock_t *splock)
30
{
31
  splock->lock = LOCKED_NO; /* 放锁 */
32
  if (splock->interrupt_mask)
33
  {                      /* 如果进锁前 IF==1，才重新开中断 */
34
    enable_interrupts(); /* sti */
35
  }
36
}

1
typedef struct mutex
2
{
3
    volatile uint32_t hold;                 // 0: 未锁定, 1: 锁定
4
    volatile struct linked_list_node *thread_node; // 持有者（未来可用于调试）
5
    linked_list_t waiting_task_queue;       // 等待队列
6
    yieldlock_t ydlock;                     // 保护内部状态的锁
7
} mutex_t;

1
/**
2
 * mutex_lock - 获取互斥锁
3
 * @mp: 互斥锁对象
4
 *
5
 * 如果锁被占用，将当前任务加入等待队列并阻塞
6
 */
7
void mutex_lock(mutex_t *mp)
8
{
9
    while (1) {
10
        yieldlock_lock(&mp->ydlock);
11

12
        if (atomic_exchange(&mp->hold, LOCKED_YES) == LOCKED_NO) {
13
            /* 成功获取锁 */
14
            yieldlock_unlock(&mp->ydlock);
15
            return;
16
        }
17

18
        /* 获取失败：将当前任务加入等待队列并阻塞 */
19
        task_t *self = current_task();
20
        linked_list_node_t *node = (linked_list_node_t *)kmalloc(sizeof(linked_list_node_t));
21
        if (node != NULL) {
22
            node->ptr = (type_t)self;
23
            node->prev = NULL;
24
            node->next = NULL;
25
            linked_list_append(&mp->waiting_task_queue, node);
26
        }
27

28
        yieldlock_unlock(&mp->ydlock);
29

30
        /* 阻塞当前任务，schedule() 会切换到其他任务 */
31
        task_block(self);
32

33
        /* 被唤醒后重新尝试获取锁 */
34
    }
35
}
36

37
/**
38
 * mutex_unlock - 释放互斥锁
39
 * @mp: 互斥锁对象
40
 *
41
 * 如果有等待者，唤醒队列中的第一个
42
 */
43
void mutex_unlock(mutex_t *mp)
44
{
45
    yieldlock_lock(&mp->ydlock);
46

47
    mp->hold = LOCKED_NO;
48
    mp->thread_node = NULL;
49

50
    /* 如果有等待者，唤醒第一个 */
51
    if (mp->waiting_task_queue.size != 0) {
52
        linked_list_node_t *head = mp->waiting_task_queue.head;
53
        task_t *waiter = (task_t *)head->ptr;
54
        linked_list_remove(&mp->waiting_task_queue, head);
55
        kfree(head);
56

57
        yieldlock_unlock(&mp->ydlock);
58

59
        task_unblock(waiter);
60
    } else {
61
        yieldlock_unlock(&mp->ydlock);
62
    }
63
}

1
typedef struct semaphore {
2
    volatile int count;            // 可用资源数量
3
    linked_list_t wait_queue;      // 等待队列
4
    spinlock_t lock;              // 保护内部状态
5
} semaphore_t;

1
/**
2
 * sem_init - 初始化信号量
3
 * @sem: 信号量对象
4
 * @initial_count: 初始资源数量
5
 */
6
void sem_init(semaphore_t *sem, int initial_count)
7
{
8
    sem->count = initial_count;
9
    linked_list_init(&sem->wait_queue);
10
    spinlock_init(&sem->lock);
11
}
12

13
/**
14
 * sem_wait - P 操作：等待/获取资源
15
 * @sem: 信号量对象
16
 *
17
 * 如果有资源可用，递减计数；否则阻塞当前任务
18
 */
19
void sem_wait(semaphore_t *sem)
20
{
21
    spinlock_lock(&sem->lock);
22

23
    if (sem->count > 0) {
24
        /* 有资源可用，直接获取 */
25
        sem->count--;
26
        spinlock_unlock(&sem->lock);
27
        return;
28
    }
29

30
    /* count == 0：将当前任务加入等待队列并阻塞 */
31
    task_t *self = current_task();
32
    linked_list_node_t *node = (linked_list_node_t *)kmalloc(sizeof(linked_list_node_t));
33
    if (node != NULL) {
34
        node->ptr = (type_t)self;
35
        node->prev = NULL;
36
        node->next = NULL;
37
        linked_list_append(&sem->wait_queue, node);
38
    }
39

40
    spinlock_unlock(&sem->lock);
41
    task_block(self);
42
}
43

44
/**
45
 * sem_signal - V 操作：释放/增加资源
46
 * @sem: 信号量对象
47
 *
48
 * 如果有等待者，唤醒一个；否则递增计数
49
 */
50
void sem_signal(semaphore_t *sem)
51
{
52
    spinlock_lock(&sem->lock);
53

54
    if (sem->wait_queue.size > 0) {
55
        /* 有等待者，唤醒第一个 */
56
        linked_list_node_t *head = sem->wait_queue.head;
57
        task_t *waiter = (task_t *)head->ptr;
58
        linked_list_remove(&sem->wait_queue, head);
59
        kfree(head);
60

61
        spinlock_unlock(&sem->lock);
62
        task_unblock(waiter);
63
    } else {
64
        /* 没有等待者，增加资源计数 */
65
        sem->count++;
66
        spinlock_unlock(&sem->lock);
67
    }
68
}

1
#define BUFFER_SIZE 4
2
static int buffer[BUFFER_SIZE];
3
static int buf_in = 0, buf_out = 0;
4
static semaphore_t sem_empty;  // 空槽位数量
5
static semaphore_t sem_full;   // 已填充槽位数量
6
static spinlock_t buf_lock;    // 保护缓冲区
7

8
// 初始化
9
sem_init(&sem_empty, BUFFER_SIZE);  // 初始有 BUFFER_SIZE 个空槽位
10
sem_init(&sem_full, 0);             // 初始没有已填充的槽位
11
spinlock_init(&buf_lock);
12

13
void producer(void *arg) {
14
    int id = (int)(uint32_t)arg;
15
    for (int i = 0; i < 8; i++) {
16
        int item = id * 100 + i;
17
        sem_wait(&sem_empty);   // 等待空槽位
18
        spinlock_lock(&buf_lock);
19
        buffer[buf_in] = item;
20
        buf_in = (buf_in + 1) % BUFFER_SIZE;
21
        spinlock_unlock(&buf_lock);
22
        sem_signal(&sem_full);  // 增加已填充槽位
23
        schedule_yield();
24
    }
25
    task_exit(0);
26
}
27

28
void consumer(void *arg) {
29
    for (int i = 0; i < 16; i++) {
30
        sem_wait(&sem_full);    // 等待数据
31
        spinlock_lock(&buf_lock);
32
        int item = buffer[buf_out];
33
        buf_out = (buf_out + 1) % BUFFER_SIZE;
34
        spinlock_unlock(&buf_lock);
35
        sem_signal(&sem_empty);  // 增加空槽位
36
        schedule_yield();
37
    }
38
    task_exit(0);
39
}