java开发系统内核：进程切换

更详细的讲解和代码调试演示过程，请参看视频
Linux kernel Hacker, 从零构建本身的内核vue

上一节，咱们初步介绍了进程相关的具体概念，特别是讲解了进程切换相关的数据结构，也就是TSS,也实现了进程的自我切换，本节，咱们看看如何从当前的进程切换到新进程，而后再切换回来，也就是：面试

进程A -切换->进程B-切换->进程A.算法

咱们先看看进程B的实现，一个进程主要包含一个主函数，咱们把进程B的主函数实现以下：微信

void task_b_main(void) {
   showString(shtctl, sht_back, 0, 144, COL8_FFFFFF, "enter task b");

    struct FIFO8 timerinfo_b;
    char timerbuf_b[8];
    struct TIMER *timer_b = 0;

    int i = 0;

    fifo8_init(&timerinfo_b, 8, timerbuf_b);
    timer_b = timer_alloc();
    timer_init(timer_b, &timerinfo_b, 123);

    timer_settime(timer_b, 500);

    for(;;) {

       io_cli();
        if (fifo8_status(&timerinfo_b) == 0) {
            io_sti();
        } else {
           i = fifo8_get(&timerinfo_b);
           io_sti();
           if (i == 123) {
               showString(shtctl, sht_back, 0, 160, COL8_FFFFFF, "switch back");
               taskswitch7();
           }

        }

    }

}

进程B函数的逻辑是这样的，当进入到进程B后，经过它的主函数如今桌面上打印出一个字符串”enter task b”, 当这个字符串出如今桌面时，表示进程完成了切换。而后它初始化一个时钟，这个时钟超时是五秒，五秒事后，它调用函数taskswitch7从新切回到进程A.markdown

进程A就是主入口函数CMain. 既然要切换进程B,那显然，咱们须要一个描述进程B的TSS结构，并进行相应的初始化，代码以下：数据结构

int addr_code32 = get_code32_addr();
 tss_b.eip =  (task_b_main - addr_code32);
    tss_b.eflags = 0x00000202; 
    tss_b.eax = 0;
    tss_b.ecx = 0;
    tss_b.edx = 0;
    tss_b.ebx = 0;
    tss_b.esp = 1024;//tss_a.esp;
    tss_b.ebp = 0;
    tss_b.esi = 0;
    tss_b.edi = 0;
    tss_b.es = tss_a.es;
    tss_b.cs = tss_a.cs;//6 * 8;
    tss_b.ss = tss_a.ss;
    tss_b.ds = tss_a.ds;
    tss_b.fs = tss_a.fs;
    tss_b.gs = tss_a.gs;

上面的代码须要详细解释下，首先咱们把tss_b.eflags设置成0x202,这个值能够当作一个写死的值，而后，咱们把进程B的段寄存器设置成跟A同样，咱们看看进程A的各个段寄存器分别指向哪一个全局描述符，tss_a.cs 的值是8，对应全局描述符表的下标就是1(数值要除以8，上一节讲解过）。下标为1的描述符是这样的：app

LABEL_DESC_CODE32:  Descriptor        0,      0fffffh,       DA_CR | DA_32 | DA_LIMIT_4K

这个描述符指向一段内存，这段内存的性质是可执行代码段，这段内存的起始地址在内核的汇编部分进行了初始化，以下：机器学习

xor   eax, eax
     mov   ax,  cs
     shl   eax, 4
     add   eax, LABEL_SEG_CODE32
     mov   word [LABEL_DESC_CODE32 + 2], ax
     shr   eax, 16
     mov   byte [LABEL_DESC_CODE32 + 4], al
     mov   byte [LABEL_DESC_CODE32 + 7], ah

上面的代码把描述符指向的内存地址的起始位置设置为LABEL_SEG_CODE32，
tss_a.ds 的值为24，除以8后为3，也就是对应描述符在全局描述符表中的下标是3，这个描述符内容以下：函数

LABEL_DESC_VRAM:    Descriptor        0,         0fffffh,            DA_DRWA | DA_LIMIT_4K

这个描述符指向的内存起始地址是0，长度为0fffffh, 这段内存的性质是可读写数据段，也就是从0到0fffffh这段长度的内存是可读写的数据。学习

tss_a.ss 的值是32，除以8后得4，所以对应的是下标为4的描述符，该描述符的内容以下：

LABEL_DESC_STACK:   Descriptor        0,             LenOfStackSection,        DA_DRWA | DA_32

它描述的是一段32位可读写的内存，长度为LenOfStackSection，它对应的这段内存是咱们在内核的汇编部分分配的内存，具体以下：

[SECTION .gs]
ALIGN 32
[BITS 32]
LABEL_STACK:
times 512  db 0
TopOfStack1  equ  $ - LABEL_STACK
times 512 db 0
TopOfStack2 equ $ - LABEL_STACK

LenOfStackSection equ $ - LABEL_STACK

上面分配了两个512字节，总共1024字节的内存，LABEL_STACK将会设置成下标为4的描述符所对应内存的起始地址，第一个512字节，做为进程A的堆栈，第二个512字节，将做为进程B的堆栈，上面tss_b的初始化代码中有这么一句：
tss_b.esp = 1024;
它的做用就是让进程把把堆栈指针指向第二个512字节的末尾处，你们要记得，堆栈是有高地址向低地址生长的，因此设置堆栈指针时，要把它指向内存的末尾。

在内核的汇编部分，有代码将下标为4的描述符对应的内容起始地址设置为了LABEL_STACK, 代码以下：

    xor   eax, eax
     mov   ax,  cs
     shl   eax, 4
     add   eax, LABEL_STACK
     mov   word [LABEL_DESC_STACK + 2], ax
     shr   eax, 16
     mov   byte [LABEL_DESC_STACK + 4], al
     mov   byte [LABEL_DESC_STACK + 7], ah

最重要的三个段寄存器，cs, ds, ss,设置好，其他寄存器，设置成跟进程A同样便可，接下来最重要的设置是eip指针，这个指针将指向要执行代码的首地址，咱们要执行的函数是task_b_main ,所以eip应该指向这个函数，但注意，咱们不能直接把这个函数的地址直接赋值给eip, eip指向的是相对于代码段起始地址的偏移，当前代码段的其实地址是LABEL_SEG_CODE32，所以咱们须要把task_b_main的地址减去LABEL_SEG_CODE32,所得的结果就是相对偏移了，这也是eip初始化的逻辑：
tss_b.eip = (task_b_main - addr_code32);

get_code32_addr是内核的汇编部分实现的行数，目的就是返回LABEL_SEG_CODE32对应的地址，实现以下：

get_code32_addr:
        mov  eax, LABEL_SEG_CODE32
        ret

上一节，咱们已经看到，咱们经过代码，讲一个描述符指向结构tss_b了，代码以下：

set_segmdesc(gdt + 9, 103, (int) &tss_b, AR_TSS32);

指向tss_b结构的描述符下标是9，初始化好tss_b后，只要经过一个jmp语句，跳转到下标为9的描述符，那么就能将当前指向进程切换成运行task_b_main的进程了，这个跳转语句实现以下：

taskswitch9:
        jmp 9*8:0
        ret

进程A运行的是CMain函数，它会建立一个5秒的计时器，一旦超时，则调用上面的函数实现任务切换：

for(;;) {
.....
else if (fifo8_status(&timerinfo) != 0) {
           io_sti();
           int i = fifo8_get(&timerinfo);
           if (i == 10) {
               showString(shtctl, sht_back, 0, 176, COL8_FFFFFF, "switch to task b");
                //switch task 
               taskswitch9();
           }
.....
}

在跳转前，咱们会在桌面上打印出一句switch to task b表示即将进行任务切换，task_b_main的实现咱们已经看过了，进入task_b_main后，它会在桌面打印一条语句，表示跳转成功，而后启动一个5秒的计时器，五秒事后，经过taskswitch7从新跳转回进程A.

从运行过程上看，当进程A运行时，有一个光标会在文本框中不断的闪烁：

一旦跳转到task_b_main, 桌面会打印出相关字符串，而后光标会中止住，等5庙后，进程从task_b_main,切换回进程A,进程A恢复执行，因而在卡死5秒后，在跳转会进程A前，task_b_main会打印出一条语句”switch back”,当这条语句出如今桌面上时，控制器转回到进程A, 因而光标会从新开始闪烁。

这样的话，咱们就实现了进程从A切换到B再从B切换回A的整个流程：

更加详细的讲解和调试演示请参看视频。

更多技术信息，包括操做系统，编译器，面试算法，机器学习，人工智能，请关照个人公众号：

本文分享自微信公众号 - Coding迪斯尼（gh_c9f933e7765d）。
若有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一块儿分享。