《Linux 内核分析》完成一个简单的时间片轮转多道程序内核代码

// 代码中文件 mypcb.h 中
#define MAX_TASK_NUM 4
#define KERNEL_STACK_SIZE 4*1024

// 定义一个进程中主线程执行时，CPU 中 eip 和 esp 寄存器中的值
struct Thread
{
    unsigned long ip;
    unsigned long sp;
};


// 进程控制块定义
typedef struct PCB
{
    int pid;   // 进程号
    volatile long state;   // 表示当前进程的状态， -1: 不可运行，0: 运行中，>0: 停止
    char stack[KERNEL_STACK_SIZE];  // 内核堆栈空间
    // 进程执行时的 CPU 中关键寄存器的状态
    struct Thread thread;
    // 进程中主程序的入口地址
    unsigned long task_entry;
    struct PCB *next;   // 指向下一个进程控制块
} tPCB;

// 代码在文件 myinterrupt.c 文件中
extern volatile int my_need_sched;
volatile int time_count = 0;

/*
 * Called by timer interrupt.
 */
void my_timer_handler(void)
{
    if (time_count % 1000 == 0 && my_need_sched != 1) // 每个 1000 次时间中断并且没有进行调度，则执行一次打印输出
    {
        printk(KERN_NOTICE ">>>my_timer_handler here<<<\n");
        my_need_sched = 1; //进行调度
    }
    time_count++;
}

// 代码位于 mymain.c 文件中
tPCB task[MAX_TASK_NUM];   // 创建包含所有进程的进程数组
tPCB *my_current_task = NULL; // my_current_task 指针指向当前正在运行的进程的进程控制块
volatile int my_need_sched = 0; // 是否需要进行调度的标志

void my_process(void);

// 这个 my_start_kernel 是经过打过补丁之后，新的内核的开始执行的入口函数
void __init my_start_kernel(void)
{
    int pid = 0;
    int i;

    // 初始化 0 号进程
    task[pid].pid = 0;
    task[pid].state = 0;  // 0 表示当前进程正在执行
    task[pid].task_entry = task[pid].thread.ip = (unsigned long)my_process; // 将第 0 号进程的主函数入口地址设置为 my_process
    // my_process 是定义在本文件中的一个函数
    task[pid].thread.sp = (unsigned long) & (task[pid].stack[KERNEL_STACK_SIZE - 1]); // 将进程中的栈指针 sp 指向进程所使用栈的栈顶
    task[pid].next = &task[pid];  // 在还没有初始化更多进程之前，它所指向的下一个进程块还是它自己

    // fork 出更多的进程
    for (i = 1; i < MAX_TASK_NUM; i++)
    {
        // 首先使用 0 号进程对应的进程块中的内容来初始化其他新创建的进程
        memcpy(&task[i], &task[0], sizeof(tPCB));
        task[i].pid = i;
        task[i].state = -1;
        task[i].thread.sp = (unsigned long) & (task[i].stack[KERNEL_STACK_SIZE - 1]);
        task[i].next = task[i - 1].next;
        task[i - 1].next = &task[i];
    }
......

}

task[pid].task_entry = task[pid].thread.ip = (unsigned long)my_process

task[pid].next = &task[pid];

    // 代码位于 mymain.c 文件中
    // 准备启动第 0 号进程
    pid = 0;
    my_current_task = &task[0];
    asm volatile (
        "movl %1,%%ebp\n\t" // 应该将 "pushl %1\n\t" 替换成这句话，并放在现在这个位置
        "movl %1,%%esp\n\t"  // 将 task[pid].thread.sp 的值存放到 esp 寄存器中
        // "pushl %1\n\t"  // 这句话得删除了，添加第一句汇编代码
        "pushl %0\n\t"  // 将进程 0 主函数入口地址压入堆栈
        "ret\n\t"  // 弹出进程 0 的 ip 值到 eip 寄存器中
        "popl %%ebp\n\t" //将进程 0 对应的栈的栈底弹出到 ebp 寄存器中
        :  // 没有输出
        :  "c"(task[pid].thread.ip), "d"(task[pid].thread.sp)
    );

// 自定义进程所对应的主函数，类似于我们 C 语言中的 main 函数
void my_process(void)
{
    int i = 0;
    while (1)
    {
        i++;
        if (i % 10000000 == 0) // 每执行 10000000 次来进行一次主动的进程调度
        {
            printk(KERN_NOTICE "this is process %d -\n", my_current_task->pid);
            // 如果需要进行调度
            if (my_need_sched == 1)
            {
                my_need_sched = 0;
                my_schedule();
            }
            printk(KERN_NOTICE "this is process %d +\n", my_current_task->pid);
        }
    }
    return;
}

// 代码实现在 myinterrupt.c 文件中
void my_schedule(void)
{
    tPCB *next; // 下一个需要调度的进程
    tPCB *prev; // 调度前执行的进程

    if (my_current_task == NULL || my_current_task->next == NULL)
    {
        return ;
    }

    printk(KERN_NOTICE ">>> my_schedule <<<\n");
    next = my_current_task->next;
    prev = my_current_task;

    if (next->state == 0)
    {
        my_current_task = next;
        printk(KERN_NOTICE ">>>switch %d to %d<<<\n", prev->pid, next->pid);
        /* switch to next process */
        asm volatile (
            "pushl %%ebp\n\t"  // 保存 prev 进程的栈底指针地址，并将其压入到 prev 栈中
            "movl %%esp, %0\n\t"   // 将 prev 进程中 栈顶指针 esp 保存到 prev 进程控制块中 thread.sp 数据成员中
            "movl %2, %%esp\n\t"   // 将 next 指向进程中的栈底指针保存到 esp 中
            "movl $1f,%1\n\t"      // 将 prev 指向进程下一条要执行的指令保存到进程控制块中
            "pushl %3\n\t"         // 将 next 指向进程的下一条指令入栈
            "ret\n\t"              // 将 next 进程需要执行的下一条指令弹出到 eip 寄存器中
            "1: \t"
            "popl %%ebp\n\t" // 弹出 next 进程栈订顶的值到 ebp 寄存器中
            : "=m"(prev->thread.sp), "=m"(prev->thread.ip)
            : "m"(next->thread.sp), "m"(next->thread.ip)
        );
    }
    else {
        next->state = 0;
        my_current_task = next;
        printk(KERN_NOTICE ">>>switch %d to %d<<<\n", prev->pid, next->pid);
        /* switch to new process */
        asm volatile (
            "pushl %%ebp\n\t" // 将 prev 进程中栈的栈底指针保存到 prev 栈中
            "movl %%esp,%0\n\t" // 将 prev 进程中 栈顶指针 esp 保存到 prev 进程控制块中 thread.sp 数据成员中
            "movl %2,%%ebp\n\t" // 将 next 进程的栈底地址送到 ebp 寄存器中
            "movl %2,%%esp\n\t" // 将 next 进程的栈顶地址送到 esp 寄存器中
            "movl $1f,%1\n\t"   // 保存 prev 指向进程下一次执行时的指令地址，也就是标号为 1 处的地址
            "pushl %3\n\t" // 将 next 进程的入口地址压入到栈中
            "ret\n\t" // 将 next 进程的下一条执行的指令弹出，然后从刚弹出的指令地址开始执行
            : "=m"(prev->thread.sp), "=m"(prev->thread.ip)
            : "m"(next->thread.sp), "m"(next->thread.ip)
        );
    }
    return;
}