操作系统是怎么进行任务操作的

计算机工作需要三大法宝：

1、存储程序计算机工作模型，计算机系统最最基础性的逻辑结构：

2、函数调用，高级语言得以运行的基础，只有机器语言和汇编语言的时候堆栈机制对于计算机来说并不那么重要，但有了高级语言及函数，堆栈成为了计算机的基础功能；
enter  
pushl %ebp
 movl %esp,%ebp
leave  
movl %ebp,%esp
popl %ebp
函数参数传递机制和局部变量存储
3、中断，多道程序操作系统的基点，没有中断机制程序只能从头一直运行结束才有可能开始运行其他程序。

而内核的工作机制也非常类似，需要用到内核堆栈来进行任务调度，下面我们通过一个精简的内核代码来作一下分析：首先我们需要使用指令cd LinuxKernel/linux-3.9.4来进入这个文件，再通过cd mykernel来找到mymain.c和my interrupt.c

然后将mymain.c的源代码写进去

再打开myinterrupt.c写入源代码

然后再退出到上一个文件通过make指令重新编译

下面是运行后的界面

下面我们来分析下源代码：

main.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].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*/
);
}   
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);
        }     
    }
}

关于进程的启动，我们可以看到这段启动程序

pid = 0;
    my_current_task = &task[pid];     //将当前进程等于第一个进程
asm volatile(
     "movl %1,%%esp\n\t" /* set task[pid].thread.sp to esp */  //将task[pid].thread.sp放入到寄存器esp中
     "pushl %1\n\t"         /* push ebp */  //因为当前进程的堆栈块是空的，所以此时这条指令相当于将ebp入栈
     "pushl %0\n\t"         /* push task[pid].thread.ip */  //再将(task[pid].thread.ip入栈
     "ret\n\t"             /* pop task[pid].thread.ip to eip */   //将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*/

);

关于这段程序，我们可以看到启动一个进程的时候，我们会重新开辟一个堆栈块给这个进程，

就比如上图，因为有进程p2的运行，计算机重新开辟了一块堆栈块给它，但是在进程p2中又运行了进程p1，所以计算机又开辟了一块堆栈块给进程p1。

接下来我们分析下任务是怎么切换的，下面是任务切换的源代码：

void my_timer_handler(void)
{
#if 1
    if(time_count%1000 == 0 && my_need_sched != 1)    //这是任务调度的时间设置，我们可以通过调整1000这个值来进行调整
    {
        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 */    //这是任务切换的条件
    {
    /* switch to next process */
    asm volatile(
        "pushl %%ebp\n\t"    /* save ebp */   //任务切换时需要保存当前环境，将当前任务的ebp入栈，即保存ebp的值
        "movl %%esp,%0\n\t" /* save esp */   //将当前esp的值存入prev->thread.sp
        "movl %2,%%esp\n\t"     /* restore  esp */  //将next->thread.sp的值存入esp中，进入到需切换的任务的入口地址
        "movl $1f,%1\n\t"       /* save eip */   //将1f存入到prev->thread.ip中，即保存前一个任务的eip值
        "pushl %3\n\t"                                          //将next->thread.ip的值入栈
        "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;
}

从上面这段源代码可以看出，任务的切换就是通过内核堆栈来保存当前任务的环境来进行的，任务的切换也有两种情况，一种是下一个任务是可运行任务，那么需要保存当前任务运行环境，再进行任务切换，另一种是下一个任务是空任务，那么需要新建一个新任务，并保存当前任务的运行环境，再进行切换。

实验总结：

通过这次的实验，我们可以了解到进程之间的切换需要内核堆栈的配合才能完成，堆栈是整个多任务运行的基础，中断的实现也是依靠堆栈实现的，所以堆栈是计算机多任务运行的核心。

源代码引用自孟宁老师的网易云课堂讲义https://github.com/mengning/mykernel

                                                                                                                                                                                                                                                         作者      叶涛

                                                                                                   《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-1000029000