可以在http://www.gnome.org/projects/dia上找到它的下载和screenshot。

这个软件基本上不需要学习，使用界面非常简单。

下面是示例图：

Dia对各类图形的支持是插件形式提供，很容易扩展。如果支持图形间超级链接就更好了。不过程序发生异常的情况较多，最严重的是有时候异常了原来的图形文件打不开。等到1.x版本出来的时候可能会好些吧。

第9课：系统调用和可执行程序    下载源代码

声明：转载请保留：

译者：http://www.cppblog.com/jinglexy

原作者：xiaoming.mo at skelix dot org

MSN & Email: jinglexy at yahoo dot com dot cn

目标

这一节中，我们来实现从磁盘加载应用程序并执行它，以及给这个应用程序系统调用的能力。

系统调用

经过前面一系列的课程，我们基本上建立了一个OS的各个简单组件，确实非常简单，没有什么复杂的算法和架构。现在再来实现一个简单的shell控制，一般的shell处理流程是：getty()打印登录提示符，等待用户login，然后执行bash。这里，我当然不想实现一个shell，也不想写什么getty。这一节中，skelix将从磁盘加载一个可执行程序并执行它，就像常用的*nix OS一样。

由于slelix的虚拟内存管理部分还没有做好，所有的任务共享同一个地址空间。我们采取一个简单的方法，程序从磁盘中加载到地址0x100000，放到"/"根目录下面。

要注意的是，用户任务不能访问内核地址空间，所以一些函数如kprintf, print_c等也不能再使用了（实际上是可以的，因为我们没有实现虚拟内存管理，这里先假定不能使用它们）。大多数的操作系统都提供了一些API或系统调用来执行这些函数。现在先添加一个系统调用：

09/isr.s

sys_print:
        pushl    %esi            # 背景颜色
        pushl    %edi            # 前景颜色
        pushl    %ebx            # 要打印的字符
        cli                      # 中断门会字节关掉EFLAGS 的IF位，系统调用却不行

        call    print_c
        sti
        addl    $12,    %esp
        ret

恨简单，不是吗？上面系统调用有三个参数，esi是背景颜色，edi是前景颜色，ebx是要打印的字符。这个系统调用只打印一个字符，起始就是用户程序对内核print_c函数的一个wrapper。

理论上说，用户任务不能直接使用print_c函数，也不应当知道有这个函数存在。唯一的方法就是使用系统调用，以此提供给用户一个可用的接口。DOS 操作系统提供了int 0x21作为系统服务，linux 提供int 0x80系统调用，本节中模仿linux在IDT 中添加一个号码0x80 的系统调用。
现在我们只用到了IDT 中断的34项，所以其余的项都可以拿来使用，但是我们只需要0x80已足够。在IDT中建立一个386 的陷阱门就行了，陷阱门和中断门非常类似，只是E 位的类型用8替代，并且DPL 特权级设置为3。

09/init.c

static void
sys_call_install(void) {
    unsigned long long sys_call_entry = 0x0000ef0000080000ULL

                             | ((unsigned long long)CODE_SEL<<16);
    sys_call_entry |= ((unsigned long long)sys_call<<32)

                             & 0xffff000000000000ULL;
    sys_call_entry |= ((unsigned long long)sys_call) & 0xffff;
    idt[SYS_CALL] = sys_call_entry;
}

宏SYS_CALL 值为0x80。

现在我们来看下0x80的陷阱门处理例程：
09/isr.s

sys_call:
        cmpl    $1,        %eax
        jb        1f
        iret
1:
        pushal
        call    *sys_call_table(, %eax, 4)
        popal
        iret

我尽量做到简单，虽然很多东西没有考虑周全，这样做可以降低学习成本。该例程判断系统调用号，即存储在eax中的值，然后查找函数表：sys_call_table。

函数表定义如下：
09/syscall.c

void (*sys_call_table[VALID_SYSCALL])(void) = {sys_print};

VALID_SYSCALL 宏定义为1, of course

系统调用测试函数
现在我们来做一个用户任务的系统调用测试函数：
09/color.c

void
color(void) {
    int i, j;
    for (i=0; i<16; ++i)
        for (j=0; j<16; ++j)
            __asm__ ("int    $0x80"::"S"(i),"D"(j),"b"('X'),"a"(0));
    for (;;)
        ;
}

按例，最简单实现。这个函数打印一些“X”字符，以不同的前景和背景颜色。还有一个问题，怎样把它存储在磁盘上呢，在没有shell的情况下（否则可以用cp来拷贝了）。解决的方法是另外写一个程序把程序直接写到磁盘上：实现一个ghex.c程序来把color可执行程序的内容打印出来，在内核里面再把可执行文件写到磁盘上。

Makefile也得修改一下：
09/Makefile

all: final.img color

color: color.o
    ${LD} --oformat binary -N -e color -Ttext 0x100000 -o color $<

上面的命令把color.o文件生成一个二进制可执行文件，入口点在color函数，代码段逻辑地址从0x100000开始。

（color.c由主机上的gcc编译器编译，ld链接）

现在把这些二进制数据（显示命令是：./ghex ../color）写到磁盘上：
09/fs.c

void
install_color(void) {
    struct SUPER_BLOCK sb;
    char sect[512] = {0};
    struct DIR_ENTRY *de = NULL;
    int inode = -1;
    struct INODE clnode;
    unsigned int blk = 0;
    unsigned char color[] =
{0x57,0x56,0x53,0x83,0xec,0x08,0xc7,0x44,0x24,0x04,0x00,0x00,
 0x00,0x00,0x83,0x7c,0x24,0x04,0x0f,0x7f,0x2e,0xc7,0x04,0x24,
 0x00,0x00,0x00,0x00,0x83,0x3c,0x24,0x0f,0x7f,0x19,0x8b,0x74,
 0x24,0x04,0x8b,0x3c,0x24,0xbb,0x58,0x00,0x00,0x00,0xb8,0x00,
 0x00,0x00,0x00,0xcd,0x80,0x89,0xe0,0xff,0x00,0xeb,0xe1,0x8d,
 0x44,0x24,0x04,0xff,0x00,0xeb,0xcb,0xeb,0xfe};

    sb.sb_start = *(unsigned int *)(HD0_ADDR);
    hd_rw(ABS_SUPER_BLK(sb), HD_READ, 1, sect);
    memcpy(&sb, sect, sizeof(struct SUPER_BLOCK));

    inode = alloc_inode(&sb);
    assert(inode > 0);
    blk = alloc_blk(&sb);
    assert(blk != 0);
    clnode.i_block[0] = blk;
    hd_rw(blk, HD_WRITE, 1, color);
    clnode.i_mode = FT_NML;
    clnode.i_size = sizeof color;
    iput(&sb, &clnode, inode);

    // 为color程序分配新的inode节点和块

    hd_rw(iroot.i_block[0], HD_READ, 1, sect);
    de = &((struct DIR_ENTRY *)sect)[2];
    strcpy(de->de_name, "color");
    de->de_inode = inode;
    hd_rw(iroot.i_block[0], HD_WRITE, 1, sect);

    // 把color程序放到根目录"/"下面

    iget(&sb, &iroot, 0);
    iroot.i_size = 3*sizeof(struct DIR_ENTRY);
    iput(&sb, &iroot, 0);
    // 搞定
}

// color程序已经写到磁盘上了，再把它加载到内存地址0x100000
09/fs.c

void
load_color(void) {
    struct INODE inode;
    struct SUPER_BLOCK sb;
    char sect[512] = {0};

    sb.sb_start = *(unsigned int *)(HD0_ADDR);
    hd_rw(ABS_SUPER_BLK(sb), HD_READ, 1, sect);
    memcpy(&sb, sect, sizeof(struct SUPER_BLOCK));
    iget(&sb, &inode, 1);

    /* 只是简单的把color加载到虚拟地址0x100000（也是物理地址0x100000） */
    hd_rw(inode.i_block[0], HD_READ, 1, (void *)0x100000);
}

还记得以前运行的task1_run 和task2_run这两个任务吗，它们只是做一些轮流在屏幕上打印字符的无聊工作。我们把task1换成执行磁盘中的color程序：
09/init.c

void
do_task1(void) {
    __asm__ ("incb 0xb8000+160*24+2");
    load_color();
    __asm__ ("jmp 0x100000");
}

最后在check_root()函数中添加一些安装函数：
09/fs.c

    if (! testb(sect, 0)) {
        kprintf(KPL_DUMP, "/ has not been created, creating....\t\t\t\t\t  ");
        if (alloc_inode(&sb) != 0) {
            kprintf(KPL_PANIC, "\n/ must be inode 0!!!\n");
            halt();
        }
        iroot.i_block[0] = alloc_blk(&sb);
        iput(&sb, &iroot, 0);
       
        hd_rw(iroot.i_block[0], HD_READ, 1, sect);
        de = (struct DIR_ENTRY *)sect;
        strcpy(de->de_name, ".");
        de->de_inode = 0;
        ++de;
        strcpy(de->de_name, "..");
        de->de_inode = -1;
        hd_rw(iroot.i_block[0], HD_WRITE, 1, sect);
        kprintf(KPL_DUMP, "[DONE]");
        if (iroot.i_size == 2*sizeof(struct DIR_ENTRY))
            install_color();
    }

编译，运行一下。如果一起正常的话，应该是color任务打印一系列的彩色字符。很有成就感吧：）

到此为止，这一系列的课程就结束了，大家可以继续深入下去，linux内核是一个值得学习的好kernel，

而且也有一些较好的书籍，如情景分析，ULK2，In A Nut Shell等。

学习是一件愉快的事情，当然也少不了挫折和煎熬。态度才是第一位，祝大家进步：）

                                    丁亥年四月廿四       于上海体育馆

                                    http://www.cppblog.com/jinglexy

                                    天衣有缝

第8课：内存管理    下载源代码

声明：转载请保留：

译者：http://www.cppblog.com/jinglexy

原作者：xiaoming.mo at skelix dot org

MSN & Email: jinglexy at yahoo dot com dot cn

目标

抱歉，其实还没有实现。在任务分配独立的4G地址空间上调试失败了，现在只使能了分页机制，页异常。大量的工作未实现，有兴趣的同学可以搜索buddy和slab的相关资料，经典的内存管理算法。

分页

386处理器的内存管理单元可以实现任务独立地址空间，任务间内存保护。每个任务可以拥有独立的4G虚拟地址空间。内存映射是内存管理很重要的一步，可以分为两部分：分段和分页。前面的课程中已经讨论过分段机制了，通过分段可以隔开不同的代码，数据，堆栈等；分页单元把虚拟地址映射成物理地址，还可以用来实现虚拟内存（和硬盘分区进行交换），现在我们来了解一下它。

对于每个任务，我们无法分配4G的物理内存，所以使用了一些机制来管理内存：及虚拟内存机制。该机制有处理器的分页部分来实现，首先我们将内存分成一些块，每个块大小为4k，通常我们称之为一个页帧。操作系统通过页目录和页表来管理这些页帧。页目录是相当于第一级页表，其中的每一项再管理一个下级页表。（更详细过程请参考intel的IA 32/64手册）

当分页机制开启时，处理器把任务中的虚拟地址转换成物理地址，步骤如下：
1.查找段选择子在GDT 或 LDT 中的描述符，做一些权限检查，看看能否访问

2.以描述符中的基址相加页目录基址得到一个线性地址

3.在页表中索引虚拟地址所对应的页表项，得到页地址

4.查找偏移得到实际物理地址。

如果实际物理页不存在（可能交换到硬盘中去了），则引发异常，可以在这个异常里面做想要做的事情（加载硬盘中的交换页，或者kill这个程序：Segment Fault，等等）

处理器使用的页目录或者页表，都是由32 位的项组成：

页目录项：

 31                    12    11    9    876   5   43    2     1     0

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓

┃   指向页表的物理地址  ┃ 用户定义 ┃  X  ┃ A┃ X ┃ U/S┃ R/W┃ P ┃

┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛

页表项：

 31                    12    11    9   87  6  5   43    2     1     0

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓

┃   指向页帧的物理地址  ┃ 用户定义 ┃ X┃D┃ A┃ X ┃ U/S┃ R/W┃ P ┃

┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛

从上面可以知道，页目录项和页表项的结构很类似，下面逐个说明一下其中的域：

页目录的每一项：即页表的物理地址，它的高20 位地址表示有个页帧的起始地址，正好和4k对齐。2^20可以表示1M范围，每个页帧大小是4k，所以可以索引1M * 4K地址空间。页目录项中还有一个D 位，它用来表示一个页帧是否已修改，linux用它来表示一个页面释放是脏页面，这个位非常有用，当一个页帧交换到硬盘上后，如果该页帧还没有被修改，而且是已经从硬盘交换出来的，则简单取消以后的交换。

为了将逻辑地址转换成物理地址，逻辑地址被分成3 部分：

举例来说，我们有一个逻辑地址：0x3E837B0A。前提条件：CR3寄存器指向的页目录地址是 0x0005C000，这个寄存器存储了当前页目录所使用的页帧的物理地址，通常也叫做 PDBR。

先取它的高10位， 就是0x0FA，由它可以索引到页目录的第0x0FA项，我们取得这一项的值，假设得到的地址值是0x0003F000。然后我们取虚拟地址的中间10位，就是0x037，再取出0x0003F000指向页帧的第0x037项的值，假设是0x0001B000。这个地址就是我们要找的虚拟地址对应的物理地址的页帧的起始地址，最后加上偏移值（低12位），即0xB0A，得到实际的物理地址是：0x0001BB0A。

相关的知识可以参考 Intel 的IA 32/64手册。

CR3寄存器必须在分页机制开启前就装载好，可以使用MOV 指令或者在任务切换时使用TSS中的CR3域的值。当处理器访问不存在的页帧时，发生一个异常，CR2 寄存器存引发异常的逻辑地址，同时错误码也会压入到堆栈中，错误码格式如下：

 31                                                 3   2     1     0

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓

┃                    未使用                         ┃ U/S┃ R/W┃ P ┃

┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛

异常处理例程通常采取如下的步骤：

查找一个空闲的页帧或从硬盘中将页帧交换出来，重新设置正确的页目录项或页表项的值，刷新TLB。处理器通常保存最近最多访问的页目录或页表项到一个cache中，以避免每次都进行虚拟地址到物理地址的转换，这个cache就叫做TLB。只有我们改动了页目录或页表项，就应当刷新TLB。方法很简单，就是重新加载CR3 寄存器。

现在我们来看看代码段，内存管理通常少不了大量的宏定义：

08/include/kernel.h

#define PAGE_DIR    ((HD0_ADDR+HD0_SIZE+(4*1024)-1) & 0xfffff000)

物理内存安排：IDT（在0x40000），接下来是GDT，接下来是HD0使用，然后才是页目录，

所以这个宏看起来有点长。

08/include/mm.h
#define PAGE_SIZE    (4*1024)                    /* 页帧粒度 */
#define PAGE_TABLE    (PAGE_DIR+PAGE_SIZE)       /* 页表物理地址 */
#define MEMORY_RANGE (4*1024)                    /* skelix只管理4M 内存暂时 */

08/mm.c

/* 物理内存使用情况的位图表 */

static char mmap[MEMORY_RANGE/PAGE_SIZE] = {PG_REVERSED, };

void
mm_install(void) {
    unsigned int *page_dir = ((unsigned int *)PAGE_DIR);
    unsigned int *page_table = ((unsigned int *)PAGE_TABLE);
    unsigned int address = 0;
    int i;
    for(i=0; i<MEMORY_RANGE/PAGE_SIZE; ++i) {
        /* 页表项属性设置为: kernel, r/w, present */
        page_table[i] = address|7;
        address += PAGE_SIZE;
    };

    // 上面循环初始化了0~4M对应的所有页表项

    page_dir[0] = (PAGE_TABLE|7);

    // 页目录项只需要第一个就可以了，因为只有4M内存

    for (i=1; i<1024; ++i)
        page_dir[i] = 6;

    // 其他的1023个页目录项设置为空，如果这1024项都设置，可访问4G内存空间

    // 设置0～1M内存为已使用。
    for (i=(1*1024*1024)/PAGE_SIZE-1; i>=0; --i)
        mmap[i] = PG_REVERSED;

    // 因为内核只用到了低于1M的内存，所以保留它们，这样就不会被交换出去了

    __asm__ (
        "movl    %%eax,    %%cr3\n\t"        // 加载页目录基址到寄存器
        "movl    %%cr0,    %%eax\n\t"
        "orl    $0x80000000,    %%eax\n\t"
        "movl    %%eax,    %%cr0"::"a"(PAGE_DIR));    // 开启分页机制，CR0的最高位
}

通过mmap位图，我们可以清楚的知道内存的使用情况，这样就可以分配空闲页帧了，如下：
08/mm.c

unsigned int
alloc_page(int type) {
    int i;

    for (i=(sizeof mmap)-1; i>=0 && mmap[i]; --i)
        ;

    if (i < 0) {
        kprintf(KPL_PANIC, "NO MEMORY LEFT");
        halt();
    }
    mmap[i] = type;
    return i;            // 返回页帧号
}

void *
page2mem(unsigned int nr) {            // 转换为虚拟地址
    return (void *)(nr * PAGE_SIZE);
}

void
do_page_fault(enum KP_LEVEL kl,
              unsigned int ret_ip, unsigned int ss, unsigned int gs,
              unsigned int fs, unsigned int es, unsigned int ds,
              unsigned int edi, unsigned int esi, unsigned int ebp,
              unsigned int esp, unsigned int ebx, unsigned int edx,
              unsigned int ecx, unsigned int eax, unsigned int isr_nr,
              unsigned int err, unsigned int eip, unsigned int cs,
              unsigned int eflags,unsigned int old_esp, unsigned int old_ss) {
    unsigned int cr2, cr3;
    (void)ret_ip; (void)ss; (void)gs; (void)fs; (void)es;
    (void)ds; (void)edi; (void)esi; (void)ebp; (void)esp;
    (void) ebx; (void)edx; (void)ecx; (void)eax;
    (void)isr_nr; (void)eip; (void)cs; (void)eflags;
    (void)old_esp; (void)old_ss; (void)kl;
    __asm__ ("movl %%cr2, %%eax":"=a"(cr2));
    __asm__ ("movl %%cr3, %%eax":"=a"(cr3));
    kprintf(KPL_PANIC, "\n  The fault at %x cr3:%x was caused by a %s. "
            "The accessing cause of the fault was a %s, when the "
            "processor was executing in %s mode, page %x is free\n",
            cr2, cr3,
            (err&0x1)?"page-level protection voilation":"not-present page",
            (err&0x2)?"write":"read",
            (err&0x4)?"user":"supervisor",
            alloc_page(PG_NORMAL));
}

页异常函数，它什么也没有做，知识显示一些错误信息。

现在我们来动态的分配一些内存，我们修改一下任务函数：
08/init.c

static void
new_task(unsigned int eip) {
    struct TASK_STRUCT *task = page2mem(alloc_page(PG_TASK));
    memcpy(&(task->tss), &(TASK0.tss), sizeof(struct TSS_STRUCT));

    task->tss.esp0 = (unsigned int)task + PAGE_SIZE;
    task->tss.eip = eip;
    task->tss.eflags = 0x3202;
    task->tss.esp = (unsigned int)page2mem(alloc_page(PG_TASK))+PAGE_SIZE;
    task->tss.cr3 = PAGE_DIR;
    task->priority = INITIAL_PRIO;
    task->ldt[0] = DEFAULT_LDT_CODE;
    task->ldt[1] = DEFAULT_LDT_DATA;

    task->next = current->next;
    current->next = task;
    task->state = TS_RUNABLE;
}

自己分配的任务数据结构和任务堆栈，是不是很有成就感：）

最后在init.c中添加初始化代码：
08/init.c

void
init(void) {
    char wheel[] = {'\\', '|', '/', '-'};
    int i = 0;

    idt_install();
    pic_install();
    mm_install();      /* 初始化函数调用 */
    kb_install();
    timer_install(100);
    set_tss((unsigned long long)&TASK0.tss);
    set_ldt((unsigned long long)&TASK0.ldt);
    __asm__ ("ltrw    %%ax\n\t"::"a"(TSS_SEL));
    __asm__ ("lldt    %%ax\n\t"::"a"(LDT_SEL));

    kprintf(KPL_DUMP, "Verifing disk partition table....\n");
    verify_DPT();
    kprintf(KPL_DUMP, "Verifing file systes....\n");
    verify_fs();
    kprintf(KPL_DUMP, "Checking / directory....\n");
    verify_dir();

    sti();
    new_task((unsigned int)task1_run);
    new_task((unsigned int)task2_run);
    __asm__ ("movl %%esp,%%eax\n\t" \
             "pushl %%ecx\n\t" \
             "pushl %%eax\n\t" \
             "pushfl\n\t" \
             "pushl %%ebx\n\t" \
             "pushl $1f\n\t" \
             "iret\n" \
             "1:\tmovw %%cx,%%ds\n\t" \
             "movw %%cx,%%es\n\t" \
             "movw %%cx,%%fs\n\t" \
             "movw %%cx,%%gs" \
             ::"b"(USER_CODE_SEL),"c"(USER_DATA_SEL));
    __asm__ ("incb 0xeeffeeff");         /*