基于mykernel完成多进程的简单内核

327

原创作品转载请注明出处 + https://github.com/mengning/linuxkernel/

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

根据操作系统中进程相关的知识，并参考mykernel代码，最简单的多道程序切换需要以下几点：

• 存储进程相关信息的PCB，包括pid，进程状态，寄存器信息等
• 用于存储所有进程的数据结构
• 启动进程时的初始化函数，包括初始化状态，分配pid，堆栈空间等
• 用于切换进程的时间片轮转调度算法

接下来，我将逐个分析这些步骤

定义存储进程相关信息的PCB

进程必备的信息包括

pid：进程号，每个进程的唯一标识

state：进程状态，在最简单的模拟中只有就绪和运行两种状态，分别用-1和0表示

stack：进程堆栈，一个指针，指向该进程独有的堆栈起始地址

ip：该进程的指令寄存器

sp：该进程的栈顶寄存器

task_entry：该进程的入口函数

 

当定义了这些信息之后，进程调度算法便可以根据它们来存储当前进程的状态，并恢复一个就绪进程的状态使其继续运行

相关代码如下

/*
 *  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);
 

代码中也表现了一下具体实现时的设计，

比如使用单链表来存储所有进程的PCB，用其结构中的next指针去追踪另一个进程的PCB

还有定义了一个调度算法的接口，需要在其他文件中去实现它

实现用于存储所有进程的数据结构

有了上一小节定义的PCB之后，还需要根据它们来实现存储所有进程的数据结构

该数据结构将供给进程初始化函数与进程调度算法使用

首先需要定义一个PCB链表，和一个指向当前进程的PCB指针

这两个数据结构将用于时间片轮转调度算法使用

然后定义一个数组来存储所有进程PCB

最后定义一个标志变量来标识当前是否需要调度进程

代码实现如下

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

在三个数据结构将会暴露给其他的文件，使用方式如下

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

实现启动进程的初始化函数

进程初始化的时机在kernel刚开始执行时，在mykernel项目中，该时刻位于mymain.c文件的my_start_kernel函数

即所有的初始化工作要在该函数中完成

在初始进程时，利用尾插法将生成的进程挨个插入队列尾部，同时把进程挨个存储在进程数组中

然后手动标识一个进程为当前进程，并将其指令寄存器与栈顶寄存器恢复至cpu的eip与esp中，使其运行起来

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

代码中将每个进程的入口函数都设置为my_process，该函数监听my_need_sched标识变量，当需要调度时，在其中调用调度函数my_schedule

void my_process(void)
{
	int i = 0;
	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_need_sched标识变量置为1，表示当前进程需要调度

代码如下

/*
 * 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;  	
}

接着实现进程切换功能，即之前定义的my_schedule函数

在该函数中获取当前进程PCB与下一个将要执行的进程PCB

并实现保存当前进程状态与恢复下一个进程状态，包括保存当前进程的ebp，esp，eip，恢复下一个进程的ebp，esp，eip

实现代码如下

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 */
    {
    	/* 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)
    	); 
    	my_current_task = next; 
    	printk(KERN_NOTICE ">>>switch %d to %d<<<\n",prev->pid,next->pid);   	
    }
    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)
    	);          
    }   
    return;	
}

至此，一个简单的时间片轮转进程调度算法便完成了

查看运行结果

总结

操作系统使用PCB数据结构对进程进行抽象，存储其相关信息

在一个进程运行时，操作系统接收到进程调度请求后，会执行进程调度算法，存储当前进程的相关信息至其PCB中，恢复某一个进程PCB中相关信息至寄存器中

这样，根据当前寄存器中的信息继续执行下去，便完成了进程的切换

转载于:https://www.cnblogs.com/svens/p/10520401.html