[自制简单操作系统] 6、多任务（一）

 

#前言#

>_<" 这里主要是多任务的初探~比较简单，主要是尝试保存当前任务、任务切换、恢复当前任务，而真正的多任务要比这个复杂的多，因为包含互不干扰，甚至是高度优化的并行技术！

 

一、保存当前任务：

>_<" 当向CPU发出切换命令的时候，CPU会先把寄存器中的值全部写入内存中，这样当切换回来时，可以从中断的地方继续执行。接下来，为了运行下一个程序，CPU会把所有的寄存器中的值从内存中读取出来，这就完成了一次切换。

>_<" 这里的结构TSS32是task status segment,是32位任务状态段，其也是内存段的一种，需要再GDT中进行定以后使用。

struct TSS32 {//task status segment 任务状态段
    int backlink, esp0, ss0, esp1, ss1, esp2, ss2, cr3;//保存的不是寄存器的数据，而是与任务设置相关的信息，在执行任务切换的时候这些成员不会被写入（backlink除外，某些情况下会被写入）
    int eip, eflags, eax, ecx, edx, ebx, esp, ebp, esi, edi;//32位寄存器
    int es, cs, ss, ds, fs, gs;//16位寄存器
    int ldtr, iomap;//有关任务设置部分
};

 

二、任务切换:从任务A到任务B[12a]

>_<" 接下来要在main函数中创建两个TSS：任务A的TSS和任务B的TSS,然后对其初始化，接着再在GDT中定义...见下面的main函数(有删减，这里只展示核心部分)：

void HariMain(void)
{
    int mx, my, i ,cursor_x, cursor_c, task_b_esp;//cursor_x是记录光标位置的变量，cursor_c表示光标现在的颜色，每隔0.5秒变化一次,任务B的栈
    struct TSS32 tss_a, tss_b;//首先建立2个TSS，任务a的TSS和任务b的TSS
    tss_a.ldtr = 0;//先这样设置好
    tss_a.iomap = 0x40000000;
    tss_b.ldtr = 0;
    tss_b.iomap = 0x40000000;
    set_segmdesc(gdt + 3, 103, (int) &tss_a, AR_TSS32);//定义在gdt的3号，段长限制为103字节
    set_segmdesc(gdt + 4, 103, (int) &tss_b, AR_TSS32);
    //向TR寄存器写入这个值，因为刚才把当前运行任务的GDT定义为3号，TR寄存器是让CPU记住当前正在运行哪一个任务
    //每当进行任务切换时，TR寄存器的值也会自动变换，task register
    //每次给TR赋值的时候，必须把GDT的编号乘以8
    load_tr(3 * 8);
    task_b_esp = memman_alloc_4k(memman, 64 * 1024) + 64 * 1024;//要为任务B专门分配栈，直接用任务A的栈就会乱成一团糟
    tss_b.eip = (int) &task_b_main;//任务b的开始地址
    tss_b.eflags = 0x00000202; /* IF = 1; */
    tss_b.eax = 0;
    tss_b.ecx = 0;
    tss_b.edx = 0;
    tss_b.ebx = 0;
    tss_b.esp = task_b_esp;
    tss_b.ebp = 0;
    tss_b.esi = 0;
    tss_b.edi = 0;
    tss_b.es = 1 * 8;
    tss_b.cs = 2 * 8;
    tss_b.ss = 1 * 8;
    tss_b.ds = 1 * 8;
    tss_b.fs = 1 * 8;
    tss_b.gs = 1 * 8;
    
    for (;;) {140         if (fifo32_status(&fifo) == 0) {142         } else {145             if (256 <= i && i <= 511) {//键盘数据165             }else if (512 <= i && i <= 767) {//鼠标数据202             }else if(i==10){//10s定时
                taskswitch4();//程序10s以后进行任务切换
            }else if (i == 3){}219         }
    }
}300 /////////////////////////////////////////////////////////////////////////////////////
//功能：任务b的函数
//参数：
void task_b_main(void)
{
    for (;;) { io_hlt(); }
}

/* bootpack */

#include "bootpack.h"
#include <stdio.h>

void make_window8(unsigned char *buf, int xsize, int ysize, char *title);
void putfonts8_asc_sht(struct SHEET *sht, int x, int y, int c, int b, char *s, int l);//字符串显示
void make_textbox8(struct SHEET *sht, int x0, int y0, int sx, int sy, int c);

struct TSS32 {//task status segment 任务状态段
    int backlink, esp0, ss0, esp1, ss1, esp2, ss2, cr3;//保存的不是寄存器的数据，而是与任务设置相关的信息，在执行任务切换的时候这些成员不会被写入（backlink除外，某些情况下会被写入）
    int eip, eflags, eax, ecx, edx, ebx, esp, ebp, esi, edi;//32位寄存器
    int es, cs, ss, ds, fs, gs;//16位寄存器
    int ldtr, iomap;//有关任务设置部分
};
void task_b_main(void);

void HariMain(void)
{
    struct BOOTINFO *binfo = (struct BOOTINFO *) ADR_BOOTINFO;
    struct FIFO32 fifo;//定时器FIFO
    char s[40];
    int fifobuf[128];
    struct TIMER *timer,*timer2,*timer3;//3个定时器
    int mx, my, i ,cursor_x, cursor_c, task_b_esp;//cursor_x是记录光标位置的变量，cursor_c表示光标现在的颜色，每隔0.5秒变化一次,任务B的栈
    unsigned int memtotal;
    struct MOUSE_DEC mdec;
    struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
    struct SHTCTL *shtctl;
    struct SHEET *sht_back, *sht_mouse, *sht_win;
    unsigned char *buf_back, buf_mouse[256], *buf_win;
    static char keytable[0x54] = {//键盘映射表
        0,   0,   '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '-', '^', 0,   0,
        'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P', '@', '[', 0,   0,   'A', 'S',
        'D', 'F', 'G', 'H', 'J', 'K', 'L', ';', ':', 0,   0,   ']', 'Z', 'X', 'C', 'V',
        'B', 'N', 'M', ',', '.', '/', 0,   '*', 0,   ' ', 0,   0,   0,   0,   0,   0,
        0,   0,   0,   0,   0,   0,   0,   '7', '8', '9', '-', '4', '5', '6', '+', '1',
        '2', '3', '0', '.'
    };
    
    struct TSS32 tss_a, tss_b;//首先建立2个TSS，任务a的TSS和任务b的TSS
    struct SEGMENT_DESCRIPTOR *gdt = (struct SEGMENT_DESCRIPTOR *) ADR_GDT;
    
    init_gdtidt();//在dsctbl.c中，负责分区和中断分区初始化[包括键盘和鼠标中断设定]
    init_pic();//在int.c中，负责中断初始化（硬件）
    io_sti();//在naskfunc.nas中，仅仅执行STI指令，是CLI的逆指令，前者是开中断，后者是禁止中断
    /*
    同一占用一个fifo,这里：
    0~1               光标闪烁用定时器
    3                 3秒定时器
    10                10秒定时器
    256~511            键盘输入（从键盘控制器读入的值再加上256)
    512~767            鼠标输入（从键盘控制器读入的值再加上512)
    */
    fifo32_init(&fifo, 128, fifobuf);//初始化fifo
    init_pit();//负责计时器初始化100hz
    init_keyboard(&fifo, 256);//初始化键盘控制电路//在fifo.c中，负责缓冲区初始化（缓冲区结构体，大小，缓冲区首址）
    enable_mouse(&fifo, 512, &mdec);//使能鼠标
    /*这里IMR是(interrupt mask register),意思是“中断屏蔽寄存器”，是8位寄存器，分别对应8路IRQ信号，如果一路是1则该路被屏蔽，因为键盘中断是IRQ1,鼠标中断是IRQ12,且PIC分主从2个，从PIC连接主PIC的IRQ2,所以想要有鼠标和键盘中断，要PIC0的IRQ1和IRQ2，和PIC1的IRQ4*/
    io_out8(PIC0_IMR, 0xf8); /* (11111000) *///PIT,PIC1,键盘许可
    io_out8(PIC1_IMR, 0xef); /* (11101111) */

    timer = timer_alloc();//3个定时器
    timer_init(timer, &fifo, 10);
    timer_settime(timer, 1000);
    timer2 = timer_alloc();
    timer_init(timer2, &fifo, 3);
    timer_settime(timer2, 300);
    timer3 = timer_alloc();
    timer_init(timer3, &fifo, 1);
    timer_settime(timer3, 50);

    //memman需要32KB内存
    memtotal = memtest(0x00400000, 0xbfffffff);//计算总量memtatal
    memman_init(memman);
    memman_free(memman, 0x00001000, 0x0009e000); /* 0x00001000 - 0x0009efff 将现在不用的字节以0x1000个字节为单位注册到memman里*/
    memman_free(memman, 0x00400000, memtotal - 0x00400000);
    
    init_palette();//调色板
    shtctl = shtctl_init(memman, binfo->vram, binfo->scrnx, binfo->scrny);//图层初始化函数
    sht_back  = sheet_alloc(shtctl);//分配一个背景窗口
    sht_mouse = sheet_alloc(shtctl);//分配一个鼠标窗口
    sht_win   = sheet_alloc(shtctl);//分配一个小窗口
    buf_back  = (unsigned char *) memman_alloc_4k(memman, binfo->scrnx * binfo->scrny);//为背景窗口和普通小窗口分配缓存空间
    buf_win   = (unsigned char *) memman_alloc_4k(memman, 160 * 52);
    sheet_setbuf(sht_back, buf_back, binfo->scrnx, binfo->scrny, -1); /* 设定涂层缓冲区的大小和透明色的函数 */
    sheet_setbuf(sht_mouse, buf_mouse, 16, 16, 99);
    sheet_setbuf(sht_win, buf_win, 160, 52, -1); /* 设定涂层缓冲区的大小和透明色的函数 */
    init_screen8(buf_back, binfo->scrnx, binfo->scrny);//初始化屏幕，画矩形，形成最初的窗口界面
    init_mouse_cursor8(buf_mouse, 99);//准备鼠标指针(16*16),99是窗口背景颜色
    make_window8(buf_win, 160, 52, "WINDOW");//就像制作背景和鼠标一样，先准备一张图，然后在图层内描绘一个貌似窗口的图就可以了
    make_textbox8(sht_win, 8, 28, 144, 16, COL8_FFFFFF);//窗口上的文件编辑部分
    cursor_x = 8;
    cursor_c = COL8_FFFFFF;
    sheet_slide(sht_back, 0, 0);//上下左右移动窗口,即移动窗口至0,0
    mx = (binfo->scrnx - 16) / 2; /* 计算鼠标初始位置 */
    my = (binfo->scrny - 28 - 16) / 2;
    sheet_slide(sht_mouse, mx, my);//移动鼠标窗口
    sheet_slide(sht_win, 80, 72);//移动消息窗口
    sheet_updown(sht_back,  0);//设置窗口对的高度，背景在最下面
    sheet_updown(sht_win,   1);
    sheet_updown(sht_mouse, 2);
    sprintf(s, "(%3d, %3d)", mx, my);//显示鼠标位置
    putfonts8_asc_sht(sht_back, 0, 0, COL8_FFFFFF, COL8_008484, s, 10);
    sprintf(s, "memory %dMB   free : %dKB",
            memtotal / (1024 * 1024), memman_total(memman) / 1024);
    putfonts8_asc_sht(sht_back, 0, 32, COL8_FFFFFF, COL8_008484, s, 40);
    sheet_refresh(sht_back, 0, 0, binfo->scrnx, 48);

    tss_a.ldtr = 0;//先这样设置好
    tss_a.iomap = 0x40000000;
    tss_b.ldtr = 0;
    tss_b.iomap = 0x40000000;
    set_segmdesc(gdt + 3, 103, (int) &tss_a, AR_TSS32);//定义在gdt的3号，段长限制为103字节
    set_segmdesc(gdt + 4, 103, (int) &tss_b, AR_TSS32);
    //向TR寄存器写入这个值，因为刚才把当前运行任务的GDT定义为3号，TR寄存器是让CPU记住当前正在运行哪一个任务
    //每当进行任务切换时，TR寄存器的值也会自动变换，task register
    //每次给TR赋值的时候，必须把GDT的编号乘以8
    load_tr(3 * 8);
    task_b_esp = memman_alloc_4k(memman, 64 * 1024) + 64 * 1024;//要为任务B专门分配栈，直接用任务A的栈就会乱成一团糟
    tss_b.eip = (int) &task_b_main;//任务b的开始地址
    tss_b.eflags = 0x00000202; /* IF = 1; */
    tss_b.eax = 0;
    tss_b.ecx = 0;
    tss_b.edx = 0;
    tss_b.ebx = 0;
    tss_b.esp = task_b_esp;
    tss_b.ebp = 0;
    tss_b.esi = 0;
    tss_b.edi = 0;
    tss_b.es = 1 * 8;
    tss_b.cs = 2 * 8;
    tss_b.ss = 1 * 8;
    tss_b.ds = 1 * 8;
    tss_b.fs = 1 * 8;
    tss_b.gs = 1 * 8;
    
    for (;;) {
        io_cli();
        if (fifo32_status(&fifo) == 0) {
            io_sti();
        } else {
            i = fifo32_get(&fifo);
            io_sti();
            if (256 <= i && i <= 511) {//键盘数据
                sprintf(s, "%02X", i - 256);//减去256
                putfonts8_asc_sht(sht_back, 0, 16, COL8_FFFFFF, COL8_008484, s, 2);//清，显，刷
                if (i < 0x54 + 256) {
                    if (keytable[i - 256] != 0 && cursor_x < 144) {//一般字符
                        /* 显示一次就前移一次光标 */
                        s[0] = keytable[i - 256];
                        s[1] = 0;
                        putfonts8_asc_sht(sht_win, cursor_x, 28, COL8_000000, COL8_FFFFFF, s, 1);
                        cursor_x += 8;//记录光标位置
                    }
                }
                if (i == 256 + 0x0e && cursor_x > 8) { /* 退格键 */
                    /* 用空格键把光标消去后，后移1次光标 */
                    putfonts8_asc_sht(sht_win, cursor_x, 28, COL8_000000, COL8_FFFFFF, " ", 1);
                    cursor_x -= 8;
                }
                /* 光标再显示 */
                boxfill8(sht_win->buf, sht_win->bxsize, cursor_c, cursor_x, 28, cursor_x + 7, 43);
                sheet_refresh(sht_win, cursor_x, 28, cursor_x + 8, 44);
            }else if (512 <= i && i <= 767) {//鼠标数据
                //已经收集了3字节的数据，所以显示出来
                if (mouse_decode(&mdec, i - 512) != 0) {
                    sprintf(s, "[lcr %4d %4d]", mdec.x, mdec.y);
                    if ((mdec.btn & 0x01) != 0) {
                        s[1] = 'L';
                    }
                    if ((mdec.btn & 0x02) != 0) {
                        s[3] = 'R';
                    }
                    if ((mdec.btn & 0x04) != 0) {
                        s[2] = 'C';
                    }
                    putfonts8_asc_sht(sht_back, 32, 16, COL8_FFFFFF, COL8_008484, s, 15);//清，显，刷
                    /* 移动鼠标 */
                    mx += mdec.x;
                    my += mdec.y;
                    if (mx < 0) {
                        mx = 0;
                    }
                    if (my < 0) {
                        my = 0;
                    }
                    if (mx > binfo->scrnx - 1) {
                        mx = binfo->scrnx - 1;
                    }
                    if (my > binfo->scrny - 1) {
                        my = binfo->scrny - 1;
                    }
                    sprintf(s, "(%3d, %3d)", mx, my);
                    putfonts8_asc_sht(sht_back, 0, 0, COL8_FFFFFF, COL8_008484, s, 10);//清，显，刷
                    sheet_slide(sht_mouse, mx, my);
                    //移动窗口计算
                    if((mdec.btn & 0x01)!=0){
                        sheet_slide(sht_win,mx-80,my-80);
                    }//按下左键移动sht_win
                }
            }else if(i==10){//10s定时
                putfonts8_asc_sht(sht_back, 0, 64, COL8_FFFFFF, COL8_008484, "10[sec]", 7);//清，显，刷、
                taskswitch4();//程序10s以后进行任务切换
            }else if (i == 3) { //3秒定时器
                putfonts8_asc_sht(sht_back, 0, 80, COL8_FFFFFF, COL8_008484, "3[sec]", 6);
            }else if (i<=1) { //光标用定时器
                if (i != 0) {
                    timer_init(timer3, &fifo, 0); /* 師偼0傪 */
                    cursor_c = COL8_000000;
                } else {
                    timer_init(timer3, &fifo, 1); /* 師偼1傪 */
                    cursor_c = COL8_FFFFFF;
                }
                timer_settime(timer3, 50);
                boxfill8(sht_win->buf, sht_win->bxsize, cursor_c, cursor_x, 28, cursor_x + 7, 43);
                sheet_refresh(sht_win, cursor_x, 28, cursor_x + 8, 44);
            }
        }
    }
}
/////////////////////////////////////////////////////////////////////////////////////
//功能：就像制作背景和鼠标一样，先准备一张图，然后在图层内描绘一个貌似窗口的图就可以了
//参数：
void make_window8(unsigned char *buf, int xsize, int ysize, char *title)
{
    static char closebtn[14][16] = {
        "OOOOOOOOOOOOOOO@",
        "OQQQQQQQQQQQQQ$@",
        "OQQQQQQQQQQQQQ$@",
        "OQQQ@@QQQQ@@QQ$@",
        "OQQQQ@@QQ@@QQQ$@",
        "OQQQQQ@@@@QQQQ$@",
        "OQQQQQQ@@QQQQQ$@",
        "OQQQQQ@@@@QQQQ$@",
        "OQQQQ@@QQ@@QQQ$@",
        "OQQQ@@QQQQ@@QQ$@",
        "OQQQQQQQQQQQQQ$@",
        "OQQQQQQQQQQQQQ$@",
        "O$$$$$$$$$$$$$$@",
        "@@@@@@@@@@@@@@@@"
    };
    int x, y;
    char c;
    boxfill8(buf, xsize, COL8_C6C6C6, 0,         0,         xsize - 1, 0        );
    boxfill8(buf, xsize, COL8_FFFFFF, 1,         1,         xsize - 2, 1        );
    boxfill8(buf, xsize, COL8_C6C6C6, 0,         0,         0,         ysize - 1);
    boxfill8(buf, xsize, COL8_FFFFFF, 1,         1,         1,         ysize - 2);
    boxfill8(buf, xsize, COL8_848484, xsize - 2, 1,         xsize - 2, ysize - 2);
    boxfill8(buf, xsize, COL8_000000, xsize - 1, 0,         xsize - 1, ysize - 1);
    boxfill8(buf, xsize, COL8_C6C6C6, 2,         2,         xsize - 3, ysize - 3);
    boxfill8(buf, xsize, COL8_000084, 3,         3,         xsize - 4, 20       );
    boxfill8(buf, xsize, COL8_848484, 1,         ysize - 2, xsize - 2, ysize - 2);
    boxfill8(buf, xsize, COL8_000000, 0,         ysize - 1, xsize - 1, ysize - 1);
    putfonts8_asc(buf, xsize, 24, 4, COL8_FFFFFF, title);
    for (y = 0; y < 14; y++) {
        for (x = 0; x < 16; x++) {
            c = closebtn[y][x];
            if (c == '@') {
                c = COL8_000000;
            } else if (c == '$') {
                c = COL8_848484;
            } else if (c == 'Q') {
                c = COL8_C6C6C6;
            } else {
                c = COL8_FFFFFF;
            }
            buf[(5 + y) * xsize + (xsize - 21 + x)] = c;
        }
    }
    return;
}
/////////////////////////////////////////////////////////////////////////////////////
//功能：先图上背景颜色，再显示字符，最后完成刷新
//参数：图层，位置，字体颜色，背景颜色，字符串，字符串长度
void putfonts8_asc_sht(struct SHEET *sht, int x, int y, int c, int b, char *s, int l)
{
    boxfill8(sht->buf, sht->bxsize, b, x, y, x + l * 8 - 1, y + 15);
    putfonts8_asc(sht->buf, sht->bxsize, x, y, c, s);
    sheet_refresh(sht, x, y, x + l * 8, y + 16);
    return;
}
/////////////////////////////////////////////////////////////////////////////////////
//功能：描绘文字输入背景的
//参数：
void make_textbox8(struct SHEET *sht, int x0, int y0, int sx, int sy, int c)
{
    int x1 = x0 + sx, y1 = y0 + sy;
    boxfill8(sht->buf, sht->bxsize, COL8_848484, x0 - 2, y0 - 3, x1 + 1, y0 - 3);
    boxfill8(sht->buf, sht->bxsize, COL8_848484, x0 - 3, y0 - 3, x0 - 3, y1 + 1);
    boxfill8(sht->buf, sht->bxsize, COL8_FFFFFF, x0 - 3, y1 + 2, x1 + 1, y1 + 2);
    boxfill8(sht->buf, sht->bxsize, COL8_FFFFFF, x1 + 2, y0 - 3, x1 + 2, y1 + 2);
    boxfill8(sht->buf, sht->bxsize, COL8_000000, x0 - 1, y0 - 2, x1 + 0, y0 - 2);
    boxfill8(sht->buf, sht->bxsize, COL8_000000, x0 - 2, y0 - 2, x0 - 2, y1 + 0);
    boxfill8(sht->buf, sht->bxsize, COL8_C6C6C6, x0 - 2, y1 + 1, x1 + 0, y1 + 1);
    boxfill8(sht->buf, sht->bxsize, COL8_C6C6C6, x1 + 1, y0 - 2, x1 + 1, y1 + 1);
    boxfill8(sht->buf, sht->bxsize, c,           x0 - 1, y0 - 1, x1 + 0, y1 + 0);
    return;
}
/////////////////////////////////////////////////////////////////////////////////////
//功能：任务b的函数
//参数：
void task_b_main(void)
{
    for (;;) { io_hlt(); }
}

• 第41行是建立2个TSS,分别是任务A和任务B的

• 第110~113是对A和B的TSS任务的成员变量的初始化，这里不能乱赋值否则不能正常切换

• 第114和第115两行是定义两个TSS的GDT,分别是段3和段4

• 第119行load_tr(3 * 8);是用汇编写的函数，目的是给TR寄存器赋值，因为刚才设置任务a的GDT为3，而TR寄存器是让CPU记住当前执行那一条任务，所以，要给TR重新设置值，这里*8是和硬件有关~

• 第120行是给任务B分配栈，否则和任务A混在一起就会出现混乱

• 第121~136是对B的TSS的初始化设置，其中第一行指定任务B的入口地址，当任务切换到任务B时，就会转到第303行任务B的函数执行~

• 第204行是任务切换，同样这里的函数也是用汇编写的，里面就是一个JMP语句：JMP 4*8:0 用来转到任务B所对应的段地址，我们可以看到这是在10s定时器中写的，所以每隔10s就进行任务切换了

• @总的来说，这段代码的任务就是做一个10s后的任务切换工作，先运行A任务，然后任务切换进入B，一直处于进行hlt()~

 

三、任务切换：任务A和B的互相切换[12b]

>_<" 上面只是实现了从任务A切换到任务B，然后就一直处于hlt()了~这里我们只要简单的改一下任务B的函数就能实现任务的切回了：

void task_b_main(void)
{
    struct FIFO32 fifo;
    struct TIMER *timer;
    int i,fifobuf[128];
    
    fifo32_init(&fifo,128,fifobuf);
    timer=timer_alloc();
    timer_init(timer,&fifo,1);
    timer_settime(timer,500);
    
    for(;;){
        io_cli();
        if(fifo32_status(&fifo)==0){
            io_stihlt();
        }else{
            i=fifo32_get(&fifo);
            io_sti();
            if(i==1){//超时时间为5s
                taskswitch3();//返回任务A
            }
        }
    }
}

PS: 这里在任务B的函数里写了和任务A中相同的变量名，其实是互不影响的~

 

四、多任务：每隔0.02s切换任务 & 变量传递[这里是窗口sht_back][12e]

>_<" 这里把汇编写的taskswitch3();和taskswitch4();合并为一个可以带参数的任务切换函数farjmp()，并声明一个定时器0.02s中断一次用于任务切换，注意这里每次切换后要重新设置定时器，以便下次仍然是0.02s切换一次~，对于参数传递采用的思路是：把sht_back在任务A的时候找一个内存存进去(*((int*)0x0fec)=(int) sht_back;),然后在任务B的时候再从这个内存中读出sht_back的值(sht_back=(struct SHEET *)*((int*)0x0fec);)

if (i==2){//每隔0.02s执行一次任务切换
    farjmp(0,4*8);
    timer_settime(timer_ts,2);
}

/* bootpack */

#include "bootpack.h"
#include <stdio.h>

void make_window8(unsigned char *buf, int xsize, int ysize, char *title);
void putfonts8_asc_sht(struct SHEET *sht, int x, int y, int c, int b, char *s, int l);//字符串显示
void make_textbox8(struct SHEET *sht, int x0, int y0, int sx, int sy, int c);

struct TSS32 {//task status segment 任务状态段
    int backlink, esp0, ss0, esp1, ss1, esp2, ss2, cr3;//保存的不是寄存器的数据，而是与任务设置相关的信息，在执行任务切换的时候这些成员不会被写入（backlink除外，某些情况下会被写入）
    int eip, eflags, eax, ecx, edx, ebx, esp, ebp, esi, edi;//32位寄存器
    int es, cs, ss, ds, fs, gs;//16位寄存器
    int ldtr, iomap;//有关任务设置部分
};
void task_b_main(void);

void HariMain(void)
{
    struct BOOTINFO *binfo = (struct BOOTINFO *) ADR_BOOTINFO;
    struct FIFO32 fifo;//定时器FIFO
    char s[40];
    int fifobuf[128];
    struct TIMER *timer,*timer2,*timer3,*timer_ts;//4个定时器
    int mx, my, i ,cursor_x, cursor_c, task_b_esp;//cursor_x是记录光标位置的变量，cursor_c表示光标现在的颜色，每隔0.5秒变化一次,任务B的栈
    unsigned int memtotal;
    struct MOUSE_DEC mdec;
    struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
    struct SHTCTL *shtctl;//图层管理
    struct SHEET *sht_back, *sht_mouse, *sht_win;//3个图层
    unsigned char *buf_back, buf_mouse[256], *buf_win;
    static char keytable[0x54] = {//键盘映射表
        0,   0,   '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '-', '^', 0,   0,
        'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P', '@', '[', 0,   0,   'A', 'S',
        'D', 'F', 'G', 'H', 'J', 'K', 'L', ';', ':', 0,   0,   ']', 'Z', 'X', 'C', 'V',
        'B', 'N', 'M', ',', '.', '/', 0,   '*', 0,   ' ', 0,   0,   0,   0,   0,   0,
        0,   0,   0,   0,   0,   0,   0,   '7', '8', '9', '-', '4', '5', '6', '+', '1',
        '2', '3', '0', '.'
    };
    
    struct TSS32 tss_a, tss_b;//首先建立2个TSS，任务a的TSS和任务b的TSS
    struct SEGMENT_DESCRIPTOR *gdt = (struct SEGMENT_DESCRIPTOR *) ADR_GDT;
    
    init_gdtidt();//在dsctbl.c中，负责分区和中断分区初始化[包括键盘和鼠标中断设定]
    init_pic();//在int.c中，负责中断初始化（硬件）
    io_sti();//在naskfunc.nas中，仅仅执行STI指令，是CLI的逆指令，前者是开中断，后者是禁止中断
    /*
    同一占用一个fifo,这里：
    0~1               光标闪烁用定时器
    3                 3秒定时器
    10                10秒定时器
    256~511            键盘输入（从键盘控制器读入的值再加上256)
    512~767            鼠标输入（从键盘控制器读入的值再加上512)
    */
    fifo32_init(&fifo, 128, fifobuf);//初始化fifo
    init_pit();//负责计时器初始化100hz
    init_keyboard(&fifo, 256);//初始化键盘控制电路//在fifo.c中，负责缓冲区初始化（缓冲区结构体，大小，缓冲区首址）
    enable_mouse(&fifo, 512, &mdec);//使能鼠标
    /*这里IMR是(interrupt mask register),意思是“中断屏蔽寄存器”，是8位寄存器，分别对应8路IRQ信号，如果一路是1则该路被屏蔽，因为键盘中断是IRQ1,鼠标中断是IRQ12,且PIC分主从2个，从PIC连接主PIC的IRQ2,所以想要有鼠标和键盘中断，要PIC0的IRQ1和IRQ2，和PIC1的IRQ4*/
    io_out8(PIC0_IMR, 0xf8); /* (11111000) *///PIT,PIC1,键盘许可
    io_out8(PIC1_IMR, 0xef); /* (11101111) */

    timer = timer_alloc();//4个定时器
    timer_init(timer, &fifo, 10);
    timer_settime(timer, 1000);
    timer2 = timer_alloc();
    timer_init(timer2, &fifo, 3);
    timer_settime(timer2, 300);
    timer3 = timer_alloc();
    timer_init(timer3, &fifo, 1);
    timer_settime(timer3, 50);
    timer_ts = timer_alloc();
    timer_init(timer_ts, &fifo, 2);
    timer_settime(timer_ts, 2);

    //memman需要32KB内存
    memtotal = memtest(0x00400000, 0xbfffffff);//计算总量memtatal
    memman_init(memman);
    memman_free(memman, 0x00001000, 0x0009e000); /* 0x00001000 - 0x0009efff 将现在不用的字节以0x1000个字节为单位注册到memman里*/
    memman_free(memman, 0x00400000, memtotal - 0x00400000);
    
    init_palette();//调色板
    shtctl = shtctl_init(memman, binfo->vram, binfo->scrnx, binfo->scrny);//图层初始化函数
    sht_back  = sheet_alloc(shtctl);//分配一个背景窗口
    sht_mouse = sheet_alloc(shtctl);//分配一个鼠标窗口
    sht_win   = sheet_alloc(shtctl);//分配一个小窗口
    buf_back  = (unsigned char *) memman_alloc_4k(memman, binfo->scrnx * binfo->scrny);//为背景窗口和普通小窗口分配缓存空间
    buf_win   = (unsigned char *) memman_alloc_4k(memman, 160 * 52);
    sheet_setbuf(sht_back, buf_back, binfo->scrnx, binfo->scrny, -1); /* 设定涂层缓冲区的大小和透明色的函数 */
    sheet_setbuf(sht_mouse, buf_mouse, 16, 16, 99);
    sheet_setbuf(sht_win, buf_win, 160, 52, -1); /* 设定涂层缓冲区的大小和透明色的函数 */
    init_screen8(buf_back, binfo->scrnx, binfo->scrny);//初始化屏幕，画矩形，形成最初的窗口界面
    init_mouse_cursor8(buf_mouse, 99);//准备鼠标指针(16*16),99是窗口背景颜色
    make_window8(buf_win, 160, 52, "WINDOW");//就像制作背景和鼠标一样，先准备一张图，然后在图层内描绘一个貌似窗口的图就可以了
    make_textbox8(sht_win, 8, 28, 144, 16, COL8_FFFFFF);//窗口上的文件编辑部分
    cursor_x = 8;
    cursor_c = COL8_FFFFFF;
    sheet_slide(sht_back, 0, 0);//上下左右移动窗口,即移动窗口至0,0
    mx = (binfo->scrnx - 16) / 2; /* 计算鼠标初始位置 */
    my = (binfo->scrny - 28 - 16) / 2;
    sheet_slide(sht_mouse, mx, my);//移动鼠标窗口
    sheet_slide(sht_win, 80, 72);//移动消息窗口
    sheet_updown(sht_back,  0);//设置窗口对的高度，背景在最下面
    sheet_updown(sht_win,   1);
    sheet_updown(sht_mouse, 2);
    sprintf(s, "(%3d, %3d)", mx, my);//显示鼠标位置
    putfonts8_asc_sht(sht_back, 0, 0, COL8_FFFFFF, COL8_008484, s, 10);
    sprintf(s, "memory %dMB   free : %dKB",
            memtotal / (1024 * 1024), memman_total(memman) / 1024);
    putfonts8_asc_sht(sht_back, 0, 32, COL8_FFFFFF, COL8_008484, s, 40);
//    sheet_refresh(sht_back, 0, 0, binfo->scrnx, 48);

    tss_a.ldtr = 0;//先这样设置好
    tss_a.iomap = 0x40000000;
    tss_b.ldtr = 0;
    tss_b.iomap = 0x40000000;
    set_segmdesc(gdt + 3, 103, (int) &tss_a, AR_TSS32);//定义在gdt的3号，段长限制为103字节
    set_segmdesc(gdt + 4, 103, (int) &tss_b, AR_TSS32);
    //向TR寄存器写入这个值，因为刚才把当前运行任务的GDT定义为3号，TR寄存器是让CPU记住当前正在运行哪一个任务
    //每当进行任务切换时，TR寄存器的值也会自动变换，task register
    //每次给TR赋值的时候，必须把GDT的编号乘以8
    load_tr(3 * 8);
    task_b_esp = memman_alloc_4k(memman, 64 * 1024) + 64 * 1024;//要为任务B专门分配栈，直接用任务A的栈就会乱成一团糟
    tss_b.eip = (int) &task_b_main;//任务b的开始地址
    tss_b.eflags = 0x00000202; /* IF = 1; */
    tss_b.eax = 0;
    tss_b.ecx = 0;
    tss_b.edx = 0;
    tss_b.ebx = 0;
    tss_b.esp = task_b_esp;
    tss_b.ebp = 0;
    tss_b.esi = 0;
    tss_b.edi = 0;
    tss_b.es = 1 * 8;
    tss_b.cs = 2 * 8;
    tss_b.ss = 1 * 8;
    tss_b.ds = 1 * 8;
    tss_b.fs = 1 * 8;
    tss_b.gs = 1 * 8;
    *((int*)0x0fec)=(int) sht_back;//将这个变量从任务A传给任务B
    
    for (;;) {
        io_cli();
        if (fifo32_status(&fifo) == 0) {
            io_sti();
        } else {
            i = fifo32_get(&fifo);
            io_sti();
            if (i==2){//每隔0.02s执行一次任务切换
                farjmp(0,4*8);
                timer_settime(timer_ts,2);
            }if (256 <= i && i <= 511) {//键盘数据
                sprintf(s, "%02X", i - 256);//减去256
                putfonts8_asc_sht(sht_back, 0, 16, COL8_FFFFFF, COL8_008484, s, 2);//清，显，刷
                if (i < 0x54 + 256) {
                    if (keytable[i - 256] != 0 && cursor_x < 144) {//一般字符
                        /* 显示一次就前移一次光标 */
                        s[0] = keytable[i - 256];
                        s[1] = 0;
                        putfonts8_asc_sht(sht_win, cursor_x, 28, COL8_000000, COL8_FFFFFF, s, 1);
                        cursor_x += 8;//记录光标位置
                    }
                }
                if (i == 256 + 0x0e && cursor_x > 8) { /* 退格键 */
                    /* 用空格键把光标消去后，后移1次光标 */
                    putfonts8_asc_sht(sht_win, cursor_x, 28, COL8_000000, COL8_FFFFFF, " ", 1);
                    cursor_x -= 8;
                }
                /* 光标再显示 */
                boxfill8(sht_win->buf, sht_win->bxsize, cursor_c, cursor_x, 28, cursor_x + 7, 43);
                sheet_refresh(sht_win, cursor_x, 28, cursor_x + 8, 44);
            }else if (512 <= i && i <= 767) {//鼠标数据
                //已经收集了3字节的数据，所以显示出来
                if (mouse_decode(&mdec, i - 512) != 0) {
                    sprintf(s, "[lcr %4d %4d]", mdec.x, mdec.y);
                    if ((mdec.btn & 0x01) != 0) {
                        s[1] = 'L';
                    }
                    if ((mdec.btn & 0x02) != 0) {
                        s[3] = 'R';
                    }
                    if ((mdec.btn & 0x04) != 0) {
                        s[2] = 'C';
                    }
                    putfonts8_asc_sht(sht_back, 32, 16, COL8_FFFFFF, COL8_008484, s, 15);//清，显，刷
                    /* 移动鼠标 */
                    mx += mdec.x;
                    my += mdec.y;
                    if (mx < 0) {
                        mx = 0;
                    }
                    if (my < 0) {
                        my = 0;
                    }
                    if (mx > binfo->scrnx - 1) {
                        mx = binfo->scrnx - 1;
                    }
                    if (my > binfo->scrny - 1) {
                        my = binfo->scrny - 1;
                    }
                    sprintf(s, "(%3d, %3d)", mx, my);
                    putfonts8_asc_sht(sht_back, 0, 0, COL8_FFFFFF, COL8_008484, s, 10);//清，显，刷
                    sheet_slide(sht_mouse, mx, my);
                    //移动窗口计算
                    if((mdec.btn & 0x01)!=0){
                        sheet_slide(sht_win,mx-80,my-80);
                    }//按下左键移动sht_win
                }
            }else if(i==10){//10s定时
                putfonts8_asc_sht(sht_back, 0, 64, COL8_FFFFFF, COL8_008484, "10[sec]", 7);//清，显，刷、
            }else if (i == 3) { //3秒定时器
                putfonts8_asc_sht(sht_back, 0, 80, COL8_FFFFFF, COL8_008484, "3[sec]", 6);
            }else if (i<=1) { //光标用定时器
                if (i != 0) {
                    timer_init(timer3, &fifo, 0); /* 師偼0傪 */
                    cursor_c = COL8_000000;
                } else {
                    timer_init(timer3, &fifo, 1); /* 師偼1傪 */
                    cursor_c = COL8_FFFFFF;
                }
                timer_settime(timer3, 50);
                boxfill8(sht_win->buf, sht_win->bxsize, cursor_c, cursor_x, 28, cursor_x + 7, 43);
                sheet_refresh(sht_win, cursor_x, 28, cursor_x + 8, 44);
            }
        }
    }
}
/////////////////////////////////////////////////////////////////////////////////////
//功能：就像制作背景和鼠标一样，先准备一张图，然后在图层内描绘一个貌似窗口的图就可以了
//参数：
void make_window8(unsigned char *buf, int xsize, int ysize, char *title)
{
    static char closebtn[14][16] = {
        "OOOOOOOOOOOOOOO@",
        "OQQQQQQQQQQQQQ$@",
        "OQQQQQQQQQQQQQ$@",
        "OQQQ@@QQQQ@@QQ$@",
        "OQQQQ@@QQ@@QQQ$@",
        "OQQQQQ@@@@QQQQ$@",
        "OQQQQQQ@@QQQQQ$@",
        "OQQQQQ@@@@QQQQ$@",
        "OQQQQ@@QQ@@QQQ$@",
        "OQQQ@@QQQQ@@QQ$@",
        "OQQQQQQQQQQQQQ$@",
        "OQQQQQQQQQQQQQ$@",
        "O$$$$$$$$$$$$$$@",
        "@@@@@@@@@@@@@@@@"
    };
    int x, y;
    char c;
    boxfill8(buf, xsize, COL8_C6C6C6, 0,         0,         xsize - 1, 0        );
    boxfill8(buf, xsize, COL8_FFFFFF, 1,         1,         xsize - 2, 1        );
    boxfill8(buf, xsize, COL8_C6C6C6, 0,         0,         0,         ysize - 1);
    boxfill8(buf, xsize, COL8_FFFFFF, 1,         1,         1,         ysize - 2);
    boxfill8(buf, xsize, COL8_848484, xsize - 2, 1,         xsize - 2, ysize - 2);
    boxfill8(buf, xsize, COL8_000000, xsize - 1, 0,         xsize - 1, ysize - 1);
    boxfill8(buf, xsize, COL8_C6C6C6, 2,         2,         xsize - 3, ysize - 3);
    boxfill8(buf, xsize, COL8_000084, 3,         3,         xsize - 4, 20       );
    boxfill8(buf, xsize, COL8_848484, 1,         ysize - 2, xsize - 2, ysize - 2);
    boxfill8(buf, xsize, COL8_000000, 0,         ysize - 1, xsize - 1, ysize - 1);
    putfonts8_asc(buf, xsize, 24, 4, COL8_FFFFFF, title);
    for (y = 0; y < 14; y++) {
        for (x = 0; x < 16; x++) {
            c = closebtn[y][x];
            if (c == '@') {
                c = COL8_000000;
            } else if (c == '$') {
                c = COL8_848484;
            } else if (c == 'Q') {
                c = COL8_C6C6C6;
            } else {
                c = COL8_FFFFFF;
            }
            buf[(5 + y) * xsize + (xsize - 21 + x)] = c;
        }
    }
    return;
}
/////////////////////////////////////////////////////////////////////////////////////
//功能：先图上背景颜色，再显示字符，最后完成刷新
//参数：图层，位置，字体颜色，背景颜色，字符串，字符串长度
void putfonts8_asc_sht(struct SHEET *sht, int x, int y, int c, int b, char *s, int l)
{
    boxfill8(sht->buf, sht->bxsize, b, x, y, x + l * 8 - 1, y + 15);
    putfonts8_asc(sht->buf, sht->bxsize, x, y, c, s);
    sheet_refresh(sht, x, y, x + l * 8, y + 16);
    return;
}
/////////////////////////////////////////////////////////////////////////////////////
//功能：描绘文字输入背景的
//参数：
void make_textbox8(struct SHEET *sht, int x0, int y0, int sx, int sy, int c)
{
    int x1 = x0 + sx, y1 = y0 + sy;
    boxfill8(sht->buf, sht->bxsize, COL8_848484, x0 - 2, y0 - 3, x1 + 1, y0 - 3);
    boxfill8(sht->buf, sht->bxsize, COL8_848484, x0 - 3, y0 - 3, x0 - 3, y1 + 1);
    boxfill8(sht->buf, sht->bxsize, COL8_FFFFFF, x0 - 3, y1 + 2, x1 + 1, y1 + 2);
    boxfill8(sht->buf, sht->bxsize, COL8_FFFFFF, x1 + 2, y0 - 3, x1 + 2, y1 + 2);
    boxfill8(sht->buf, sht->bxsize, COL8_000000, x0 - 1, y0 - 2, x1 + 0, y0 - 2);
    boxfill8(sht->buf, sht->bxsize, COL8_000000, x0 - 2, y0 - 2, x0 - 2, y1 + 0);
    boxfill8(sht->buf, sht->bxsize, COL8_C6C6C6, x0 - 2, y1 + 1, x1 + 0, y1 + 1);
    boxfill8(sht->buf, sht->bxsize, COL8_C6C6C6, x1 + 1, y0 - 2, x1 + 1, y1 + 1);
    boxfill8(sht->buf, sht->bxsize, c,           x0 - 1, y0 - 1, x1 + 0, y1 + 0);
    return;
}
/////////////////////////////////////////////////////////////////////////////////////
//功能：任务b的函数
//参数：
//附加：这里所使用的变量名和HariMain里面一样的，不过别担心，计算机会把他们当成不同的变量来处理
//这里，在每个任务重，当farjmp返回的时候，我们都将定时器设定到0.02s之后，以便让程序在返回0.02s之后再次执行任务切换
void task_b_main(void)
{
    struct FIFO32 fifo;
    struct TIMER *timer_ts;
    int i,fifobuf[128],count=0;
    char s[11];
    struct SHEET *sht_back;
    sht_back=(struct SHEET *)*((int*)0x0fec);
    
    fifo32_init(&fifo,128,fifobuf);
    timer_ts=timer_alloc();
    timer_init(timer_ts,&fifo,1);
    timer_settime(timer_ts,2);
    
    for(;;){
        count++;
        sprintf(s,"%10d",count);
        putfonts8_asc_sht(sht_back,0,144,COL8_FFFFFF,COL8_008484,s,10);
        io_cli();
        if(fifo32_status(&fifo)==0){
            io_stihlt();
        }else{
            i=fifo32_get(&fifo);
            io_sti();
            if(i==1){//超时时间为5s
                farjmp(0,3*8);//返回任务A
                timer_settime(timer_ts,2);
            }
        }
    }
}

 

五、任务自动切换[12g]

>_<" 真正的多任务是程序本身不知道的情况下进行任务切换！这里直接创建一个mtask.c专门用来处理多任务

/* 任务管理相关程序 */

#include "bootpack.h"

struct TIMER *mt_timer;
int mt_tr;

/////////////////////////////////////////////////////////////////////////////////////
//功能：初始化mt_timer和mt_tr的值，并将计数器设定为0.02s，仅此而已
//参数：
//附加：变量mt_tr实际上代表了TR寄存器，而不需要timer_init是因为在超时的时候不需要向FIFO缓冲区写入数据
//接下来，mt_taskswitch函数的功能是按照当前的mt_tr变量的值计算下一个mt_tr的值，将计时器重新设定为0.02s之后并进行任务切换
void mt_init(void)
{
    mt_timer = timer_alloc();
    /* 这里没有必要使用timer_init */
    timer_settime(mt_timer, 2);
    mt_tr = 3 * 8;
    return;
}
/////////////////////////////////////////////////////////////////////////////////////
//功能：按照当前的mt_tr变量的值计算下一个mt_tr的值，将计时器重新设定为0.02s之后并进行任务切换
//参数：
void mt_taskswitch(void)
{
    if (mt_tr == 3 * 8) {
        mt_tr = 4 * 8;
    } else {
        mt_tr = 3 * 8;
    }
    timer_settime(mt_timer, 2);
    farjmp(0, mt_tr);
    return;
}

• mt_init函数是初始化mt_timer和mt_tr的值，并将计数器设置为0.02s之后，mt_tr代表TR寄存器，而不需要使用timer_init()是因为发生超时时不需要向FIFO写数据~

• mt_taskswitch是按照当前的mt_tr变量的值计算出下一个mt_tr的值，并设置计时器为0.02s,然后任务切换~

>_<" 这里就必须对timer.c里的定时器中断响应函数inthandler20进行响应的修改了：

void inthandler20(int *esp)
{
    char ts=0;//标记mt_timer任务切换计时器是否超时，如果直接在else语句直接调用任务切换会出现错误，因为这个中断处理还没完成
    struct TIMER *timer;
    io_out8(PIC0_OCW2, 0x60);    /* 把IRQ-00信号接受完了的信息通知给PIC */
    timerctl.count++;
    if (timerctl.next > timerctl.count) {//如果下一个还没计数完毕就直接返回
        return;
    }
    timer = timerctl.t0; //把最前面的地址赋址给timer
    for (;;) {
        if (timer->timeout > timerctl.count) {
            break;
        }//从前往后遍历，一旦发现有计时未完成的计时器就跳出循环
        /*除了上面的情况，都是定时已达的定时器*/
        timer->flags = TIMER_FLAGS_ALLOC;
        if(timer!=mt_timer){
            fifo32_put(timer->fifo, timer->data);
        }else{
            ts=1;/* mt_timer超时 */
        }
        timer = timer->next;//下一个定时器的地址赋址给timer
    }
    timerctl.t0 = timer;//新移位
    timerctl.next = timer->timeout;//timectl.next设定
    if(ts!=0){
        mt_taskswitch();
    }
    return;
}

• 如果发生超时的是mt_timer的话，不向FIFO写数据，而是置ts为1，最后根据这个标志看是否要进行任务切换~（这里一定不能直接在第20行进行任务切换，因为中断还没进行完毕~）

 

六、效果展示：

>_<" 这里每隔1s就显示一下累计的数据：7370035，下面一行是总的数据~

 

七、代码链接：

•  任务切换A->B链接12a：http://pan.baidu.com/s/1eQlDQ2u
•  任务切换AB互转链接12b：http://pan.baidu.com/s/1qWlZ4Qg
•  简单的多任务B数数链接12d：http://pan.baidu.com/s/1Gongy
•  简单的多任务优化提速链接12e:http://pan.baidu.com/s/1pJFhI8j
•  任务自动切换链接12g:http://pan.baidu.com/s/1ntHTGsp