1
typedef enum {
2
    TASK_RUNNING,    /* 运行中 */
3
    TASK_RUNNABLE,   /* 可运行/调度 */
4
    TASK_BLOCKED,    /* 阻塞中 */
5
    TASK_SLEEPING,   /* 睡眠中 */
6
    TASK_ZOMBIE,     /* 僵尸态（已完成，但仍占用资源） */
7
} task_state_t;

1
typedef struct task {
2
    /* identity */
3
    tid_t tid;                  /* 任务ID */
4
    pid_t tgid;                 /* 线程组ID（pid） */
5
    char name[16];              /* 任务名称 */
6

7
    struct process *owner;      /* 所属进程（可为NULL表示内核线程） */
8

9
    /* scheduling */
10
    task_state_t state;         /* 任务状态 */
11
    int priority;               /* 优先级 */
12
    int timeslice;              /* 时间片 */
13

14
    /* kernel stack */
15
    void *kstack_base;          /* 内核栈基址 */
16
    void *kstack_top;           /* 内核栈顶 */
17
    uint32_t kernel_esp;        /* 当前内核栈指针 */
18

19
    /* saved context for context_switch */
20
    cpu_context_t ctx;          /* CPU上下文 */
21

22
    /* runqueue node */
23
    struct list_node rq_node;   /* 运行队列链表节点 */
24

25
    /* bookkeeping */
26
    int exit_code;              /* 退出码 */
27
    int refcount;               /* 引用计数 */
28
} task_t;

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
}

1
cd 10.kernel-sched
2
make clean
3
make all
4
make run

1
=== Chapter 10: Kernel Scheduler ===
2

3
Initializing hardware...
4
  GDT...OK
5
  IDT...OK
6
  Interrupts...OK
7
  Timer (50 Hz)...OK
8
  Boot info...OK
9
  Physical memory...OK
10
  Virtual memory...OK
11
  Kernel heap...OK
12

13
--- Scheduler Test ---
14

15
Initializing task subsystem...
16
[Scheduler] Initialized (idle tid=1)
17

18
Creating test threads...
19
Threads created:
20
  test1: tid=2, priority=5
21
  test2: tid=3, priority=5
22
  test3: tid=4, priority=3
23

24
--- Starting Scheduler ---
25
Tasks will yield CPU voluntarily in this test.
26
In a real system, timer interrupts would trigger scheduling.
27

28
[Task 1] Started
29
[Task 1] Running (iteration 0)
30
[Task 1] Yielding CPU...
31
[Task 2] Started
32
[Task 2] Running (iteration 0)
33
[Task 2] Yielding CPU...
34
[Task 1] Resumed
35
[Task 1] Running (iteration 1)
36
[Task 1] Yielding CPU...
37
[Task 2] Resumed
38
[Task 2] Running (iteration 1)
39
[Task 2] Yielding CPU...
40
...