从零开始配置的linux系统基于mykernel的一个简单的时间片轮转多道程序模拟

最新推荐文章于 2025-08-05 17:02:05 发布

qq_31209133

最新推荐文章于 2025-08-05 17:02:05 发布

阅读量868

点赞数

CC 4.0 BY-SA版权

文章标签： linux 操作系统

本文链接：https://blog.youkuaiyun.com/qq_31209133/article/details/88404987

本文介绍了从零开始配置Linux系统，并基于mykernel实现一个简单的时间片轮转多道程序模拟的过程。首先，通过虚拟机安装Ubuntu系统，然后安装qemu模拟处理器，接着编译内核并应用补丁。在模拟过程中，通过修改mymain.c和myinterrupt.c文件，实现了进程调度的初始化和改进，包括进程PCB和进程链表的管理。实验展示了如何通过my_timer_handler进行进程切换，模拟时间片轮转调度。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

学号098原创作品，转载请注明出处。

本实验资源来源： https://github.com/mengning/linuxkernel/

一.实验环境

VM14pro虚拟机

ubuntu系统（ubuntu-18.04.2-desktop-amd64）

二.实验准备

1.下载linux内核linux-3.9.4内核压缩文件和其对应的补丁包。

2.在孟宁老师的github上下载三个文件：mymain.c、myinterrupt.c、mypcb.h(注意下载更新的)

3.所有文件放在mykernel文件夹中

三.实验步骤

1.在虚拟机上安装ubuntu系统

建议虚拟机内存大于2GB，这样运行linux系统不至于太卡。

2.安装qemu模拟处理器

打开shell命令行。

输入sudo apt-get install qemu # install QEMU，安装QEMU。

此处输入密码，再按enter建即可。（输入密码时命令行无字符显示，直接输入即可）

一路yes等待安装即可。

输入sudo ln -s /usr/bin/qemu-system-i386 /usr/bin/qemu，建立一条软链接，方便后续对qemu的调用。

3.编译内核

输入cd mykernel，定位到mykernel文件夹

输入ls，查看mykernel文件夹中的内容

输入xz -d linux-3.9.4.tar.xz解压xz文件为tar

输入ls可以看到linux-3.9.4.tar存在。

输入tar -xvf linux-3.9.4.tar解压linux-3.9.4.tar

输入ls可以看到linux-3.9.4文件夹存在。

输入cd linux-3.9.4，定位到linux-3.9.4文件夹

输入patch -p1 < ../mykernel_for_linux3.9.4sc.patch，为该内核带上补丁。

输入make allnoconfig设置所有选项均回答为"no“。

可以看到ubuntu里未自带make命令，依照命令行的提示安装。

输入sudo apt install make.

安装成功。

再次输入make allnoconfig，此时再次出现错误。

信息提示系统未安装gcc。

输入gcc得到提示信息。

输入sudo apt install gcc，安装gcc

一路yes，等待安装即可。

安装成功。

继续输入make allnoconfig。

该错误的解决方法为https://github.com/Gateworks/linux-imx6/commit/7b823e82af87ae951a957d241934fc807a76fe8e

截图为：

找到文件scripts/kconfig/menu.c，将图中的-行代码换成+行的代码。

再次输入make allnoconfig得到下图的结果

输入make进行编译。出现错误

解决方法为：

在linux-3.9.4文件夹中查找compiler-gcc,将下图中的compiler-gcc4.h重命名为compiler-gcc7.h即可

再次运行make

编译中的截图如下：

等待编译即可。

编译完成。

4.使用qemu模拟进程调度

（1）初始调度

查看linux-3.9.4/mykernel里的mymain.c和myinterrupt.c文件

mymain.c

/*
* linux/mykernel/mymain.c
*
* Kernel internal my_start_kernel
*
* Copyright (C) 2013 Mengning
*
*/
#include <linux/types.h>
#include <linux/module.h>
#include <linux/proc_fs.h>
#include <linux/kernel.h>
#include <linux/syscalls.h>
#include <linux/stackprotector.h>
#include <linux/string.h>
#include <linux/ctype.h>
#include <linux/delay.h>
#include <linux/ioport.h>
#include <linux/init.h>
#include <linux/initrd.h>
#include <linux/bootmem.h>
#include <linux/acpi.h>
#include <linux/tty.h>
#include <linux/percpu.h>
#include <linux/kmod.h>
#include <linux/vmalloc.h>
#include <linux/kernel_stat.h>
#include <linux/start_kernel.h>
#include <linux/security.h>
#include <linux/smp.h>
#include <linux/profile.h>
#include <linux/rcupdate.h>
#include <linux/moduleparam.h>
#include <linux/kallsyms.h>
#include <linux/writeback.h>
#include <linux/cpu.h>
#include <linux/cpuset.h>
#include <linux/cgroup.h>
#include <linux/efi.h>
#include <linux/tick.h>
#include <linux/interrupt.h>
#include <linux/taskstats_kern.h>
#include <linux/delayacct.h>
#include <linux/unistd.h>
#include <linux/rmap.h>
#include <linux/mempolicy.h>
#include <linux/key.h>
#include <linux/buffer_head.h>
#include <linux/page_cgroup.h>
#include <linux/debug_locks.h>
#include <linux/debugobjects.h>
#include <linux/lockdep.h>
#include <linux/kmemleak.h>
#include <linux/pid_namespace.h>
#include <linux/device.h>
#include <linux/kthread.h>
#include <linux/sched.h>
#include <linux/signal.h>
#include <linux/idr.h>
#include <linux/kgdb.h>
#include <linux/ftrace.h>
#include <linux/async.h>
#include <linux/kmemcheck.h>
#include <linux/sfi.h>
#include <linux/shmem_fs.h>
#include <linux/slab.h>
#include <linux/perf_event.h>
#include <linux/file.h>
#include <linux/ptrace.h>
#include <linux/blkdev.h>
#include <linux/elevator.h>

#include <asm/io.h>
#include <asm/bugs.h>
#include <asm/setup.h>
#include <asm/sections.h>
#include <asm/cacheflush.h>

#ifdef CONFIG_X86_LOCAL_APIC
#include <asm/smp.h>
#endif

void __init my_start_kernel(void)
{
    int i = 0;
    while(1)
    {
        i++;
        if(i%100000 == 0)
            printk(KERN_NOTICE "my_start_kernel here %d \n",i);

    }
}

myinterrupt.c

/*
* linux/mykernel/myinterrupt.c
*
* Kernel internal my_timer_handler
*
* Copyright (C) 2013 Mengning
*
*/
#include <linux/kernel_stat.h>
#include <linux/export.h>
#include <linux/interrupt.h>
#include <linux/percpu.h>
#include <linux/init.h>
#include <linux/mm.h>
#include <linux/swap.h>
#include <linux/pid_namespace.h>
#include <linux/notifier.h>
#include <linux/thread_info.h>
#include <linux/time.h>
#include <linux/jiffies.h>
#include <linux/posix-timers.h>
#include <linux/cpu.h>
#include <linux/syscalls.h>
#include <linux/delay.h>
#include <linux/tick.h>
#include <linux/kallsyms.h>
#include <linux/irq_work.h>
#include <linux/sched.h>
#include <linux/sched/sysctl.h>
#include <linux/slab.h>

#include <asm/uaccess.h>
#include <asm/unistd.h>
#include <asm/div64.h>
#include <asm/timex.h>
#include <asm/io.h>

#define CREATE_TRACE_POINTS
#include <trace/events/timer.h>

/*
* Called by timer interrupt.
*/
void my_timer_handler(void)
{
printk(KERN_NOTICE "\n>>>>>>>>>>>>>>>>>my_timer_handler here<<<<<<<<<<<<<<<<<<\n\n");
}

可以看到，在mymain.c的my_start_kernel函数中有一个循环，不停的输出 my_start_kernel here。

在myinterrupt.c中，有一个会被时钟中断周期调用的函数my_timer_handler ，输出类似>>>>>my_timer_handler here <<<<< 的字符串。

输入qemu -kernel arch/x86/boot/bzImage在qemu中执行。

从qemu窗口中可以看到my_start_kernel在执行，同时my_timer_handler时钟中断处理程序周期性执行。

（2）改进调度

根据初始调度，我们在mymain.c基础上继续写进程描述PCB和进程链表管理等代码，在myinterrupt.c的基础上完成进程切换代码，一个可运行的小OS kernel就完成了。

将下载的mymain.c、myinterrupt.c覆盖linux-3.9.4/mykernel里的mymain.c和myinterrupt.c。

同时将mypcb.h也复制进去。

删除mymain.o、myinterrupt.o

再次使用

make config

make进行编译

mymain.c

/*
* linux/mykernel/mymain.c
*
* Kernel internal my_start_kernel
*
* Copyright (C) 2013 Mengning
*
*/
#include <linux/types.h>
#include <linux/string.h>
#include <linux/ctype.h>
#include <linux/tty.h>
#include <linux/vmalloc.h>

#include "mypcb.h"

tPCB task[MAX_TASK_NUM];
tPCB * my_current_task = NULL;
volatile int my_need_sched = 0;

void my_process(void);

void __init my_start_kernel(void)
{
    int pid = 0;
    int i;
    /* Initialize process 0*/
    task[pid].pid = pid;
    task[pid].state = 0;/* -1 unrunnable, 0 runnable, >0 stopped */
    task[pid].task_entry = task[pid].thread.ip = (unsigned long)my_process;
    task[pid].thread.sp = (unsigned long)&task[pid].stack[KERNEL_STACK_SIZE-1];
    task[pid].next = &task[pid];
    /*fork more process */
    for(i=1;i<MAX_TASK_NUM;i++)
    {
        memcpy(&task[i],&task[0],sizeof(tPCB));
        task[i].pid = i;
   //*(&task[i].stack[KERNEL_STACK_SIZE-1] - 1) = (unsigned long)&task[i].stack[KERNEL_STACK_SIZE-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];
    }
    /* start process 0 by task[0] */
    pid = 0;
    my_current_task = &task[pid];
   asm volatile(
       "movl %1,%%esp\n\t"    /* set task[pid].thread.sp to esp */
       "pushl %1\n\t"             /* push ebp */
       "pushl %0\n\t"             /* push task[pid].thread.ip */
       "ret\n\t"                 /* pop task[pid].thread.ip to eip */
       :
       : "c" (task[pid].thread.ip),"d" (task[pid].thread.sp)   /* input c or d mean %ecx/%edx*/
   );
}

int i = 0;

void my_process(void)
{
    while(1)
    {
        i++;
        if(i%10000000 == 0)
        {
            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);
        }
    }
}

my_start_kernel 是系统启动后最先调用的函数，在这个函数里完成了0号进程的初始化和启动，并创建了其它的进程PCB，以方便后面的调度。在模拟系统里，每个进程的函数代码都是一样的，即 my_process 函数，my_process 在执行的时候，会打印出当前进程的 id，从而使得我们能够看到当前哪个进程正在执行。

myinterrupt.c

/*
* linux/mykernel/myinterrupt.c
*
* Kernel internal my_timer_handler
*
* Copyright (C) 2013 Mengning
*
*/
#include <linux/types.h>
#include <linux/string.h>
#include <linux/ctype.h>
#include <linux/tty.h>
#include <linux/vmalloc.h>

#include "mypcb.h"

extern tPCB task[MAX_TASK_NUM];
extern tPCB * my_current_task;
extern volatile int my_need_sched;
volatile int time_count = 0;

/*
* Called by timer interrupt.
* it runs in the name of current running process,
* so it use kernel stack of current running process
*/
void my_timer_handler(void)
{
#if 1
    if(time_count%1000 == 0 && my_need_sched != 1)
    {
        printk(KERN_NOTICE ">>>my_timer_handler here<<<\n");
        my_need_sched = 1;
    }
    time_count ++ ;
#endif
    return;
}

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");
    /* schedule */
    next = my_current_task->next;
    prev = my_current_task;
    if(next->state == 0)/* -1 unrunnable, 0 runnable, >0 stopped */
    {
       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"         /* save ebp */
           "movl %%esp,%0\n\t"    /* save esp */
           "movl %2,%%esp\n\t"     /* restore esp */
           "movl $1f,%1\n\t"       /* save eip */
           "pushl %3\n\t"
           "ret\n\t"                 /* restore eip */
           "1:\t"                  /* next process start here */
           "popl %%ebp\n\t"
           : "=m" (prev->thread.sp),"=m" (prev->thread.ip)
           : "m" (next->thread.sp),"m" (next->thread.ip)
       );
    }
    return;
}

my_time_handler()函数，是个时间片轮转，周期性地发出中断信号，也就是my_need_sched。my_start_kernel()完成每个进程初始化，每个进程的任务都是my_process(),由于这个函数中有个无限循环，任务永远不会结束；并且启动了0号进程。任务需要调度时根据任务链表顺序进行调度。

mypcb.h

/*
* linux/mykernel/mypcb.h
*
* Kernel internal PCB types
*
* Copyright (C) 2013 Mengning
*
*/

#define MAX_TASK_NUM        4
#define KERNEL_STACK_SIZE   1024*2 # unsigned long
/* CPU-specific state of this task */
struct Thread {
    unsigned long       ip;
    unsigned long       sp;
};

typedef struct PCB{
    int pid;
    volatile long state;   /* -1 unrunnable, 0 runnable, >0 stopped */
    unsigned long stack[KERNEL_STACK_SIZE];
    /* CPU-specific state of this task */
    struct Thread thread;
    unsigned long   task_entry;
    struct PCB *next;
}tPCB;

void my_schedule(void);