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

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

使用实验楼的虚拟机打开 shell，并执行如下语句。

# 注意路径是区分大小的
$ cd ~/LinuxKernel/linux-3.9.4

$ rm -rf mykernel

$ patch -p1 < ../mykernel_for_linux3.9.4sc.patch

$ make allnoconfig

# 编译内核请耐心等待
$ make

$ qemu -kernel arch/x86/boot/bzImage

实验结果如下所示

可以看到，在my_start_kernel函数中，不停地循环执行一条输出语句，打印出了在QEMU窗口中看到的>>>my_timer_handler here <<<<<

 这是一个被时钟中断状态下调用的函数：my_timer_handler。

实验结果如下所示

mykernel/mypcb.h

首先在mykernel目录下增加一个mypcb.h 头文件，用来定义进程控制块（Process Control Block），也就是进程结构体的定义，在Linux内核中是struct tast_struct结构体。

   

 
#define MAX_TASK_NUM        4              
#define KERNEL_STACK_SIZE   1024*2 # unsigned long       

struct Thread {                             
    unsigned long       ip;
    unsigned long       sp;
};
 
typedef struct PCB{                           
    int pid;
    volatile long state;    
    unsigned long stack[KERNEL_STACK_SIZE];
    
    struct Thread thread;
    unsigned long   task_entry;
    struct PCB *next;
}tPCB;
 
void my_schedule(void);

 mymain.c修改后的文件

对mymain.c进行修改，这是mykernel内核代码的入口，负责初始化内核的各个组成部分。在Linux内核源代码中，实际的内核入口是init/main.c中的start_kernel(void)函数。

 
#include "mypcb.h"
#include 

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;
    
    task[pid].pid = pid;
    task[pid].state = 0;
    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];
    
    for(i=1;ipid);
            if(my_need_sched == 1)
            {
                my_need_sched = 0;
                my_schedule();
            }
            printk(KERN_NOTICE "this is process %d +n",my_current_task->pid);
        }
    }
}

 对myinterrupt.c修改后的文件

对myinterrupt.c中修改my_timer_handler用来记录时间片.对myinterrupt.c进行修改，主要是增加了进程切换的代码my_schedule(void)函数，在Linux内核源代码中对应的是schedule(void)函数

#include "mypcb.h"
#include 
#include 
#include 
#include 
#include 

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



void my_timer_handler(void)
{
    if(time_count%1000 == 0 && my_need_sched != 1)
    {
        printk(KERN_NOTICE ">>>my_timer_handler here<<next == NULL)
    {
      return;
    }
    printk(KERN_NOTICE ">>>my_schedule<<next;
    prev = my_current_task;
    if(next->state == 0)
    {
      my_current_task = next;
      printk(KERN_NOTICE ">>>switch %d to %d<<pid,next->pid);
      
      asm volatile(
         "pushq %%rbpnt"       
         "movq %%rsp,%0nt"     
         "movq %2,%%rspnt"     
         "movq $1f,%1nt"       
         "pushq %3nt"          
         "retnt"               
         "1:t"                  
         "popq %%rbpnt"        
        : "=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<<pid,next->pid);
      
      asm volatile(
        "pushq %%rbpnt"       
        "movq %%rsp,%0nt"     
        "movq %2,%%rspnt"
        "movq %2,%%rbpnt"     
        "movq $1f,%1nt"       
        "pushq %3nt"
        "retnt"               
        "1:t"                  
        "popq %%rbpnt"
        : "=m" (prev->thread.sp),"=m" (prev->thread.ip)
        : "m" (next->thread.sp),"m" (next->thread.ip)
      );
    }
    return;
}

进程是操作系统的核心。在Linux系统中，进程和线程不做特别区分，线程是一种特殊的进程。进程存放在每一项类型为 task_struct（进程描述符，包括进程的地址空间、挂起的信号、状态等）的双向循环链表中，在内核栈的尾部创建 thread_info 结构，通过计算偏移间接查找进程描述符。父进程通过调用fork()复制本进程来创建新进程，exec()读取可执行文件并将其载入地址空间开始执行，最终，程序通过exit()系统调用退出执行。

  系统调用在用户空间进程和硬件设备之间添加了一个中间层。程序员只需和API打交道，内核只和系统调用打交道。访问系统调用，通常用C库中定义的函数调用来进行。每个系统调用被赋予了一个独一无二且不能更改的系统调用号，执行系统调用后陷入内核，传递系统调用号和参数，执行系统调用函数，并把返回值带回用户空间。“提供机制而不是策略”，系统调用抽象出用于完成某种目的的函数，至于函数如何使用不需要关心。