1
void scheduler_init(void)
2
{
3
    runqueue_t *rq = get_global_runqueue();
4
    runqueue_init(rq);  /* 初始化运行队列 */
5

6
    /* 创建 idle 任务，最低优先级，不加入运行队列 */
7
    idle_task = task_create_kernel("idle", idle_thread, NULL, 0);
8
    if (idle_task == NULL) {
9
        vga_printf("[Scheduler] PANIC: failed to create idle task\n");
10
        while (1);
11
    }
12
    /* idle 不在运行队列中，仅在队列为空时使用 */
13
    idle_task->state = TASK_RUNNING;
14

15
    current_running_task = NULL;
16
    need_reschedule = 0;
17

18
    vga_printf("[Scheduler] Initialized (idle tid=%u)\n", idle_task->tid);
19
}

1
void schedule(void)
2
{
3
    task_t *prev = current_running_task;
4
    task_t *next = NULL;
5
    runqueue_t *rq = get_global_runqueue();
6

7
    /* 将当前可运行任务重新加入队列（idle 不加入） */
8
    if (prev != NULL && prev->state == TASK_RUNNABLE && prev != idle_task) {
9
        runqueue_add(rq, prev);
10
    }
11

12
    next = runqueue_pop(rq);  /* 从队列头部取出下一个任务 */
13

14
    if (next == NULL) {
15
        next = idle_task;  /* 队列为空，使用 idle 任务 */
16
    }
17

18
    if (prev == next) {
19
        need_reschedule = 0;
20
        return;  /* 没有任务切换，直接返回 */
21
    }
22

23
    current_running_task = next;
24
    next->state = TASK_RUNNING;
25
    need_reschedule = 0;
26

27
    if (prev == NULL) {
28
        /* 首次调度：直接跳转到 next 的入口 */
29
        __asm__ volatile (
30
            "movl %0, %%esp\n\t"
31
            "jmp resume_thread"
32
            :
33
            : "r" (next->kernel_esp)
34
            : "memory"
35
        );
36
    } else {
37
        /* 执行上下文切换 */
38
        context_switch(&prev->ctx, &next->ctx);
39
    }
40
}

1
void runqueue_add(runqueue_t *rq, task_t *task)
2
{
3
    struct list_node *new_node = &task->rq_node;
4

5
    if (rq->count == 0) {
6
        /* 队列为空，直接添加 */
7
        rq->head.next = new_node;
8
        new_node->prev = &rq->head;
9
        new_node->next = NULL;
10
    } else {
11
        /* 找到尾节点 */
12
        struct list_node *tail = rq->head.next;
13
        while (tail->next != NULL) {
14
            tail = tail->next;
15
        }
16
        /* 将新节点添加到尾部 */
17
        tail->next = new_node;
18
        new_node->prev = tail;
19
        new_node->next = NULL;
20
    }
21

22
    rq->count++;
23
}
24

25
task_t *runqueue_pop(runqueue_t *rq)
26
{
27
    if (rq->count == 0) {
28
        return NULL;
29
    }
30

31
    struct list_node *first = rq->head.next;
32
    if (first == NULL) {
33
        return NULL;
34
    }
35

36
    /* 从队列头部移除 */
37
    rq->head.next = first->next;
38
    if (first->next != NULL) {
39
        first->next->prev = &rq->head;
40
    }
41

42
    first->prev = NULL;
43
    first->next = NULL;
44

45
    rq->count--;
46

47
    /* 使用container_of获取task_t */
48
    return task_from_rq_node(first);
49
}

1
void schedule_yield(void)
2
{
3
    task_t *current = current_task();
4
    if (current != NULL && current->state == TASK_RUNNING) {
5
        current->state = TASK_RUNNABLE;
6
    }
7
    schedule();
8
}