更详细的讲解和代码调试演示过程，请参看视频
Linux kernel Hacker, 从零构建自己的内核
有了进程的自动调度后，接下来的任务在于，如何将空闲进程挂起，空闲进程往往是那些没有具体任务需要处理的进程，因此，如果继续让其运行的话，那么必然会耗费宝贵的CPU资源，如果能让它先挂起，等到它需要执行具体任务时，再把它调度到前台，那才是一种合理的进程管理机制。
我们实现的进程调度，是依赖于进程控制器，也就是taskctl中的任务数组来实现的，当我们想要启动某个进程时，在该数组中找到对应的任务对象，然后把它加载到CPU那就可以了。
同理，如果要让某个进程休眠，那么只要把它对应的TASK对象从任务数组中移除，那么它自然就不会得到调度的机会。
因此，修改multi_task.c 增加一个task_sleep函数：
void task_sleep(struct TASK *task) {
int i;
char ts = 0;
if (task->flags == 2) {
if (task == taskctl->tasks[taskctl->now]) {
ts = 1;
}
for (i = 0; i < taskctl->running; i++) {
//在任务数组中找到要挂起的进程对象
if (taskctl->tasks[i] == task) {
break;
}
}
taskctl->running--;
if (i < taskctl->now) {
taskctl->now--;
}
for(; i < taskctl->running; i++) {
//通过把后面的任务往前覆盖，实现将当前任务从任务列表中移除的目的
taskctl->tasks[i] = taskctl->tasks[i+1];
}
task->flags = 1;
if (ts != 0) {
//如果当前挂起的任务正好是当前正在前台运行的任务，那么将第0个任务调度到前台
if (taskctl->now >= taskctl->running) {
taskctl->now = 0;
}
farjmp(0, taskctl->tasks[taskctl->now]->sel);
}
}
return;
}
该函数的逻辑是，根据要挂起的任务，在整个任务数组中查找，找到其对应的数组下标，然后把后面的任务向前覆盖，这样的话，要移除的任务就在数组中就会被覆盖掉，从而实现将任务从数组中移除的目的。
需要注意的是，如果要挂起的任务，正好是当前正在前台运行的进程，那么ts==1，我们就把下标为0的任务调度到前台，并且把任务的数量也就是running的值减一，这样，处于数组最后的那个任务将不会有机会被调度。
任务挂起是实现了，那么当我们想重新把任务调度到前台时，该怎么做呢？我们可以利用现有的队列机制，回忆一下，一旦鼠标，键盘的事件发生时，我们会把硬件产生的数据加入到他们对应的队列中，然后在CMain主循环中，将队列中的数据取出来处理。同理，当我们挂起一个任务时，我们把挂起的任务对象放入到一个队列中，当想要重新调度这个对象时，我们往队列里发送一个数据，然后在主循环中对该队列进行检查，一旦发现队列中含有数据的话，那么就把队列中寄存的任务重新加入调度数组。代码修改如下，在golbal_define.c中：
void fifo8_init(struct FIFO8 *fifo, int size, unsigned char *buf,
struct TASK *task) {
fifo->size = size;
fifo->buf = buf;
fifo->free = size;
fifo->flags = 0;
fifo->p = 0;
fifo->q = 0;
fifo->task = task;
return ;
}
在初始化一个队列时，把一个任务对象添加进去，如果队列不需要寄存任务对象，那么把task设置为0就可以。
int fifo8_put(struct FIFO8 *fifo, unsigned char data) {
if (fifo == 0) {
return -1;
}
if (fifo->free ==0) {
fifo->flags |= FLAGS_OVERRUN;
return -1;
}
fifo->buf[fifo->p] = data;
fifo->p++;
if (fifo->p == fifo->size) {
fifo->p = 0;
}
fifo->free--;
if (fifo->task != 0) {
if (fifo->task->flags != 2) {
task_run(fifo->task);
}
}
return 0;
}
当队列中有数据加入时，顺便查看该队列是否寄存着一个任务对象，如果是，那么把该任务对象加入调度数组。
由于timer.c中，对计时器的运行需要使用到队列，既然队列的数据结构有变动，因此timer.c中，需要做一点小改动：
static struct TIMERCTL timerctl;
extern struct TIMER *task_timer;
void init_pit(void) {
io_out8(PIT_CTRL, 0x34);
io_out8(PIT_CNT0, 0x9c);
io_out8(PIT_CNT0, 0x2e);
timerctl.count = 0;
int i;
for (i = 0; i < MAX_TIMER; i++) {
timerctl.timer[i].flags = 0; //not used
timerctl.timer[i].fifo = 0;
}
}
上面的改动在于，把每个timer对象的fifo队列成员设置为0。
接下来的改动主要在主入口函数中：
void CMain(void) {
....
fifo8_init(&timerinfo, 8, timerbuf, 0);
....
fifo8_init(&keyinfo, 32, keybuf, 0);
....
task_a = task_init(memman);
keyinfo.task = task_a;
....
}
上面代码的逻辑是，先通过task_init得到CMain函数所对应的任务对象，并把该任务对象寄存在键盘事件列表中，也就是keyinfo.task = task_a;
void CMain(void) {
....
task_run(task_b);
...
int pos = 0;
int stop_task_A = 0;
for(;;) {
io_cli();
....
else if (fifo8_status(&timerinfo) != 0) {
io_sti();
int i = fifo8_get(&timerinfo);
if (i == 10) {
showString(shtctl, sht_back, pos, 144, COL8_FFFFFF,
"A");
timer_settime(timer, 100);
pos += 8;
if (pos > 40 && stop_task_A == 0) {
io_cli();
task_sleep(task_a);
io_sti();
}
}
....
}
}
上面代码的逻辑时，当CMain函数在主循环中，连续打印字符"A",当打印的字符超过5个时，通过task_sleep(task_a)把CMain进程挂起。这样的话，系统运行时，我们会发现原来是字符A和B 是同时打印到桌面上的，此时便只剩下字符B在继续打印了。
这里写图片描述
由于我们把task_A寄存到键盘队列，那么当我们点击键盘，于是键盘数据就会存储到键盘队列中，由于键盘队列存储了任务Ad的任务对象，那么此时他会把对应任务对象重新加入到调度队列中，由此字符A会从恢复打印状态，也就是说，打印字符A的进程重新获得了被调度的机会。
这里写图片描述
参看视频，可以获得更加生动的演示展示。
更多技术信息，包括操作系统，编译器，面试算法，机器学习，人工智能，请关照我的公众号：
这里写图片描述
网友评论