sagalinux学习之/kernel目录

朴灿烈づ我的快乐病毒、 2022-06-13 09:52 75阅读 0赞

这篇分析有点长了，慢慢看～～。

请随手携带一本《32位微机原理》宝典，以备查询。

这是kernel目录下的Makefile，很简单

CFLAGS = -I../include/ -c -Wall -fno-stack-protector -o
    
    all:	kernel.o page.o idt.o printk.o keyboard.o irq.o i8259.o console.o
    
    clean:
    	rm -f *.o *~
    
    kernel.o:
    	gcc ${CFLAGS} kernel.o kernel.c
    
    page.o:
    	gcc ${CFLAGS} page.o page.c
    
    idt.o:
    	gcc ${CFLAGS} idt.o idt.c
    
    printk.o:
    	gcc ${CFLAGS} printk.o printk.c
    
    keyboard.o:
    	gcc ${CFLAGS} keyboard.o keyboard.c
    
    irq.o:
    	gcc ${CFLAGS} irq.o irq.c
    
    i8259.o:
    	nasm -felf i8259.s
    
    console.o:
    	gcc ${CFLAGS} console.o console.c

我们先来看目录下的kernel.c文件，主函数就在这里，也就是sagalinux的“内核"核心。。。。我们从主函数发散出去逐个研究。

#include "kernel/idt.h"
    #include "kernel/page.h"
    #include "kernel/kernel.h"
    #include "kernel/keyboard.h"
    #include "kernel/console.h"
    
    int main(void)
    {
      //  int i;
      
      char* message = "\nWelcome!\n";
      char* kernel_release = "Kernel on an i386\n\n";
      char* fake_login = "[LinuxSaga]# ";
    
      page_init();//初始化页机制，开启分页，映射了0~16M的物理页
      trap_init();//初始化陷阱门
      keyboard_init();//初始化键盘
      con_clear();//清除终端的所有字符
    
      printk("%s",message);
      printk("%s",kernel_release);
      printk("%s",fake_login);
    
      //  i = 3 / 0;
      while(1);
      return 0;
    }

简单吧，下面是每一个初始化函数的详细

/kernel/page.c	用于初始化页表，页表中描述一个4K的物理页的一个描述项叫做PTE，PTE大小为4B，
    如果PTE在一个4K的物理页中连续存放，形成一个表，我们用PDE来描述这个PTE表，一个PDE大小为4B。
    就是这一回事。
    #include "kernel/page.h"//一些宏定义
    #include "asm/system.h"
    
    //初始化页表
    void page_init()
    {
    
      int pages = NR_PGT;//PTE表的描述项PDE的个数
                         // NR_PGT 为4，创建4个PTE表的描述项(PDE),每个PDE占4B，描述了一个PTE表，每个PTE描述了一个4K的页,这样总共可以访问4*1024*4K即16M大小的内存
    		
      unsigned int page_offset = PAGE_OFFSET;//#define PAGE_OFFSET (unsigned int)0x2000 (8K)
    
    
                                   //PDE项的开始物理地址,PGD_BASE=0x1000(4K)，也就是说PDE位于物理内存的第二个页框内(每个page为4K)
      unsigned int* pgd = PGD_BASE;//#define PGD_BASE (unsigned int*)0x1000 PGD_BASE 是一个指针，指向unsigned int类型,指针的值是0x1000
    			       //赋值之后pgd指向了0x1000这个内存地址，注意pgd这个指针变量占用4B,			
    
      
      unsigned int phy_add = 0x0000;// 从物理地址的最低端开始建立PTE项的映射，映射内存地址0～16M
    
      // PTE表从物理内存8K处开始，每个PTE表有1024项，占满一个物理页。共有4个PTE表，且连续存放
      unsigned int* pgt_entry = (unsigned int*)0x2000; //PTE表的开始地址(8K)
      
      // 填充页目录表PDE项
      // 这里依次创建4(pages=4)个页目录表PDE,一个PDE就是一个PTE表的描述项
      //(每个PTE表有1024项，1024*4B=4K，占一个物理页)
      while (pages--)
        {
          *pgd++ = page_offset |PTE_USR|PTE_RW|PTE_PRE;
          page_offset += 0x1000;//继续描述下一个PTE表
        }
    
      //PDE表，有四项PDE：0x1000~0x2000
      //PTE表：共四个表，位于0x2000~0x3000, 0x3000~0x4000, 0x4000~0x5000, 0x5000~0x6000
    
      pgd = PGD_BASE;//恢复pgd为PDE表基地址0x1000，4K
    
      // 在页表中填写页到物理地址的映射关系，映射了16M大小的物理内存 即0~16M的物理内存
    //共映射了0x1000（4K）个PTE，每个PTE指向一个4K的物理页，共4K*4K=16M内存
      //这里因为PTE表是连续的，所以可以直接给所有的PTE赋值,(*pgt_entry++)
      while (phy_add < 0x1000000) {//0x1000000=16M
        *pgt_entry++ = phy_add |PTE_USR|PTE_RW|PTE_PRE;//下一个PTE项，每个PTE项描述了一个物理页
        phy_add += 0x1000;//下一个物理页，共有4K个PTE，每个PTE一次赋值，共循环了4K次
      }
    	//嵌入式汇编语法
    //__asm__(assembler template 
    //	: output operands /* optional *// 
    //	: input operands /* optional */ 
    //	: list of clobbered registers /* optional */ 
    //);
      // 启用页机制, cr3指向页目录根PDE表的开始
      __asm__ __volatile__ ("movl %0, %%cr3;"//pgd-->cr3，PDT基地址
    			"movl %%cr0, %%eax;"
    			"orl  $0x80000000, %%eax;"
    			"movl %%eax, %%cr0;"	//eax-->cr0，cr0最高位置1，用于开启分页
    			:
    			:"r"(pgd)//%0代表pgd
    			:"memory","%eax");
    //Invalidate TLB before and after setting up page tables
    //使TLB无效，在多核处理器上，避免其他cpu引用到无效的页表
      invalidate_tlb();
    }

回到主函数中下一个trap\_init()函数，位于./kernel/idt.c中

#include "kernel/idt.h"
    #include "kernel/kernel.h"
    #include "asm/system.h"
    
    //x86的描述符类型:存储段描述符;系统段描述符;门描述符
    
    extern void __irq1(void);//声明了外部的中断函数
    
    //idt包含三种类型的门描述符：任务门描述符，中断门描述符，陷阱门描述符。共同点都是CPU暂停当下过程，转而去执行其他过程。
    
    //中断具体过程如下：
    //			0. cpu得到中断向量
    //			1. cpu由idtr寄存器中的基址和界限得到idt在物理内存中的信息
    //			2. 基址+8*中断向量=中断描述符表中的中断门或陷阱门
    //			3. cpu将某一门描述符中的选择子送cs，根据ti位确定从gdt或ldt中选择一个段描述符,即确定了一个段
    //			4. 根据门描述符中的偏移确定段中中断服务程序的具体入口地址。
    
    //intel x86支持256种中断，编号为中断向量0～255，中断向量0～32为intel设定的中断，又称为异常，由CPU内部同步产生，比如中断向量0为除法错误。
    //中断向量y和外部中断号x的关系 默认为y=x+32
    void trap_init()
    {
      int i;
      idtr_t idtr; //idtr 用于指示中断描述符表idt的基址和界限 6B
      设置陷阱门
      set_trap_gate(0, (unsigned int)÷_error);
      set_trap_gate(1, (unsigned int)&debug);
      set_trap_gate(2, (unsigned int)&nmi);
      set_trap_gate(3, (unsigned int)&int3);
      set_trap_gate(4, (unsigned int)&overflow);
      set_trap_gate(5, (unsigned int)&bounds);
      set_trap_gate(6, (unsigned int)&invalid_op);
      set_trap_gate(7, (unsigned int)&device_not_available);
      set_trap_gate(8, (unsigned int)&double_fault);
      set_trap_gate(9, (unsigned int)&coprocessor_segment_overrun);
      set_trap_gate(10,(unsigned int) &invalid_TSS);
      set_trap_gate(11, (unsigned int)&segment_not_present);
      set_trap_gate(12, (unsigned int)&stack_segment);
      set_trap_gate(13, (unsigned int)&general_protection);
      set_trap_gate(14, (unsigned int)&page_fault);
      set_trap_gate(15, (unsigned int)&coprocessor_error);
      set_trap_gate(16, (unsigned int)&alignment_check);
    			//(unsigned int)把指针强制转换成unsigned int类型
    
      for (i = 17;i<32;i++)//保留中断向量
        set_trap_gate(i, (unsigned int)&reserved);
      
      //设置外部中断
      set_trap_gate(33, (unsigned int)&__irq1);//irq1 为键盘中断，中断向量为1+32=33(中断号和中断向量的关系由主板物理连接决定)
    
      //设置中断描述符表寄存器
      idtr.limit = 34*8; //0～33共34个中断
      idtr.lowerbase = 0x0000;//从内存地址0x0开始
      idtr.higherbase = 0x0000;
      cli();//关中断cf <--0
      __asm__ __volatile__ ("lidt (%0)"//装载IDT的信息至idtr寄存器
    			::"p" (&idtr)); 
      sti();//开中断cf <--1
    }
    
    void set_trap_gate(int vector, unsigned int handler_offset)//在IDT中填入8B的门描述符
    {				//#define IDT_BASE      0x0000
      trapgd_t* trapgd = (trapgd_t*) IDT_BASE + vector;	//IDT_BASE+8*vector，在IDT中相应位置存放8B的陷阱描述符
      trapgd->loffset = handler_offset & 0x0000FFFF;	//存储函数地址低16位
      trapgd->segment_s = CODESEGMENT;			//这里选择子是0x08,指示的是内核代码段
      trapgd->reserved = 0x00;
      trapgd->options =  0x0F | PRESENT | KERNEL_LEVEL;//存在的,特权级为0的段
      trapgd->hoffset = ((handler_offset & 0xFFFF0000) >> 16);//存储函数地址高16位
      
    }
    
    void set_int_gate(int vector,  unsigned int handler_offset)//中断门
    {				
      intgd_t* intgd = (intgd_t*) IDT_BASE + vector;
      intgd->loffset =  handler_offset & 0x0000FFFF;
      intgd->segment_s = CODESEGMENT;
      intgd->reserved = 0x0;
      intgd->options =  0x0E | PRESENT | KERNEL_LEVEL;//和set_trap_gate()的不同之处仅在于此，这里是0x0E
      intgd->hoffset = ((handler_offset & 0xFFFF0000) >> 16);  
    }
    
    void set_task_gate(int vector, ushort_t tss)		//任务门
    {
      taskgd_t* taskgd = (taskgd_t*) IDT_BASE + vector;
      taskgd->reserved = 0x0;
      taskgd->tss = tss;//指向tss段的选择子
    
      taskgd->reservedd = 0x0;
      taskgd->options = 0x05 | PRESENT | KERNEL_LEVEL;
      taskgd->reserveddd = 0x0;
      
    }
    
    // Nooooo... just sleep :)
    void sleep(char* message)
    {
      printk("%s",message);
      while(1);
    }
    
    void divide_error(void)
    {
      sleep("divide error");
    }
    void debug(void)
    {
      sleep("debug");
    }
    
    void nmi(void)
    {
      sleep("nmi");
    }
    
    void int3(void)
    {
      sleep("int3");
    }
    
    void overflow(void)
    {
      sleep("overflow");
    }
    
    void bounds(void)
    {
      sleep("bounds");
    }
    void invalid_op(void)
    {
      sleep("invalid op");
    }
    
    void device_not_available(void)
    {
      sleep("device not available");
    }
    
    void double_fault(void)
    {
      sleep("double fault");
    }
    
    void coprocessor_segment_overrun(void)
    {
      sleep("coprocessor segment overrun");
    }
    
    void invalid_TSS(void)
    {
      sleep("invalid TSS");
    }
    
    void segment_not_present(void)
    {
      sleep("segment not present");
    }
    
    void stack_segment(void)
    {
      sleep("stack segment");
    }
    
    void general_protection(void)
    {
      sleep("general protection");
    }
    
    void page_fault(void)
    {
      sleep("page fault");
    }
    
    void coprocessor_error(void)
    {
      sleep("coprocessor error");
    }
    
    void alignment_check(void)
    {
      sleep("alignment check");
    }
    
    void reserved(void)
    {
      sleep("reserved");
    }

idtr\_t、trapgd\_t、intgd\_t、taskgd\_t类型就不细说了，就拿本《32位微机原理》，和书上的格式对照一下，就知道了。  
  
  
注意上面有一个extern void \_\_irq1(void);  
是对外部中断函数的声明，函数的实现在/kernel/i8259.s中  
下面来看一下这个文件

/kernel/i8259.s

;进入保护模式就是32位了
    [BITS 32]
    			;这里的中断是外部8259上的中断,两片8259可以提供15个外部中断
    extern  irq_handler	;在./include/kernel/irq.h中，是一个函数指针数组：void (*irq_handler[16])();
    
    global	__irq0
    global	__irq1
    global	__irq2
    global	__irq3
    global	__irq4
    global	__irq5
    global	__irq6
    global	__irq7
    global	__irq8
    global	__irq9
    global	__irq10
    global	__irq11
    global	__irq12
    global	__irq13
    global	__irq14
    global	__irq15
    	;中断函数
    do_irq:
    	pop	eax	;外部中断号出栈
    	call [irq_handler + 4*eax]	;irq_handler+4*eax，跳到真正的中断处理函数地址，每个地址4B
    
    	mov	al, 0x20		;向8259发送EOI，通知中断结束。
    	mov	dx, 0x20
    	out	dx, al
    	
    	popa
    	iret
    
    __irq0:				;硬件中断的处理程序，这里的函数地址将会存储在IDT中的门描述符中
    	pusha
    	mov eax, $0
    	push eax
    	jmp do_irq
    
    __irq1:				;sagalinux只实现了这个键盘中断，
    	pusha
    	mov eax, $1
    	push eax
    	jmp do_irq
    
    __irq2:
    	pusha
    	mov eax, $2
    	push eax	
    	jmp do_irq
    
    __irq3:
    	pusha
    	mov eax, $3
    	push eax
    	jmp do_irq
    
    __irq4:
    	pusha
    	mov eax, $4
    	push eax
    	jmp do_irq
    
    __irq5:
    	pusha
    	mov eax, $5
    	push eax
    	jmp do_irq
    
    __irq6:
    	pusha
    	mov eax, $6
    	push eax
    	jmp do_irq
    
    __irq7:
    	pusha
    	mov eax, $7
    	push eax
    	jmp do_irq
    
    __irq8:
    	pusha
    	mov eax, $8
    	push eax
    	jmp do_irq
    
    __irq9:
    	pusha
    	mov eax, $9
    	push eax
    	jmp do_irq
    
    __irq10:
    	pusha
    	mov eax, $10
    	push eax
    	jmp do_irq
    
    __irq11:
    	pusha
    	mov eax, $11
    	push eax
    	jmp do_irq
    
    __irq12:
    	pusha
    	mov eax, $12
    	push eax
    	jmp do_irq
    
    __irq13:
    	pusha
    	mov eax, $13
    	push eax
    	jmp do_irq
    
    __irq14:
    	pusha
    	mov eax, $14
    	push eax
    	jmp do_irq
    
    __irq15:
    	pusha
    	mov eax, $15
    	push eax
    	jmp do_irq

再细看究竟键盘中断是怎么实现的，就是按一下键，屏幕上产生一个字符。  
我们回到主函数中看下一个函数keyboard\_init()，它位于./kernel/keyboard.c中

#include "kernel/irq.h"
    #include "kernel/kernel.h"
    #include "asm/io.h"
    #include "sys/types.h"
    
    static byte shift = 0;//here the variable shift is global; typedef unsigned char byte;
    
    #define LEFTSHIFT 0x2A//make code of leftshift
    #define RIGHTSHIFT 0x36//make code of rightshift
    
    //you should know : make code and break code ,which mean press and relax, break code = make code | 0x80
    static byte keymap[] = { /* SHIFT OFF */ \
    		     ' ',' ', '1', '2', '3', '4', '5', '6', '7', '8',
    		     '9', '0', '-', '=', '\b', '\t', 'q', 'w', 'e', 'r',
                          't', 'y', 'u', 'i', 'o', 'p', '[', ']', '\n',  ' ',
                          'a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', ';',
                          '\'', '~', ' ', '\"', 'z', 'x', 'c', 'v', 'b', 'n',
                          'm', '<', '>', '/', ' ', ' ', ' ', ' ', ' ', //the last character this line is keymap[0x3B]
    			 /* SHIFT ON */
    		      ' ', ' ', '!', '@', '#', '$', '%', '^', '&', '*',
                          '(', ')', '_', '+', ' ', ' ', 'Q', 'W', 'E', 'R',
                          'T', 'Y', 'U', 'I', 'O', 'P', '{', '}', ' ',  ' ',
                          'A', 'S', 'D', 'F', 'G', 'H', 'J', 'K', 'L', ':',
                          '\"', '<', ' ', '"', 'Z', 'X', 'C', 'V', 'B', 'N',
                          'M', '<', '>', '?', ' ', ' ', ' ', ' ', ' '};
    
    //keyboard interrupt process function,when key press or relax ,interrupt occur
    void keyboard_handler()//这就是真正的键盘中断处理函数
    {			//过程：按下键盘->芯片收到中断信号->将中断号发给cpu->cpu加32得到中断向量->cpu去向量表中找到函数指针__irq1->__irq1跳到do_irq->do_irq通过中断号索引函数指针数组irq_handler[]，最终执行中断函数keyboard_handler()。
      byte scancode = inb(0x60); //read code from buffer ,only one byte when the interrupt occur，每次中断只处理缓冲区中的一个字节
      byte ascii = 0;
      
      switch (scancode) {//键盘按下和松开都会产生扫描码
      case LEFTSHIFT:
      case RIGHTSHIFT:
        shift = 0x3B;         // Nothing special.只是按下shift键的话不做任何处理，注意shift是一个全局变量
        break;
      case LEFTSHIFT | 0x80:	//break code,relax the key
      case RIGHTSHIFT | 0x80:	//松开键盘，shift标志清0
        shift = 0;
        break;
      default://the other character
          if (scancode < 0x3B)
    	{
    	  ascii = keymap[scancode + shift];//由扫描码索引得到字符
    	  printk("%c",ascii);
    	}
      }
    }
    
    void keyboard_init()
    {	//    #define KEYBOARD 0x01
      request_irq(KEYBOARD, keyboard_handler);//在中断处理函数数组中写入keyboard_handler函数指针 #define KEYBOARD 0x01
    }

request_irq()的实现在./kernel/irq.c中
    #include "kernel/irq.h"
    #include "asm/io.h"
    
    void enable_irq(int irq)
    {
      if (irq > 8)				//从芯片irq>8
        outb(inb(SLAVE)&(~(1<<irq)),SLAVE);//set bit 0 means open,使用inb(SLAVE)读取从芯片的配置，并将irq号位清0，使能此中断。
      else
        outb(inb(MASTER)&(~(1<<irq)),MASTER);  
    }
    
    void disable_irq(int irq)
    {
      if (irq > 8)
        outb((inb(SLAVE)|irq),SLAVE);//set bit 1 means close，这里应该是1<<irq吧
      else
        outb((inb(MASTER)|irq),MASTER);
    }
    //设置某中断号的中断处理程序
    void request_irq(int irq, void (*handler)())
    {
      irq_handler[irq] = handler;// void (*irq_handler[16])(); irq_handler[irq]为函数指针 is a address of function
      enable_irq(irq);	//使能中断
    }

看到这里，基本上这个系统最核心的东西就完了，还有一些处理终端界面，输入输出的函数，下面我们再分析。  
内存的初始化和中断的过程是sagalinux所描述最多的，这也是计算机中基本而又最重要的知识。  
  
  
  
  
分析到这里，./kernel目录下的文件就只剩下console.c和printk.c了

再回到主函数中看下一个函数con\_clear()，它在./kernel/concole.c中  
concole.c主要是设置界面终端字符的显示和清空的  
代码也很简单，采用了直接写视频缓冲区0xB8000的方式，看一下就好了

#include "kernel/console.h"
    #include "sys/types.h"
    #include "asm/system.h"
    #include "asm/io.h"
    
    #define SCREEN 0xB8000
    #define MAXLINES 25
    #define MAXCOLUMNS 80
    #define NEXTLINE 160
    
    static unsigned int cur_pos = 0;
    static unsigned int cur_x,cur_y;
    static char* scr_origin = (char*)SCREEN;
    static ushort_t video_cont_reg = 0x3d4;   // Video Controller Chip 6845
    static ushort_t video_cont_val = 0x3d5;
    
    void set_cursor()
    {
      cli();
      outb(14, video_cont_reg);
      outb((cur_pos>>9) & 0xFF, video_cont_val);
      outb(15, video_cont_reg);
      outb(cur_pos>>1 & 0xFF, video_cont_val);
      sti();
    }
    
    void con_write(char* message, char attr)
    {
      unsigned int pos = cur_x * 2 + cur_y * NEXTLINE;//屏幕上的一个字符需要2B来表示，一行有80个字符需要160B。
      char c;
    
      while ((c = *message++) != '\0') {
        switch (c) {
          case '\n':
    	  pos += (NEXTLINE - pos % NEXTLINE);
    	  cur_y++;
    	  cur_x = 0;
    	  break;
          case '\b':
    	pos -= 2;
    	cur_x--;
    	 *(scr_origin + pos) = ' ';
    	break;
        default:
          *(scr_origin + pos) = c;
          *(scr_origin + pos + 1) = attr;
          cur_x++;
          pos += 2;
        }
      }
      cur_pos = pos;
      set_cursor();
    }
    
    void con_clear()
    {
      int i;
      int scr_buffer = MAXLINES * MAXCOLUMNS * 2; 
    
      for (i = 0; i < scr_buffer; i+=2)
        *(scr_origin + i) = ' ';
    
      cur_x = 0;
      cur_y = 0; 
    }
    
    void scroll_up()
    {
      
    }
    
    void scroll_down()
    {
      
    }
    
    void goto_xy(unsigned int x, unsigned int y)
    {
      if (x > MAXCOLUMNS || y > MAXLINES)
        return;
      cur_x = x;
      cur_y = y;
    }

再看主函数中的最后一个函数printk();

从这个函数里我们可以学到可变参数函数的原理![微笑][smile.gif]

#include "stdarg.h"
    #include "kernel/kernel.h"
    #include "kernel/console.h"
    
    static char buf[1024];		//定义了一个静态全局变量buf缓冲区
    
    void printk(const char* fmt,...)//格式化输出，函数参数是逆序入栈的(从括号末尾处的参数开始进栈)，内存最低处存的是字符串指针。
    {
      va_list args;
      va_start(args,fmt);
      vsnprintf(buf,sizeof(buf), fmt, args);//将
      va_end(args);
      con_write(buf,0xf);//最后输出的字符串存在buf中，在终端上显示buf。
    }

这里的va\_list类型在./include/stdarg.h中

你需要理解函数运行时栈的变化。

比如printf("hello,world! %d %d", 1, 2);

栈由高向低生长，从高到低依次存储的是2，1，以及字符串"hello,world! %d %d"的地址。

#ifndef __STRARG_H__
    #define __STRARG_H__
    
    typedef char* va_list;//指针类型
    
    // Implicit type conversion occurs in argument passing. In order to use the arguments 
    // in an argument list where the parameters are pushed to stack, the sizes of the arguments has to be known.
    // In printf you can use %d for char short int and int. Thats because all are converted to int. 
    // !!!!!!!! Implicit type conversion occurs if the prototype does not specify a type... the prototype of 
    // printf(const char* fmt,...) does not specify a type for arguments so all are promoted...
    
    #define __va_size(type) \
       (((sizeof(type) + sizeof(long) - 1) / sizeof (long)) * sizeof (long))//这里是得到类型的大小，考虑到了内存4字节对齐。如果type是char型的话会返回4。
    
    #define va_start(ap, last) \
       ((ap) = ((char*)&last) + __va_size(last))//得到堆栈中下个元素的指针赋给ap
    
    #define va_arg(ap, type) \
       (*(type*)((ap)+= __va_size(type), (ap) - __va_size(type)))//先让ap指向堆栈中的下一个参数，然后返回上一个参数的指针
    
    #define va_end(va_list) ((void)0)
    
    #endif

再看printk()函数下的vsnprintf()函数，它位于./lib/vsnprintf.c中

#include "stdarg.h"
    #include "sys/types.h"
    
    void vsnprintf (char *str, size_t size, const char *fmt, va_list ap)
    {
      char *temp;
      char c;
      size_t len = size;
      int i,j,sign = 0;
      int num;
      char numbers[] = {'0','1', '2', '3', '4', '5', '6', '7', '8', '9'};
      char strnumber[] = "           "; // :) max 11 digit with the sign.用来存储数的字符串，带符号
      
      while (*fmt && len)
        {
          if(*fmt != '%')//未遇见格式标识则照常规输出
    	{
    	  *str++ = *fmt++;
    	  len--;
    	  continue;
    	}
          fmt++;		//接下来是控制字符
          switch (*fmt++){
          case 'c':	
    	*str++ = (unsigned char)va_arg(ap,int);
    	len--;
    	break;
          case 'i':
          case 'd':
    	num = va_arg(ap,int);//先将指针指向下一个参数，然后返回堆栈中下一个参数的值，
    	if (num < 0)
    	  {
    	    num *= -1;
    	    sign = 1;
    	  }
    	for(i = 0; i < 11; i++){
    	  if(num < 10) 
    	    {
    	      strnumber[i] = numbers[num];
    	      break;
    	    }
    	  strnumber[i] = numbers[num % 10];
    	  num = num / 10;
    	}
    	if(sign--)//数字在临时缓冲区中逆序存放，比如-1234，存的是"4321-"
    	    strnumber[++i] = '-';
          	for(j = i; j >= 0 && len>0; j--,len--)
    	  *str++ = strnumber[j];
    	break;
    	case 's':
    	  temp = va_arg(ap,char*);
    	  while((c = *temp++) != '\0')
    	    *str++ = c;
    	  break;
    	default:
    	  break;
          }  
        }
      *str='\0';
    }
    
    
    void snprintf (char *str, size_t size, const  char  *format,...)
    {
      va_list args;
      va_start(args,format);
      vsnprintf(str, size, format, args);
      va_end(args);  
    
    }
    
    void sprintf (char *str, const  char  *format,...)
    {
      va_list args;
      va_start(args,format);
      vsnprintf(str, 0xFFFFFFFFUL, format, args);
      va_end(args);  
    }

至此，sagaLinux中的所有运行代码分析完毕，我花了一天时间写的这篇东西。。。希望能够对大家有所帮助。  
包括汇编，寻址方式，中断原理，内存初始化，描述符表，嵌入汇编，对指针的理解，函数调用堆栈，C语法。又向高手迈出了巨大的一步～～～～。  
感谢Faik Yalcin Uygur，是他写的整个代码，而且现在又出了一个改进的版本，提供基本的内存管理和文件系统，有兴趣的同志可以去看看。

我下次准备再分析一个GeekOS来看看。

[smile.gif]: /images/20220613/9321d94d6ac14b319d3f1a3b09ca88ce.png