操作系统是如何工作的？——简单多道程序内核代码内核分析

原创 于 2015-03-15 16:01:16 发布 · 1.1k 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#调度 #内核 #代码 #存储 #基础

本文通过分析一个基于时间片轮转的简易内核调度代码，介绍了C语言内嵌汇编的应用，展示了如何实现进程调度及切换，并提供了在Linux环境下搭建和运行该内核的方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

谭东旭 原创作品转载请注明出处 《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-1000029000

上一篇文章我们花费了大量时间来讲解堆栈和AT&T的汇编，这是因为这些是我们理解计算机工作最基础的东西。但是对于了解整个计算机的运转，仅仅靠了解这一点还是不够的。计算机系统那么庞大和复杂：存储程序、调用堆栈、中断、保存现场以及中断返回、调度等，我们该如何去深入理解呢？ 再难的东西也是有最简单的事情组合起来的，下面我们就以一个简单的时间片轮转多道程序内核代码来理解整个操作系统是如何工作的吧。

c语言内嵌汇编

在c语言中内嵌汇编可以实现一些高级语言不能实现的或者不易实现的功能。对于时间紧迫的功能可以在c语言中内嵌汇编语句来实现。操作系统也是如此，我们来看一下其语法格式。

_asm_(

汇编语句模板：
输出部分 ：
输入部分 ：
破坏描述部分：

);
即格式为asm(“statements”:output_regs:input_regs:clobbered_regs);

同时“asm”也可以由“_asm_”来替代。“asm”是“_asm_”的别名。在“asm”后面有时候也会加上“_volatile_”表示编译器不要优化代码，后面的指令保留原样。所谓的输入输出部分就是函数调用的参数部分。就是下面我们也给出一个例子来理解内嵌汇编的语法。

#include <stdio.h>
int main()
{
/* val1+val2=val3 */
unsigned int val1 = 1;
unsigned int val2 = 2;
unsigned int val3 = 0;
printf("val1:%d,val2:%d,val3:%d\n",val1,val2,val3);
asm volatile(
"movl $0,%%eax\n\t"   /* clear %eax to 0 */
"addl %1,%%eax\n\t"   /* %eax += val1  */
"addl %2,%%eax\n\t"   /* %eax += val2 */
"movl %%eax,%0\n\t"   /* val3 = %eax */
: "=m" (val3)
/* output =m mean only write output memory variable */
: "c" (val1),"d" (val2)  /* input c or d mean %ecx/%edx */
);
printf("val1:%d+val2:%d=val3:%d\n",val1,val2,val3);
return 0;
}

内嵌汇编代码的含义如注释/* */所示，总的来说上述汇编的重难点有几个地方，汇编中的两个百分号如%%eax表示他是转义字符，即表示%eax,%0、%1、%2是表示输入和输出部分，但是这些分别表示什么呢，他是这样定义的：第一个输出参数就用编号0表示，第二个就用1表示……第n个即表示为n-1。那输入呢，它的标号是承接着输出部分，假如输出参数有n个，即编号到了n-1，那么第一个输入参数用编号n来表示，以此类推。所以得出上述%0表示val3,%1表示val1,%2表示val2。再看输入输出部分，在括号val3、val1、val2前面都有一个修饰。val1前边的“c”是表示ecx寄存器，意思就是说把val1存储到ecx寄存器。val2前面的“d”表示edx寄存器，把val2存到edx寄存器中。而val3前面的“=m”表示将val3写入到内存变量中去。“=”表示操作数在指令中是只写的（输出操作数）。“m”表示内存变量。

简单内核调度分析

有了上述的讲解，我们对内核代码中内嵌汇编有了一些基本的了解，下面我们就分析一个简单的内核代码来深入理解操作系统内核。我们完成内核调度的主要实现主要是靠三个文件完成：mypcb.h、mymain.c、myinterrupt.c。我们就对他们各自的代码做详细的分析。

mypcb.h

#define MAX_TASK_NUM        4
#define KERNEL_STACK_SIZE   1024*8

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

首先我们看到了该.h只是定义了进程相关的数据结构而已，struct Thread中定义了两个变量ip和sp，他们俩分别是用来存储eip和esp的值。而struct PCB是用来表示进程控制块的，pid表示进程的id,state表示进程的状态，-1表示该进程未运行，0表示正在运行，大于0则表示停止。数组stack[]表示进程堆栈，也表示为内核堆栈，还有就是线程thread以及任务的入口task_entry。还有就是*next连接下一个进程，即用链表把他们链接起来。最后还声明了一个调度器my_schedule。而且最大进程数量MAX_TASK_NUM=4。这段代码很简单，接下来我们就开始分析mymain.c

mymain.c

#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);
        }     
    }
}

首先可以看出该代码段设置了4个进程，即代码所示的0、1、2、3，从my_start_kernel函数开始，先初始化了0号进程，设置了pid、state、task_entry、thread.ip、thread.sp等信息。进程的入口则是my_process，此时系统中只有0号进程，所以该进程的next还是先指向自己。接着下面的for循环便是快速生成其他三个进程。且这三个都是处于未运行状态，他们以链表的形式连接起来。接下来my_current_task则是记录现在正在运行的进程，汇编代码则是启动0号进程。让esp指向0号进程栈顶(此时也是栈底). 把0进程栈底ebp（此时栈顶esp也指向同一位置）入栈, 把 当前thread.ip入栈,也就是myprocess 入口地址。跳转到函数myprocess. 除非 myprocess 返回, 否则 “popl %%ebp\n\t” 永远不会执行.栈入栈出的状态大家可以在纸上画出，我这里就不给出了。

上面的代码完成了初始化工作，0号进程已经启动起来了，但是进程启动起来他要干什么呢？其他三个进程怎么启动调度呢？进程间又是怎么切换呢？下面我们就来到介绍my_process函数了，这个函数也是每个进程都要做的事，我们看看里面的代码，每运行一千万次后调度一次，打印信息。然后判断是否需要改变信息，即my_need_sched是否等于1，如果为真就执行my_shedule函数。接下来改变my_current_task的值，这样完成了进程的切换。

进程的调度切换其实是用了my_shedule函数，这个函数其实是在myinterrupt.c中定义的，这个.C文件定义了有关中断的几个函数。下面我们来看看该函数：
myinterrupt.c

#include <linux/types.h>
#include <linux/string.h>
#include <linux/ctype.h>
#include <linux/tty.h>
#include <linux/vmalloc.h>
#include "mypcb.h"

extern tPCB task[MAX_TASK_NUM];
extern tPCB * my_current_task;
extern volatile int my_need_sched;
volatile int time_count = 0;
/*
 * 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;     
}

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

我们可以看出在中断调度中两个函数：时间中断处理函数my_timer_handler，再另一个就是调度处理函数my_schedule。程序怎么知道调度哪一个进程呢？其实它判断的标志就是my_need_sched是否等于1,时间中断函数周期性的触发, 每一千次置位一次标志 my_need_sched。也就是时间片的大小为1000,修改标志用于通知进程可执行。然后就进行my_schedule调度。此方式就是时间片轮转的方式。时间片阻塞轮询式锁,不是真正挂起。
终于回到了my_schedule这个调度的大boss,可以看出它定义了指向进程的两个指针*next，*prev。一个指向下一个进程，另一个指向当前进程。为了防止出错，先判断my_current_task是否指向了一个进程，并没有在进程的末尾，如果是一个野指针或者后面没有进程链表的元素，那么就退出。
最重要的是汇编代码部分，先判断后面的进程是否还是活动状态，即state=0，那么更改这两个进程的状态。如果不是活动状态，那就先将后面的进程设置成活动的，再进行交换。这就是程序中if..else语句的作用,总的来说他们就是针对两种不同状态的进程切换。
下面我们来分析if语句中的汇编含义：首先是构造一个新栈，将当前进程ebp入栈，保存好此时新栈的栈底部，接着将当前进程的 栈顶指针esp存入当前进程的 thread.sp中. 然后再将下一个进程的sp的值赋值给当前的esp，即栈顶指向了下一个进程的位置。movl $1f,%1\n\t 中的1f表示接下来的“1：”这个位置,而这个位置是下一个进程的起始位置。该句把下一个进程的开始位置赋值给了prev->thread.ip即当前进程要启动的位置。再接着将next 进程的最近一次切换前的 ip 入栈。ret最后进入下一个进程。
最后是else语句，弄清了上述汇编，该代码块也不是很难的，汇编的含义见代码后面的注释。

Linux系统环境搭建

代码部分我们已经讲解完毕，接下来我们就是要运行这个精简的系统内核。运行之前我们要有配置好的环境，这样才能运行起来。我们可用实验楼虚拟机，也可以自己搭建环境平台。下面我们就以搭建自己的平台为例（在linux12.04下），具体步骤如下：

  1. sudo apt-get install qemu # 下载 QEMU
  2. sudo ln -s /usr/bin/qemu-system-i386 /usr/bin/qemu
  3. wget https://www.kernel.org/pub/linux/kernel/v3.x/linux-3.9.4.tar.xz # 下载内核 Linux Kernel 3.9.4 source code
  4. wget https://raw.github.com/mengning/mykernel/master/mykernel_for_linux3.9.4sc.patch # 下载补丁 mykernel_for_linux3.9.4sc.patch
  5. xz -d linux-3.9.4.tar.xz
  6. tar -xvf linux-3.9.4.tar
  7. cd linux-3.9.4
  8. patch -p1 < ../mykernel_for_linux3.9.4sc.patch #打补丁
  9. make allnoconfig
  10. make

注意：在第6步解压后所得到的linux-3.9.4必须是放在第四级目录下，如我的是/home/tdx/project/linux-3.9.4，不是的话可能在make时无法通过，这是应为在Makefile里面对路径有了限制要求，我在这里就不修改了。还有一个很重要的问题就是打完补丁后，在linux-3.9.4文件夹下有个mykernel文件夹，将上述三个文件mypcb.h、mymain.c、myinterrupt.c替换到该目录下。然后再进行编译。最后执行命令
qemu -kernel arch/x86/boot/bzImage
从qemu窗口中您可以看到my_start_kernel在执行，同时my_timer_handler时钟中断处理程序周期性执行。运行结果如图：

这里写图片描述

整个过程理解起来不难，但是内核调度要自己动手写一个是挺难的。在本次实验中我们利用了linux-3.9.4内核已经搭建好的环境来进行一个简单的内核运行，为我们省了好多力。不过大家也不要紧张，这只是理解内核源码的开始，天下大事必作于细，天下难事必作于易嘛。

总结

计算机的三大法宝：存储程序计算机，程序调用堆栈和中断。这三大法宝是计算机运行调度不得基础。也是操作系统内核的本质所在。我对这三个法宝的理解和运用还没有停止，一直还在路上。。。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值