可以在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");         /* 测试：触发一个异常 */
    for (;;) {
        __asm__ ("movb    %%al,    0xb8000+160*24"::"a"(wheel[i]));
        if (i == sizeof wheel)
            i = 0;
        else
            ++i;
    }
}

异常处理例程中什么也没做，访问内存出错则死机：

08/exceptions.c

void
page_fault(void) {
    __asm__ ("pushl    %%eax;call    do_page_fault"::"a"(KPL_PANIC));
    halt();
}

最后把mm.o 添加到 Makefile 的KERNEL_OBJS 中去：

08/Makefile

KERNEL_OBJS= load.o init.o isr.o timer.o libcc.o scr.o kb.o task.o kprintf.o hd.o exceptions.o fs.o mm.o

一、solaris 内核及应用程序源程序：

http://src.opensolaris.org/source          主页

http://src.opensolaris.org/source/xref/onnv/onnv-gate/usr/src/cmd/ls/ls.c   范例：ls源程序

二、比较多的gcc资料

http://gcc.cookys.org/

三、linux内核交叉引用，从0.1到1.0，2.0，2.2，2.4，2.6.20都有

http://lxr.linux.no/source/

http://www.oldlinux.org/lxr/http/source/

四、C 语言常见问题集(中英文)

http://c-faq-chn.sourceforge.net/

http://c-faq.com/

五、操作系统相关的一些资料，包括linux源程序分析

http://osdev.gro.clinux.org

六、linus自传

http://www.bookcool.com/online/zhuanji/happyking-gb/0/content.htm

七、嵌入式及OS开发资料（英文）

http://my.execpc.com/~geezer/

八、Testing and debugging KOS（英文）

http://kos.enix.org/~d2/snapshots/kos_current/doc/testingen-html

九、the Single UNIX Specification Version 3（推荐：可作为posix的替代参考资料）

http://www.unix.org/single_unix_specification

十、OS设计参考（英文）

http://www.nondot.org/~sabre/os/articles

声明：转载请保留：

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

原作者：xiaoming.mo at skelix dot org

目标            下载源程序

这节课我们讲述的内容与操作系统暂无太大关系，但是这些基础函数非常重要，并且在后面的课程中经常用到。这就是我们经常听到的内核库。如果你对这些不是很感兴趣，知道kprintf象c语言里面的print一样工作就行了。简单掠过即可。

C用户库里面的printf具有高度可伸缩性，也很容易理解，相比之下C＋＋中的IO运算符就比较难了。为了在屏幕上显示字符串或数据，我们现在需要实现类似C库中的printf，显示字符在B8000开始的显存处。我并不像完全实现printf的所有功能，因为skelix内核只需要显示字符串，十进制和十六进制或二进制，正整数，字符就行了，并且需要支持可变参数。其他更高级的功能我们不会用到。

这里有一种方法来实现，我们直到象func(int arg1, int arg2, int arg3)这样一个函数被调用时，它汇编后的指令应该如下（所有从左向右入栈的编译器应该从地球上彻底消失）：
pushl   arg3
pushl   arg2
pushl   arg1
call    func

我们看到，参数从右向左一个个入栈，参数越多，入栈越深。如果是可变参数那我们怎么知道有多少个参数呢？答案是printf格式化字符串中参数判断：有多少个%X，就有多少个参数要解析。在32位模式下，所有小于4字节的参数都被当作4字节处理。例如一个char型参数，入栈时就是int型了，所以在解析参数时务必保证正确。

我们这样设计kprintf参数：kprintf(color, format string, arguments...)

第一个参数定义输出的前景/背景颜色。我们定义了很多宏来解析栈，如果你熟悉C语言应该很容易理解它们。

03/kprintf.c

#define args_list char *            // 这个宏用例转换栈空间为字符串指针
#define _arg_stack_size(type)    (((sizeof(type)-1)/sizeof(int)+1)*sizeof(int))

                                    // 这个宏四舍五入参数大小为4字节的倍数
#define args_start(ap, fmt) do {    \
ap = (char *)((unsigned int)&fmt + _arg_stack_size(&fmt));   \
} while (0)

                                    // 参数将从格式化字符串后面开始解析，即fmt就是栈顶，上面这个宏就是取参数的首地址

#define args_end(ap)                // 到现在为止，什么也不做
#define args_next(ap, type) (((type *)(ap+=_arg_stack_size(type)))[-1])

                                    // 取‘当前’参数地址，然后设置指针为下一个参数地址，暧昧的函数名！

03/kprintf.c

static char buf[1024] = {-1};       // 注意没有锁保护，引用该变量的函数不可重入！
static int ptr = -1;

下面两个函数解析值为指定的进制数：
static void
parse_num(unsigned int value, unsigned int base) {            // 可以打印小于等于10进制的数
    unsigned int n = value / base;
    int r = value % base;
    if (r < 0) {
        r += base;
        --n;
    }
    if (value >= base)
        parse_num(n, base);
    buf[ptr++] = (r+'0');
}

static void                                                   // 打印16进制数
parse_hex(unsigned int value) {
    int i = 8;
    while (i-- > 0) {
        buf[ptr++] = "0123456789abcdef"[(value>>(i*4))&0xf];
    }
}

现在我们来看一下 kprintf这个函数，它支持的格式：%s, %c, %x, %d, %%
void
kprintf(enum KP_LEVEL kl, const char *fmt, ...) {
    int i = 0;
    char *s;
    /* must be the same size as enum KP_LEVEL */
    struct KPC_STRUCT {
        COLOUR fg;
        COLOUR bg;
    } KPL[] = {
        {BRIGHT_WHITE, BLACK},
        {YELLOW, RED},
    };

enum KP_LEVEL {KPL_DUMP, KPL_PANIC} 定义在 include/kprintf.h, 它表示两种输出方案, KPL_DUMP 使用黑色背景白色前景显示字符，KPL_PANIC 使用黄色前景和红色背景。颜色常量定义在 include/scr.h, 后面会介绍到.

    args_list args;
    args_start(args, fmt);

    ptr = 0;

    for (; fmt[i]; ++i) {
        if ((fmt[i]!='%') && (fmt[i]!='\\')) {
            buf[ptr++] = fmt[i];
            continue;
        } else if (fmt[i] == '\\') {
            /* \a \b \t \n \v \f \r \\ */
            switch (fmt[++i]) {
            case 'a': buf[ptr++] = '\a'; break;
            case 'b': buf[ptr++] = '\b'; break;
            case 't': buf[ptr++] = '\t'; break;
            case 'n': buf[ptr++] = '\n'; break;
            case 'r': buf[ptr++] = '\r'; break;
            case '\\':buf[ptr++] = '\\'; break;
            }
            continue;
        }

        /* 下面是支持的打印格式 */
        switch (fmt[++i]) {
        case 's':
            s = (char *)args_next(args, char *);
            while (*s)
                buf[ptr++] = *s++;
            break;
        case 'c':
            buf[ptr++] = (char)args_next(args, int);
            break;
        case 'x':
            parse_hex((unsigned long)args_next(args, unsigned long));
            break;
        case 'd':
            parse_num((unsigned long)args_next(args, unsigned long), 10);
            break;
        case '%':
            buf[ptr++] = '%';
            break;
        default:
            buf[ptr++] = fmt[i];
            break;
        }
    }
    buf[ptr] = '\0';
    args_end(args);
    for (i=0; i<ptr; ++i)
        print_c(buf[i], KPL[kl].fg, KPL[kl].bg);            /* print_c() 是下层的显示函数，本文后面会有讲解 */

}

由于是内核程序，我们无法使用C用户库。所以一下memcpy，memset，memcpy函数需要自己实现，但是需要注意的是在BSD系统中，即便使用了-nostdlib，编译器仍然会产生System V中相关的memcpy等代码，具体情况我也不是很清除。这些函数的效率当然无法和linux内核中的内嵌汇编相比！我们暂时这样实现它们吧。
03/libcc.c

/* 下面函数对重叠区域也进行了处理 */
void
bcopy(const void *src, void *dest, unsigned int n) {
    const char *s = (const char *)src;
    char *d = (char *)dest;
    if (s <= d)
        for (; n>0; --n)
            d[n-1] = s[n-1];
    else
        for (; n>0; --n)
            *d++ = *s++;
}

void
bzero(void *dest, unsigned int n) {
    memset(dest, 0, n);
}

void *
memcpy(void *dest, const void *src, unsigned int n) {
    bcopy(src, dest, n);
    return dest;
}

void *
memset(void *dest, int c, unsigned int n) {
    char *d = (char *)dest;
    for (; n>0; --n)
        *d++ = (char)c;
    return dest;
}

int
memcmp(const void *s1, const void *s2, unsigned int n) {
    const char *s3 = (const char *)s1;
    const char *s4 = (const char *)s2;
    for (; n>0; --n) {
        if (*s3 > *s4)
            return 1;
        else if (*s3 < *s4)
            return -1;
        ++s3;
        ++s4;
    }
    return 0;
}

int
strcmp(const char *s1, const char *s2) {
    while (*s1 && *s2) {
        int r = *s1++ - *s2++;
        if (r)
            return r;
    }
    if (*s1 == *s2)
        return 0
    else
        return (*s1)?1:-1;
}

char *
strcpy(char *dest, const char *src) {
    char *p = dest;
    while ( (*dest++ = *src++))
        ;
    *dest = 0;
    return p;
}

unsigned int
strlen(const char *s) {
    unsigned int n = 0;
    while (*s++)
        ++n;
    return n;
}

print_c函数
直接操作显存区域一点也不方便，所以我们需要一个显示模块。这个就是我们的‘显卡驱动’了，是不是不敢相信驱动是这么简单的事情？我们先来看一下一些常量定义：
03/include/scr.h

#define MAX_LINES    25                // bios默认设置屏幕为 80x25大小，彩色字符模式
#define MAX_COLUMNS  80
#define TAB_WIDTH    8                 // 必须是：2^n
#define VIDEO_RAM    0xb8000           // 显存地址

我们曾简要提到过这个地址，在字符模式下，适配器使用0xB8000-0xBF000作为视频内存。通常我们处于80x25大小屏幕，有16种颜色。由于一个屏幕只需要80x25x2个字节，即4k，所以该视频内存可以分为多个页。我们使用所有的页，但是当前只能有一个页面可见。为了显示一个字符，将用到2个字节，一个字节是字符值，另一个字节是字符属性（即颜色）。属性字节定义如下：

To display a single character, two bytes are being used which called the character byte and the attribute byte. The character byte contains the value of the character. The attribute byte is defined like this:

#define LINE_RAM    (MAX_COLUMNS*2)
#define PAGE_RAM    (MAX_LINE*MAX_COLUMNS)

#define BLANK_CHAR    (' ')
#define BLANK_ATTR    (0x70)        /* 白色前景，黑色背景 */

#define CHAR_OFF(x,y)    (LINE_RAM*(y)+2*(x))        /* 计算给定坐标x，y的偏移地址（相对0xB8000） */
Calculates the offset of a given ordinary x, y from 0xB8000

typedef enum COLOUR_TAG {                            /* 颜色表 */
    BLACK, BLUE, GREEN, CYAN, RED, MAGENTA, BROWN, WHITE,
    GRAY, LIGHT_BLUE, LIGHT_GREEN, LIGHT_CYAN,
    LIGHT_RED, LIGHT_MAGENTA, YELLOW, BRIGHT_WHITE
} COLOUR;

坐标系如下：

  ___________________\

 | （0，0）          /

 |

\|/

03/scr.c

static int csr_x = 0;
static int csr_y = 0;

由于我们只用到了一个视频页，所以上面两个变量就可以存储坐标了。关于多页显示可以在网络上查找相关资料。

static void
scroll(int lines) {        向上滚动屏幕多少行，就是一些内存复写。
    short *p = (short *)(VIDEO_RAM+CHAR_OFF(MAX_COLUMNS-1, MAX_LINES-1));
    int i = MAX_COLUMNS-1;
    memcpy((void *)VIDEO_RAM, (void *)(VIDEO_RAM+LINE_RAM*lines),
           LINE_RAM*(MAX_LINES-lines));

    for (; i>=0; --i)            // 说明这个for循环有问题，觉得应该改成下面这样：

    // for (i = i * lines; i>=0; --i)

        *p-- = (short)((BLANK_ATTR<<4)|BLANK_CHAR);

}

下面函数设置光标可能会引发竞态条件，但是print_c只准备在内核中使用，所以没有关中断。它可能会引起一些bug，但是我没有找到。译注：全局变量没有锁保护在设计上就是一种错误。这里的代码保护确实是没有做！读者应用到自己的内核时要小心了。

void
set_cursor(int x, int y) {

    csr_x = x;

    csr_y = y;

    outb(0x0e, 0x3d4);                                   设置光标高8位的准备工作

    outb(((csr_x+csr_y*MAX_COLUMNS)>>8)&0xff, 0x3d5);    设置光标高8位

    outb(0x0f, 0x3d4);                                   设置光标低8位的准备工作
    outb(((csr_x+csr_y*MAX_COLUMNS))&0xff, 0x3d5);       设置光标低8位   
}

void
get_cursor(int *x, int *y) {
    *x = csr_x;
    *y = csr_y;
}

void
print_c(char c, COLOUR fg, COLOUR bg) {

// 用这个函数来显示一个具体的字符到屏幕，我们可以把它看作‘显卡驱动’
    char *p;
    char attr;

    p = (char *)VIDEO_RAM+CHAR_OFF(csr_x, csr_y);        // 取光标位置
    attr = (char)(bg<<4|fg);                             // 属性

    switch (c) {
    case '\r':
        csr_x = 0;
        break;
    case '\n':
        for (; csr_x<MAX_COLUMNS; ++csr_x) {
            *p++ = BLANK_CHAR;
            *p++ = attr;
        }
        break;
    case '\t':
        c = csr_x+TAB_WIDTH-(csr_x&(TAB_WIDTH-1));
        c = c<MAX_COLUMNS?c:MAX_COLUMNS;
        for (; csr_x<c; ++csr_x) {
            *p++ = BLANK_CHAR;
            *p++ = attr;
        }
        break;
    case '\b':
        if ((! csr_x) && (! csr_y))
            return;
        if (! csr_x) {
            csr_x = MAX_COLUMNS - 1;
            --csr_y;
        } else
            --csr_x;
        ((short *)p)[-1] = (short)((BLANK_ATTR<<4)|BLANK_CHAR);
        break;
    default:
        *p++ = c;
        *p++ = attr;
        ++csr_x;
        break;
    }
    if (csr_x >= MAX_COLUMNS) {
        csr_x = 0;
        if (csr_y < MAX_LINES-1)
            ++csr_y;
        else
            scroll(1);
    }
    set_cursor(csr_x, csr_y);        // 设置光标位置
}

函数比较简单，没有分析的必要了，大家自己琢磨吧。

声明：转载请保留：

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

原作者：xiaoming.mo at skelix dot org

目标：使"system"从软盘启动，并打印"Hello World!" 下载源程序

内存寻址

处理器以‘字节’管理和访问内存，每个字节都有独立的地址，即物理地址。有两种地址映射方式：分段和分页，skelix内核中都用到了。

段对于我们来说再熟悉不过了，先回顾一下dos时期的段吧。它是一个16位的寄存器，所以最多可以直接访问2^16字节的内存，即64K。这对应用程序来说太少了，于是Intel使用Segment:Offset结合方式来表示一个虚拟地址。段寄存器左移4位加上偏移就得到实际的物理地址了。例如，0x7c00:0x0189表示物理地址0x7c189，而不是0x7c000189。计算过程如下：

 7C000
+ 0189
-------
 7C189

现在我们来计算最大可以访问的地址：FFFF:FFFF

 FFFF0
+ FFFF
-------
10FFEF

这个范围是1M + 65519 bytes, 因为在80386中使用了20位地址线，所以可以额外多访问65519个字节虚拟地址，例如地址0x100010被映射到地址0x10，访问这两个地址是等价的。

表示同一个物理地址有多种方式，例如07C0:0000和0000:7C00 就是一样的。

另一个概念是线性地址，这个是32位地址，只有当分页机制开启时才有效，文章后面会提到它。

引导过程

当系统上电或RESET时，处理器将执行一些列的初始化，寄存器被设置成非预知状态，并且cpu处于实模式。也许你想知道cpu是怎样设置segment:offset为物理地址FFFF0的（0xf000:0xfff0就是bios入口地址），这是因为cs寄存器有一个非可见部分，它保存了ffff:0000地址，并且cs在初始化时会被装入f000值。此后以正常方式使用它。当bois取得控制权后，根据用户配置（从软驱，硬盘，或cdrom）中读取第一个sector到00007C00，并跳转到该地址执行（就是引导程序bootstrap）。在bootstrap中我们可以使用bios中断，但是进入kernel后就不能再使用了。

程序一：使用as和ld的范例

你可以在下载源程序的01/first.cry/bootsect.s

        .text              .text表示代码段
        .globl             start表示start可以用作外部符号
        .code16            GCC默认使用32位地址和操作数，这里告诉它使用16位
start:
        jmp      start     死循环

.org    0x1fe,   0x90      .org NEW-LC, FILL，说明：这里填充0x90，是nop指令的机器码
.word   0xaa55

讲解：.org指令指示下一个数据地址，为了编译这个程序，我们写了一个Makefile，总不能老是敲命令吧，呵呵。

网络上可以找到很多写Makefile的资料，编译选项才是我们关注的焦点。

01/first.cry/Makefile

AS=as                     gcc汇编工具
LD=ld                     gcc连接器

.s.o:
    ${AS} -a $< -o $*.o >$*.map

all: final.img

final.img: bootsect
    mv bootsect final.img

bootsect: bootsect.o
    ${LD} --oformat binary -N -e start -Ttext 0x7c00 -o bootsect $<

讲解：ld可以被配置为支持多于一种的目标文件. binary表示没有程序头和其他信息，仅仅是一些裸数据。如果没有这个选项，将被默认链接为elf格式。-N把text和data节设置为可读写。-Ttext将text节起始地址设置为0x7c00（在jmp和数据引用等重定位链接时会用到这个参考值），所有的引用地址都是在7c00这个地址上加出来的。-e选项指定程序入口点

现在我们运行make指令编译一下：

[root@root~/source/os/skelix/01/first.cry]$ ls
bootsect.s  COPYING  Makefile
[root@root~/source/os/skelix/01/first.cry]$ make
as -a bootsect.s -o bootsect.o >bootsect.map
ld --oformat binary -N -e start -Ttext 0x7c00 -o bootsect bootsect.o
mv bootsect final.img
[root@root~/source/os/skelix/01/first.cry]$ ls
bootsect.map  bootsect.o  bootsect.s  COPYING  final.img  Makefile
[root@root~/source/os/skelix/01/first.cry]$

现在，我们启动vmware，运行，载入软驱映象文件"final.img"，我们得到一个黑屏，这是正确的，因为我们什么也没有做。

程序一：显示 Hello World!

好了，上面的黑屏程序并不是太好玩，现在我们尝试在上面打印"Hello World!"

01/hello.world/bootsect.s

        .text
        .globl  start
        .code16
start:
        jmp     code
msg:                                   使用jmp指令跳过该变量，这是我们为什么在Makefile使用-N链接选项了
        .string "Hello World!\x0"
code:
        movw    $0xb800,%ax
        movw    %ax,    %es            es段设置成B800，如前所述，segment:offset地址映射方式，它指向B8000，

                                       这意味着第一个字节地址是0（映射到B8000），属性字节是1（映射到B8001）

                                       B8001值设置为0x07可以将这个byte颜色设置为黑底白字。
        xorw    %ax,    %ax
        movw    %ax,    %ds

        movw    $msg,   %si            为movsb指令设置正确的si和di
        xorw    %di,    %di
        cld
        movb    $0x07,  %al            字的颜色

1:
        cmp     $0,    (%si)
        je      1f   
        movsb
        stosb
        jmp     1b
1:      jmp     1b

.org    0x1fe,  0x90
.word   0xaa55

声明：转载请保留：

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

原作者：xiaoming.mo at skelix dot org

MSN & Email: jinglexy at yahoo dot com dot cn

GCC
Skelix 使用c语言编写，当然也用了汇编语言（at&t风格），在linux下使用gcc编译。

[root@root ~]$ gcc -v
Reading specs from /usr/lib/gcc/i386-redhat-linux/3.4.2/specs
Configured with: ../configure --prefix=/usr --mandir=/usr/share/man --infodir=/usr/share/info --enable-shared --enable-threads=posix --disable-checking --with-system-zlib --enable-__cxa_atexit --disable-libunwind-exceptions --enable-java-awt=gtk --host=i386-redhat-linux
Thread model: posix
gcc version 3.4.2 20041017 (Red Hat 3.4.2-6.fc3)

在每篇教程中都给出了源程序和软盘映象文件，你可以直接使用它们。如果你需要编译这些源程序，编译环境必须正确。我们推荐的环境是linux2.6.x内核，gcc3.x编译器。

由于在源程序中使用了__asm__, __attribute__, __extention__，以及gcc内嵌汇编，还有unsigned long long(直到C99才开始支持)；如果你使用了其他编译器，需要修改对应的源程序。且编译器必须是32位，这样做的目的是保持源程序简洁清晰。

对于windows用户可以使用 cygwin，它提供了windows下的linux环境。不过我没有尝试使用它，因为我的电脑上没有安装windows操作系统。也可以在你的windows系统上安装一个虚拟机上的linux，如果你的电脑足够快的话。

VMWARE

为了运行教程中的范例，一个虚拟机必不可少，virtual pc2007已经可以免费使用了，在M$的官方网站上可以找到下载。当然也可以使用qemu和bochs之类的虚拟机。推荐的虚拟机是VMWARE。

Things Are Good To Know

如果能看懂Makefile最好了，这是*nix程序员必须掌握的一项基本知识。另外，如果你熟悉内存地址映射，中断，异常，GDT，LDT，IDT，分页机制，范围端口就更好了。当然不懂也没关系，Intel的三卷手册是案头必备：http://www.intel.com

IA-32 Intel Architecture Software Developer's Manual Volume1: Basic Architecture
IA-32 Intel Architecture Software Developer's Manual Volume2A: Instruction Set Reference: A-M
IA-32 Intel Architecture Software Developer's Manual Volume2B: Instruction Set Reference: N-Z
IA-32 Intel Architecture Software Developer's Manual Volume3A: System Programming Guide Part1
IA-32 Intel Architecture Software Developer's Manual Volume3B: System Programming Guide Part2

读者对这些东西不必紧张，我在教程中会解释相关的知识。c语言和汇编是最基本的要求，能够很清楚的了解什么是堆和栈。关于c语言的数据成千上万，但是保护模式方面的书籍比哈雷慧星还少，据说每76年可以买到一本，如果你足够幸运的话：）

风格约定

原文中的格式被擅自去掉了，翻译后的风格应该可以一看就懂。

  which: 只在PATH环境变量中寻找文件

  whereis: 在系统定义的目录中寻找

2.根据关键字查找man页

  举例：apropos split  或者  man -k split

3.sed示例：

  sed -e s/root/toor/g /etc/passwd > ~/test.out         替换 /etc/passwd中的root为toor输出到~/test.out

  sed -e 's/root/toor/g; s/ftp/ptf/g' /etc/passwd       使用 -e 指定多个命令

  sed -e 's/root/toor/g' -e ' s/ftp/ptf/g' /etc/passwd  同上

  使用命令文件：

  /* test.sed 开始，不包含本行 */

  s/root/toor/g
  s/ftp/ptf/g

  /* test.sed 结束，不包含本行 */

  指令：sed -f test.sed /etc/passwd

4.awk示例：

  awk '{print $0}' /etc/passwd                          $0表示完整的输入记录

  awk -F":" '{print $1}' /etc/passwd                    打印第一列，以：为分隔符

  awk -F":" '{print "username: "$1 "\t\t\t user id: "$3}' /etc/passwd        格式化并打印

  使用命令文件：

  /* test.awk 开始，不包含本行 */

  BEGIN{
        FS=":"
  }
  {printf "username: "$1 "\t\t\t user id: "$3"\n"}
  END{
        printf "all done processing /etc/passwd\n"
  }

  /* test.awk 结束，不包含本行 */

  指令：awk -f test.awk /etc/passwd

5.shell脚本

  1)特殊变量：

      ?前一个命令输出状态

      0当前脚本名

      1~9参数

  2)范例1，使用if语句

    #!/bin/bash

    echo "guest the select color"
    read COLOR

    if [ $COLOR = "yellow" ] 
    then
            echo "you are correct"
    elif [ $COLOR = "blue" ]
    then
            echo "you are correct also"
    fi

  3)范例2，使用case语句

    #!/bin/bash

    case "$1" in
        start)
                echo "start......"
                ;; 
        stop)
                echo "stop......"
                ;; 
        status)
                echo "status......"
                ;; 
        *) 
                echo "usage: $0 {start | stop | status}"
                ;;  
    esac

  4)范例3，使用迭代流程

    #!/bin/bash

    echo "guest color: red, blue or orange\n"
    read COLOR

    while [ $COLOR != "orange" ]
    do
            echo "incorrect, try again"
            read COLOR
    done

    echo "correct"

  5)使用双引号进行命令替换

    lines="$(wc -l 3.sh)"

    echo $lines

  6)测试文件

    -d file        目录

    -e file        存在

    -r file        可读

    -w file        可写

    -x file        可执行