2022-2023-1 20222802 《Linux内核原理与分析》第三周作业

最新推荐文章于 2024-08-09 10:53:56 发布

20222802乔倩倩

最新推荐文章于 2024-08-09 10:53:56 发布

阅读量358

点赞数

文章标签： linux

本文链接：https://blog.csdn.net/Michelle_zzk/article/details/127143027

版权

1.使用实验楼的虚拟机打开 shell

2.查看 mymain.c ，myinterrupt.c

1.使用实验楼的虚拟机打开 shell

按行输入以下代码：

$ cd ~/LinuxKernel/linux-3.9.4 //进入目录Linux-3.9.4

$ rm -rf mykernel //强力删除mykernel

$ patch -p1 < ../mykernel_for_linux3.9.4sc.patch //patch命令用于为特定软件包打补丁，该命令使用diff命令对源文件进行操作

patch即补丁之意，记录文件中的不同，能够与文件进行整合，从而改变文件中的内容。

格式：patch [选项] [原始文件] [补丁文件]

利用补丁文件来修改，更新原始文件，达到升级原始文件功能的目的。

$ make allnoconfig

$ make

使用make allnoconfig 配置进行内核编译(编译时间较短) 。

在Linux系统中，专门提供了一个make命令来自动维护目标文件，与手工编译和连接相比，make命令的优点在于他只更新修改过的文件，如果make命令运行时没有指定目标，默认会执行Makefile文件的第一个目标。

$ qemu -kernel arch/x86/boot/bzImage //搭建目标环境

实验截图：

2.查看 mymain.c ，myinterrupt.c

$ cd mykerne //打开mykernel目录

$ ls //看到目录内容中包括 mymain.c ，myinterrupt.c

$ vi mymain.c //查看mymain.c 代码

$ vi myinterrupt.c //查看myinterrupt.c代码

3.分析该精简内核的源代码

3.1 mypcb.h

#define MAX_TASK_NUM        4
#define KERNEL_STACK_SIZE   1024*8

/* CPU-specific state of this task */
struct Thread {
    unsigned long       ip;   //对应eip
    unsigned long       sp;   //对应esp
};

typedef struct PCB{
    int pid;                 //定义进程id
    volatile long state;     //-1 unrunnable, 0 runnable, >0 stopped
    char 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); //声明调度函数

定义了PCB结构体，包括进程号、状态、堆栈、Thread结构体、入口地址、next指针。

3.2 mymain.c

（1）初始化所有进程，使成为循环链表：

#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]; //PCB的数组task
tPCB * my_current_task = NULL; //当前task指针
volatile int my_need_sched = 0; //是否需要调度

void my_process(void); //my_process函数声明

void __init my_start_kernel(void) //mykernel内核代码的入口
{
    int pid = 0;
    int i;
    /* 初始化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其他进程 */
    for(i=1;i<MAX_TASK_NUM;i++)
    {
        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[0]开始0号进程 */
    pid = 0;
    my_current_task = &task[pid];
}

（2）0号线程的启动

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 */
        "popl %%ebp\n\t"
        :
        : "c" (task[pid].thread.ip),"d" (task[pid].thread.sp)   /* input c or d mean %ecx/%edx*/
    );

3.3 myinterrupt.c

（1）时钟中断

void my_timer_handler(void) //时钟中断触发本函数
{
#if 1
    if(time_count%100 == 0 && my_need_sched != 1) //当时钟中断发生100次，并且my_need_sched不为1时，赋值为1
    {
        printk(KERN_NOTICE ">>>my_timer_handler here<<<\n");
        my_need_sched = 1;
    }
    time_count ++ ;
#endif
    return;
}

（2）进程调度

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);
        /* 切换进程 */
        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)
        );

    }

当下一个进程一次也没运行过，执行else后的语句：

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"       /* save ebp */
            "movl %%esp,%0\n\t"     /* save esp */
            "movl %2,%%esp\n\t"     /* restore esp */
            "movl %2,%%ebp\n\t"     /* restore ebp */
            "movl $1f,%1\n\t"       /* save eip */
            "pushl %3\n\t"
            "ret\n\t"               /* restore eip */
            : "=m" (prev->thread.sp),"=m" (prev->thread.ip)
            : "m" (next->thread.sp),"m" (next->thread.ip)
        );
    }