《操作系统真象还原》从零开始自制操作系统自写源码实现（kernel相关文件）

朴灿烈づ我的快乐病毒、 2022-09-04 14:53 165阅读 0赞

### 文章目录 ###

*   *  专栏博客链接
     *  kernel相关文件
     *   *  编写完的debug.c
         *  编写完的debug.h
         *  编写完的global.h
         *  编写完的init.c
         *  编写完的init.h
         *  编写完的interrupt.c
         *  编写完的interrupt.h
         *  编写完的kernel.h
         *  编写完的kernel.S
         *  编写完的main.c
         *  编写完的memory.c
         *  编写完的memory.h

--------------------

## 专栏博客链接 ##

--------------------

**[《操作系统真象还原》从零开始自制操作系统 全章节博客链接][Link 1]**

--------------------

## kernel相关文件 ##

--------------------

### 编写完的debug.c ###

--------------------

#include "debug.h"
    #include "print.h"
    #include "interrupt.h"
    
    void panic_spin(char* filename,int line,const char* func,const char* condition)
    { 
        intr_disable();                 //我的理解是中断关闭防止中断后cpu处理其他进程被调换
        put_str("\n\n\n\\**********ERROR\\**********\\\n");
        put_str("Filename: ");put_str(filename);put_char('\n');
        put_str("Line: "); put_int(line); put_char('\n');
        put_str("Func: ");put_str((char*)func);put_char('\n');
        put_str("Condition: ");put_str((char*)condition);put_char('\n');
        put_str("\\**********ERROR\\**********\\\n");
        
        while(1);
    }

--------------------

### 编写完的debug.h ###

--------------------

#ifndef __KERNEL_DEBUG_H
    #define __KERNEL_DEBUG_H
    
    void panic_spin(char* filename,int line,const char* func,const char* condition);
    
    #define PANIC(...) panic_spin (__FILE__,__LINE__,__func__,__VA_ARGS__)
    
    #ifdef NDEBUG 
    #define ASSERT(CONDITION) ((void)0)
    #else
    #define ASSERT(CONDITION) \ if(CONDITION){ } \ else{ PANIC(#CONDITION); }
    
    #endif
    
    #endif

--------------------

### 编写完的global.h ###

--------------------

#ifndef __KERNEL_GLOBAL_H
    #define __KERNEL_GLOBAL_H
    #include "stdint.h"
    
    #define RPL0 0
    #define RPL1 1
    #define RPL2 2
    #define RPL3 3
    
    #define TI_GDT 0
    #define TI_LDT 1
    
    #define EFLAGS_MBS (1 << 1)
    #define EFLAGS_IF_1 (1 << 9)
    #define EFLAGS_IF_0 0
    #define EFLAGS_IOPL_3 (3 << 12)
    #define EFLAGS_IOPL_0 (0 << 12) 
    #define DIV_ROUND_UP(X,STEP) ((X + STEP - 1) / STEP)
    #define default_prio 31
    #define USER_STACK3_VADDR (0xc0000000 - 0x1000)
    #define offset(struct_type,member) (int)(&((struct_type*)0)->member)
    #define elem2entry(struct_type,struct_member_name,elem_ptr) \ (struct_type*) ((int)elem_ptr - offset(struct_type,struct_member_name))
    
    //-------------- GDT描述符属性 ------------
    
    #define DESC_G_4K 1
    #define DESC_D_32 1
    #define DESC_L 0
    #define DESC_AVL 0
    #define DESC_P 1
    #define DESC_DPL_0 0
    #define DESC_DPL_1 1
    #define DESC_DPL_2 2
    #define DESC_DPL_3 3
    
    #define DESC_S_CODE 1
    #define DESC_S_DATA DESC_S_CODE
    #define DESC_S_SYS 0
    #define DESC_TYPE_CODE 8
    
    #define DESC_TYPE_DATA 2
    #define DESC_TYPE_TSS 9
    
    /*KERNEL段*/
    #define SELECTOR_K_CODE ((1 << 3) + (TI_GDT << 2) + RPL0)
    #define SELECTOR_K_DATA ((2 << 3) + (TI_GDT << 2) + RPL0)
    #define SELECTOR_K_STACK SELECTOR_K_DATA 
    #define SELECTOR_K_GS ((3 << 3) + (TI_GDT << 2) + RPL0)
    /*这里是TSS*/
    /*USER段*/
    #define SELECTOR_U_CODE ((5 << 3) + (TI_GDT << 2) + RPL3)
    #define SELECTOR_U_DATA ((6 << 3) + (TI_GDT << 2) + RPL3)
    #define SELECTOR_U_STACK SELECTOR_U_DATA
    
    #define GDT_ATTR_HIGH ((DESC_G_4K << 7) + (DESC_D_32 << 6) + (DESC_L << 5) + (DESC_AVL << 4))
    
    #define GDT_CODE_ATTR_LOW_DPL3 ((DESC_P << 7) + (DESC_DPL_3 << 5) + (DESC_S_CODE << 4) + DESC_TYPE_CODE)
    
    #define GDT_DATA_ATTR_LOW_DPL3 ((DESC_P << 7) + (DESC_DPL_3 << 5) + (DESC_S_DATA << 4) + DESC_TYPE_DATA)
    
    
    
    //-------------- IDT描述符属性 ------------
    #define IDT_DESC_P 1 
    #define IDT_DESC_DPL0 0
    #define IDT_DESC_DPL3 3
    #define IDT_DESC_32_TYPE 0xE // 32位的门
    #define IDT_DESC_16_TYPE 0x6 // 16位的门，不用，定义它只为和32位门区分
    #define IDT_DESC_ATTR_DPL0 ((IDT_DESC_P << 7) + (IDT_DESC_DPL0 << 5) + IDT_DESC_32_TYPE)
    #define IDT_DESC_ATTR_DPL3 ((IDT_DESC_P << 7) + (IDT_DESC_DPL3 << 5) + IDT_DESC_32_TYPE)
    
    
    //-------------- TSS描述符属性 ------------
    #define TSS_DESC_D 0
    #define TSS_ATTR_HIGH ((DESC_G_4K << 7) + (TSS_DESC_D << 6) + (DESC_L << 5) + (DESC_AVL << 4) + 0X0)
    #define TSS_ATTR_LOW ((DESC_P << 7) + (DESC_DPL_0 << 5) + (DESC_S_SYS << 4) + DESC_TYPE_TSS)
    
    #define SELECTOR_TSS ((4 << 3) + (TI_GDT << 2) + RPL0)
    
    /*描述符结构*/
    struct gdt_desc
    { 
        uint16_t limit_low_word;
        uint16_t base_low_word;
        uint8_t  base_mid_byte;
        uint8_t  attr_low_byte;
        uint8_t  limit_high_attr_high;
        uint8_t  base_high_byte;
    };
    
    #endif

--------------------

### 编写完的init.c ###

--------------------

#include "init.h"
    #include "print.h"
    #include "interrupt.h"
    #include "../device/timer.h"
    #include "memory.h"
    #include "../thread/thread.h"
    #include "../device/console.h"
    #include "../device/keyboard.h"
    #include "../userprog/tss.h"
    #include "../userprog/syscall-init.h"
    #include "../device/ide.h"
    #include "../fs/fs.h"
    
    /*负责初始化所有模块 */
    void init_all() { 
       put_str("init_all\n");
       idt_init();	     // 初始化中断
       mem_init();
       timer_init();
       thread_init();
       console_init();
       keyboard_init();
       tss_init();
       syscall_init();
       ide_init();
       filesys_init();
    }

--------------------

### 编写完的init.h ###

--------------------

#ifndef __KERNEL_INIT_H
    #define __KERNEL_INIT_H
    void init_all(void);
    #endif

--------------------

### 编写完的interrupt.c ###

--------------------

#include "interrupt.h"
    #include "stdint.h"
    #include "global.h"
    #include "io.h"
    #include "print.h"
    #include "kernel.h"
    
    #define PIC_M_CTRL 0x20 // 这里用的可编程中断控制器是8259A,主片的控制端口是0x20
    #define PIC_M_DATA 0x21 // 主片的数据端口是0x21
    #define PIC_S_CTRL 0xa0 // 从片的控制端口是0xa0
    #define PIC_S_DATA 0xa1 // 从片的数据端口是0xa1
    
    #define IDT_DESC_CNT 0x81 // 目前总共支持的中断数
    
    #define EFLAGS_IF 0x00000200 // eflags寄存器中的if位为1
    #define GET_EFLAGS(EFLAG_VAR) asm volatile("pushfl; popl %0" : "=g" (EFLAG_VAR))
    
    
    
    /*中断门描述符结构体*/
    struct gate_desc { 
       uint16_t    func_offset_low_word;
       uint16_t    selector;
       uint8_t     dcount;   //此项为双字计数字段，是门描述符中的第4字节。此项固定值，不用考虑
       uint8_t     attribute;
       uint16_t    func_offset_high_word;
    };
    
    // 静态函数声明,非必须
    static void pic_init(void);
    static void make_idt_desc(struct gate_desc* p_gdesc, uint8_t attr, intr_handler function);
    static void general_intr_handler(uint8_t vec_nr);
    static void exception_init(void);
    static struct gate_desc idt[IDT_DESC_CNT];   	     // idt是中断描述符表,本质上就是个中断门描述符数组
    char* intr_name[IDT_DESC_CNT];		     // 用于保存异常的名字 
    
    
    /******** 定义中断处理程序数组 ******** * 在kernel.S中定义的intrXXentry只是中断处理程序的入口, * 最终调用的是ide_table中的处理程序*/
    intr_handler idt_table[IDT_DESC_CNT];
    
    /********************************************/
    extern intr_handler intr_entry_table[IDT_DESC_CNT];	    // 声明引用定义在kernel.S中的中断处理函数入口数组
    
    
    
    
    
    /* 初始化可编程中断控制器8259A */
    static void pic_init(void) { 
    
       /* 初始化主片 */
       outb (PIC_M_CTRL, 0x11);   // ICW1: 边沿触发,级联8259, 需要ICW4.
       outb (PIC_M_DATA, 0x20);   // ICW2: 起始中断向量号为0x20,也就是IR[0-7] 为 0x20 ~ 0x27.
       outb (PIC_M_DATA, 0x04);   // ICW3: IR2接从片. 
       outb (PIC_M_DATA, 0x01);   // ICW4: 8086模式, 正常EOI
    
       /* 初始化从片 */
       outb (PIC_S_CTRL, 0x11);    // ICW1: 边沿触发,级联8259, 需要ICW4.
       outb (PIC_S_DATA, 0x28);    // ICW2: 起始中断向量号为0x28,也就是IR[8-15] 为 0x28 ~ 0x2F.
       outb (PIC_S_DATA, 0x02);    // ICW3: 设置从片连接到主片的IR2引脚
       outb (PIC_S_DATA, 0x01);    // ICW4: 8086模式, 正常EOI
       
       outb (PIC_M_DATA, 0xf8);
       outb (PIC_S_DATA, 0xbf);
    
       put_str(" pic_init done\n");
    }
    
    /* 创建中断门描述符 */
    static void make_idt_desc(struct gate_desc* p_gdesc, uint8_t attr, intr_handler function) {  
       p_gdesc->func_offset_low_word = (uint32_t)function & 0x0000FFFF;
       p_gdesc->selector = SELECTOR_K_CODE;
       p_gdesc->dcount = 0;
       p_gdesc->attribute = attr;
       p_gdesc->func_offset_high_word = ((uint32_t)function & 0xFFFF0000) >> 16;
    }
    
    /*初始化中断描述符表*/
    static void idt_desc_init(void) { 
       int i, lastindex = IDT_DESC_CNT - 1;
       for (i = 0; i < IDT_DESC_CNT; i++) { 
          make_idt_desc(&idt[i], IDT_DESC_ATTR_DPL0, intr_entry_table[i]); 
       }
       
       make_idt_desc(&idt[lastindex],IDT_DESC_ATTR_DPL3,syscall_handler);
    /* 单独处理系统调用,系统调用对应的中断门dpl为3, * 中断处理程序为单独的syscall_handler */
       put_str(" idt_desc_init done\n");
    }
    
    
    
    /* 通用的中断处理函数,一般用在异常出现时的处理 */
    static void general_intr_handler(uint8_t vec_nr) { 
       if (vec_nr == 0x27 || vec_nr == 0x2f) { 	// 0x2f是从片8259A上的最后一个irq引脚，保留
          return;		//IRQ7和IRQ15会产生伪中断(spurious interrupt),无须处理。
       }
       set_cursor(0);                                         //光标设置在0号位
       int cursor_pos = 0;
       while((cursor_pos++) < 320)			    //一行80字 4行空格
       	put_char(' ');			
       
       set_cursor(0);
       put_str("!!!!!! excetion message begin !!!!!!\n");
       set_cursor(88);					    //第二行第八个字开始打印
       put_str(intr_name[vec_nr]);                            //打印中断向量号
       if(vec_nr == 14)
       { 
       	int page_fault_vaddr = 0;
       	asm("movl %%cr2,%0" : "=r" (page_fault_vaddr));   //把虚拟地址 出错的放到了这个变量里面
    	put_str("\npage fault addr is ");
    	put_int(page_fault_vaddr);
       }
       put_str("!!!!!! excetion message end !!!!!!\n");
       
       while(1);                                              //悬停
    }
    
    
    /* 完成一般中断处理函数注册及异常名称注册 */
    static void exception_init(void) { 			    // 完成一般中断处理函数注册及异常名称注册
       int i;
       for (i = 0; i < IDT_DESC_CNT; i++) { 
    
    /* idt_table数组中的函数是在进入中断后根据中断向量号调用的, * 见kernel/kernel.S的call [idt_table + %1*4] */
          idt_table[i] = general_intr_handler;		    // 默认为general_intr_handler。
    							    // 以后会由register_handler来注册具体处理函数。
          intr_name[i] = "unknown";				    // 先统一赋值为unknown 
       }
       intr_name[0] = "#DE Divide Error";
       intr_name[1] = "#DB Debug Exception";
       intr_name[2] = "NMI Interrupt";
       intr_name[3] = "#BP Breakpoint Exception";
       intr_name[4] = "#OF Overflow Exception";
       intr_name[5] = "#BR BOUND Range Exceeded Exception";
       intr_name[6] = "#UD Invalid Opcode Exception";
       intr_name[7] = "#NM Device Not Available Exception";
       intr_name[8] = "#DF Double Fault Exception";
       intr_name[9] = "Coprocessor Segment Overrun";
       intr_name[10] = "#TS Invalid TSS Exception";
       intr_name[11] = "#NP Segment Not Present";
       intr_name[12] = "#SS Stack Fault Exception";
       intr_name[13] = "#GP General Protection Exception";
       intr_name[14] = "#PF Page-Fault Exception";
       // intr_name[15] 第15项是intel保留项，未使用
       intr_name[16] = "#MF x87 FPU Floating-Point Error";
       intr_name[17] = "#AC Alignment Check Exception";
       intr_name[18] = "#MC Machine-Check Exception";
       intr_name[19] = "#XF SIMD Floating-Point Exception";
       //intr_name[80] = "SYSCALL INTR";
    }
    
    
    /*完成有关中断的所有初始化工作*/
    void idt_init() { 
       put_str("idt_init start\n");
       idt_desc_init();	   // 初始化中断描述符表
       exception_init();	   // 异常名初始化并注册通常的中断处理函数
       pic_init();		   // 初始化8259A
    
       /* 加载idt */
       uint64_t idt_operand = ((sizeof(idt) - 1) | ((uint64_t)(uint32_t)idt << 16));
       asm volatile("lidt %0" : : "m" (idt_operand));
       put_str("idt_init done\n");
    }
    
    void register_handler(uint8_t vec_no,intr_handler function)
    { 
        //把相关向量号的注册函数指针放进去了
        idt_table[vec_no] = function;
    }
    
    enum intr_status intr_enable()
    { 
        if(intr_get_status() != INTR_ON)
        { 
        	asm volatile("sti");
        	return INTR_OFF;
        }
        return INTR_ON;
    }
    
    enum intr_status intr_disable()
    { 
        if(intr_get_status() != INTR_OFF)
        { 
       	asm volatile("cli");
       	return INTR_ON;
        }
        return INTR_OFF;
    }
    
    enum intr_status intr_set_status(enum intr_status status)
    { 
        return (status == INTR_ON) ? intr_enable() : intr_disable();
    }
    
    enum intr_status intr_get_status()
    { 
        uint32_t eflags = 0;
        GET_EFLAGS(eflags);
        return (eflags & EFLAGS_IF) ? INTR_ON : INTR_OFF; 
    }

--------------------

### 编写完的interrupt.h ###

--------------------

#ifndef __KERNEL_INTERRUPT_H
    #define __KERNEL_INTERRUPT_H
    
    #include "stdint.h"
    typedef void* intr_handler;
    
    void idt_init(void);
    void register_handler(uint8_t vec_no,intr_handler function);
    
    enum intr_status
    { 
        INTR_ON,
        INTR_OFF
    };
    
    enum intr_status intr_enable(void);
    enum intr_status intr_disable(void);
    enum intr_status intr_set_status(enum intr_status status);
    enum intr_status intr_get_status(void);
    
    #endif

--------------------

### 编写完的kernel.h ###

--------------------

#ifndef __KERNEL_KERNEL_H
    #define __KERNEL_KERNEL_H
    
    void syscall_handler(void);
    
    #endif

--------------------

### 编写完的kernel.S ###

--------------------

[bits 32]
    %define ERROR_CODE nop		 ; 若在相关的异常中cpu已经自动压入了错误码,为保持栈中格式统一,这里不做操作.
    %define ZERO push 0		 ; 若在相关的异常中cpu没有压入错误码,为了统一栈中格式,就手工压入一个0
    
    extern put_str;
    extern idt_table;
    extern syscall_table;
    
    section .data
    global intr_entry_table
    intr_entry_table:
    
    %macro VECTOR 2
    section .text
    intr%1entry:		 ; 每个中断处理程序都要压入中断向量号,所以一个中断类型一个中断处理程序，自己知道自己的中断向量号是多少
    
        %2				 ; 中断若有错误码会压在eip后面 
    ; 以下是保存上下文环境
        push ds
        push es
        push fs
        push gs
        pushad			 ; PUSHAD指令压入32位寄存器,其入栈顺序是: EAX,ECX,EDX,EBX,ESP,EBP,ESI,EDI
    
        ; 如果是从片上进入的中断,除了往从片上发送EOI外,还要往主片上发送EOI 
        mov al,0x20                   ; 中断结束命令EOI
        out 0xa0,al                   ; 向从片发送
        out 0x20,al                   ; 向主片发送
    
        push %1			   ; 不管idt_table中的目标程序是否需要参数,都一律压入中断向量号,调试时很方便
        call [idt_table + %1*4]       ; 调用idt_table中的C版本中断处理函数
        jmp intr_exit
    	
    section .data
        dd    intr%1entry	 ; 存储各个中断入口程序的地址，形成intr_entry_table数组
    %endmacro
    
    section .text
    global intr_exit
    intr_exit:	     
    ; 以下是恢复上下文环境
        add esp, 4			   ; 跳过中断号
        popad
        pop gs
        pop fs
        pop es
        pop ds
        add esp, 4			   ; 跳过error_code
        iretd
    
    section .text   
    global syscall_handler
    syscall_handler:
        push 0
        
        push ds
        push es
        push fs
        push gs
        pushad
        
        push 0x80			     ; 不管是否需要参数,都一律压入中断向量号,调试时很方便
        push edx			     ;第三个参数
        push ecx			     ;第二个参数
        push ebx			     ;第一个参数
        
        call [syscall_table + eax*4]
        add  esp,12
        
        mov [esp + 8*4],eax	     ;返回值给放到eax中 eax前面有 中断号+EDI+ESI+EBP+ESP+EBX+EDX+ECX 
        jmp intr_exit
        
    
    VECTOR 0x0 ,ZERO
    VECTOR 0X1 ,ZERO
    VECTOR 0X2 ,ZERO
    VECTOR 0x3 ,ZERO
    VECTOR 0X4 ,ZERO
    VECTOR 0X5 ,ZERO
    VECTOR 0x6 ,ZERO
    VECTOR 0X7 ,ZERO
    VECTOR 0X8 ,ERROR_CODE
    VECTOR 0x9 ,ZERO
    VECTOR 0XA ,ERROR_CODE
    VECTOR 0XB ,ERROR_CODE
    VECTOR 0XC ,ERROR_CODE
    VECTOR 0XD ,ERROR_CODE
    VECTOR 0XE ,ERROR_CODE
    VECTOR 0XF ,ZERO
    VECTOR 0X10 ,ZERO
    VECTOR 0X11 ,ERROR_CODE
    VECTOR 0x12 ,ZERO
    VECTOR 0X13 ,ZERO
    VECTOR 0X14 ,ZERO
    VECTOR 0x15 ,ZERO
    VECTOR 0X16 ,ZERO
    VECTOR 0X17 ,ZERO
    VECTOR 0X18 ,ZERO
    VECTOR 0X19 ,ZERO
    VECTOR 0X1A ,ZERO
    VECTOR 0X1B ,ZERO
    VECTOR 0X1C ,ZERO
    VECTOR 0X1D ,ZERO
    VECTOR 0X1E ,ERROR_CODE                               ;处理器自动推错误码
    VECTOR 0X1F ,ZERO					
    VECTOR 0X20 ,ZERO					;时钟中断
    VECTOR 0X21 ,ZERO					;键盘中断
    VECTOR 0X22 ,ZERO					;级联
    VECTOR 0X23 ,ZERO					;串口2
    VECTOR 0X24 ,ZERO					;串口1
    VECTOR 0X25 ,ZERO					;并口2
    VECTOR 0X26 ,ZERO					;软盘
    VECTOR 0X27 ,ZERO					;并口1
    VECTOR 0X28 ,ZERO					;实时时钟
    VECTOR 0X29 ,ZERO					;重定向
    VECTOR 0X2A ,ZERO					;保留
    VECTOR 0x2B ,ZERO					;保留
    VECTOR 0x2C ,ZERO					;ps/2 鼠标
    VECTOR 0x2D ,ZERO					;fpu 浮点单元异常
    VECTOR 0x2E ,ZERO					;硬盘
    VECTOR 0x2F ,ZERO					;保留
    VECTOR 0x30 ,ZERO
    VECTOR 0x31 ,ZERO
    VECTOR 0x32 ,ZERO
    VECTOR 0x33 ,ZERO
    VECTOR 0x34 ,ZERO
    VECTOR 0x35 ,ZERO
    VECTOR 0x36 ,ZERO
    VECTOR 0x37 ,ZERO
    VECTOR 0x38 ,ZERO
    VECTOR 0x39 ,ZERO
    VECTOR 0x3A ,ZERO
    VECTOR 0x3B ,ZERO
    VECTOR 0x3C ,ZERO
    VECTOR 0x3D ,ZERO
    VECTOR 0x3E ,ZERO
    VECTOR 0x3F ,ZERO
    VECTOR 0x40 ,ZERO
    VECTOR 0x41 ,ZERO
    VECTOR 0x42 ,ZERO
    VECTOR 0x43 ,ZERO
    VECTOR 0x44 ,ZERO
    VECTOR 0x45 ,ZERO
    VECTOR 0x46 ,ZERO
    VECTOR 0x47 ,ZERO
    VECTOR 0x48 ,ZERO
    VECTOR 0x49 ,ZERO
    VECTOR 0x4A ,ZERO
    VECTOR 0x4B ,ZERO
    VECTOR 0x4C ,ZERO
    VECTOR 0x4D ,ZERO
    VECTOR 0x4E ,ZERO
    VECTOR 0x4F ,ZERO
    VECTOR 0x50 ,ZERO
    VECTOR 0x51 ,ZERO
    VECTOR 0x52 ,ZERO
    VECTOR 0x53 ,ZERO
    VECTOR 0x54 ,ZERO
    VECTOR 0x55 ,ZERO
    VECTOR 0x56 ,ZERO
    VECTOR 0x57 ,ZERO
    VECTOR 0x58 ,ZERO
    VECTOR 0x59 ,ZERO
    VECTOR 0x5A ,ZERO
    VECTOR 0x5B ,ZERO
    VECTOR 0x5C ,ZERO
    VECTOR 0x5D ,ZERO
    VECTOR 0x5E ,ZERO
    VECTOR 0x5F ,ZERO
    VECTOR 0x61 ,ZERO
    VECTOR 0x62 ,ZERO
    VECTOR 0x63 ,ZERO
    VECTOR 0x64 ,ZERO
    VECTOR 0x65 ,ZERO
    VECTOR 0x66 ,ZERO
    VECTOR 0x67 ,ZERO
    VECTOR 0x68 ,ZERO
    VECTOR 0x69 ,ZERO
    VECTOR 0x6A ,ZERO
    VECTOR 0x6B ,ZERO
    VECTOR 0x6C ,ZERO
    VECTOR 0x6D ,ZERO
    VECTOR 0x6E ,ZERO
    VECTOR 0x6F ,ZERO
    VECTOR 0x70 ,ZERO
    VECTOR 0x71 ,ZERO
    VECTOR 0x72 ,ZERO
    VECTOR 0x73 ,ZERO
    VECTOR 0x74 ,ZERO
    VECTOR 0x75 ,ZERO
    VECTOR 0x76 ,ZERO
    VECTOR 0x77 ,ZERO
    VECTOR 0x78 ,ZERO
    VECTOR 0x79 ,ZERO
    VECTOR 0x7A ,ZERO
    VECTOR 0x7B ,ZERO
    VECTOR 0x7C ,ZERO
    VECTOR 0x7D ,ZERO
    VECTOR 0x7E ,ZERO
    VECTOR 0x7F ,ZERO
    VECTOR 0x80 ,ZERO

--------------------

### 编写完的main.c ###

--------------------

#include "print.h"
    #include "init.h"
    #include "debug.h"
    #include "string.h"
    #include "memory.h"
    #include "../thread/thread.h"
    #include "interrupt.h"
    #include "../device/console.h"
    #include "../device/ioqueue.h"
    #include "../device/keyboard.h"
    #include "../userprog/process.h"
    #include "../lib/user/syscall.h"
    #include "../userprog/syscall-init.h"
    #include "../lib/stdio.h"
    #include "../lib/kernel/stdio-kernel.h"
    #include "../fs/fs.h"
    #include "../fs/file.h"
    #include "../shell/shell.h"
    #include "global.h"
    
    int main(void) 
    { 
        put_str("I am kernel\n");
        init_all();
        intr_enable();
        
        uint32_t file_size = 10236;
        uint32_t sec_cnt   = DIV_ROUND_UP(file_size,512);
        struct disk* sda = &channels[0].devices[0];
        void* prog_buf = sys_malloc(file_size);
        ide_read(sda,300,prog_buf,sec_cnt);
        int32_t fd = sys_open("/prog_no_arg",O_CREAT | O_RDWR);
        if(fd != -1)
        { 
            if(sys_write(fd,prog_buf,file_size) == -1)
            { 
                printk("file write error\n");
                while(1);
            }
        }
        sys_free(prog_buf);
        
        cls_screen();
        console_put_str("[Love 6@localhost /]$ ");
        
       
        while(1);
        return 0;
    }
    
    void init(void)
    { 
        uint32_t ret_pid = fork();
        if(ret_pid)
            while(1);
        else
            my_shell();
        PANIC("init: should not be here");
    }

--------------------

### 编写完的memory.c ###

--------------------

#include "memory.h"
    #include "stdint.h"
    #include "print.h"
    #include "bitmap.h"
    #include "debug.h"
    #include "string.h"
    #include "global.h"
    #include "../thread/sync.h"
    #include "../thread/thread.h"
    #include "../lib/kernel/list.h"
    #include "interrupt.h"
    
    #define PG_SIZE 4096
    #define MEM_BITMAP_BASE 0Xc009a000 //位图开始存放的位置
    #define K_HEAP_START 0xc0100000 //内核栈起始位置
    #define PDE_IDX(addr) ((addr & 0xffc00000) >> 22)
    #define PTE_IDX(addr) ((addr & 0x003ff000) >> 12)
    
    struct pool
    { 
        struct bitmap pool_bitmap; //位图来管理内存使用
        uint32_t phy_addr_start;   //内存池开始的起始地址
        uint32_t pool_size;	//池容量
        struct lock lock;
    };
    struct mem_block_desc k_block_descs[DESC_CNT]; //内核内存块描述符数组
    
    struct pool kernel_pool ,user_pool; //生成内核内存池 和 用户内存池
    struct virtual_addr kernel_vaddr;    //内核虚拟内存管理池
    
    void* vaddr_get(enum pool_flags pf,uint32_t pg_cnt)
    { 
        int vaddr_start = 0,bit_idx_start = -1;
        uint32_t cnt = 0;
        if(pf == PF_KERNEL)
        { 
        	bit_idx_start = bitmap_scan(&kernel_vaddr.vaddr_bitmap,pg_cnt);
        	if(bit_idx_start == -1)	return NULL;
        	while(cnt < pg_cnt)
        	    bitmap_set(&kernel_vaddr.vaddr_bitmap,bit_idx_start + (cnt++),1);
        	vaddr_start = kernel_vaddr.vaddr_start + bit_idx_start * PG_SIZE;
        }
        else
        { 
        	struct task_struct* cur = running_thread();
        	bit_idx_start = bitmap_scan(&cur->userprog_vaddr.vaddr_bitmap,pg_cnt);
        	if(bit_idx_start == -1)	return NULL;
        	
        	while(cnt < pg_cnt)
        	    bitmap_set(&cur->userprog_vaddr.vaddr_bitmap,bit_idx_start + (cnt++),1);
        	vaddr_start = cur->userprog_vaddr.vaddr_start + bit_idx_start * PG_SIZE;
        	ASSERT((uint32_t)vaddr_start < (0xc0000000 - PG_SIZE));
        }
        return (void*)vaddr_start;
    }
    
    uint32_t* pte_ptr(uint32_t vaddr)
    { 
        uint32_t* pte = (uint32_t*)(0xffc00000 + ((vaddr & 0xffc00000) >> 10) + PTE_IDX(vaddr) * 4);
        return pte;
    }
    
    uint32_t* pde_ptr(uint32_t vaddr)
    { 
        uint32_t* pde = (uint32_t*) ((0xfffff000) + PDE_IDX(vaddr) * 4);
        return pde;
    }
    
    void* palloc(struct pool* m_pool)
    { 
        int bit_idx = bitmap_scan(&m_pool->pool_bitmap,1);
        if(bit_idx == -1)	return NULL;
        bitmap_set(&m_pool->pool_bitmap,bit_idx,1);
        uint32_t page_phyaddr = ((bit_idx * PG_SIZE) + m_pool->phy_addr_start);
        return (void*)page_phyaddr;
    }
    
    void page_table_add(void* _vaddr,void* _page_phyaddr)
    { 
        uint32_t vaddr = (uint32_t)_vaddr,page_phyaddr = (uint32_t)_page_phyaddr;
        uint32_t* pde = pde_ptr(vaddr);
        uint32_t* pte = pte_ptr(vaddr);
        
        if(*pde & 0x00000001)
        { 
        	ASSERT(!(*pte & 0x00000001));
        	if(!(*pte & 0x00000001))
        	    *pte = (page_phyaddr | PG_US_U | PG_RW_W | PG_P_1);
        	else
        	{ 
        	    PANIC("pte repeat");
        	    *pte = (page_phyaddr | PG_US_U | PG_RW_W | PG_P_1);
        	}
        } 
        else
        { 
        	uint32_t pde_phyaddr = (uint32_t)palloc(&kernel_pool);
        	*pde = (pde_phyaddr | PG_US_U | PG_RW_W | PG_P_1);
        	memset((void*)((int)pte & 0xfffff000),0,PG_SIZE);
        	ASSERT(!(*pte & 0x00000001));
        	*pte = (page_phyaddr | PG_US_U | PG_RW_W | PG_P_1);
        }
        return;
    }
    
    void* malloc_page(enum pool_flags pf,uint32_t pg_cnt)
    { 
        ASSERT(pg_cnt > 0 && pg_cnt < 3840);
        
        void* vaddr_start = vaddr_get(pf,pg_cnt);
        if(vaddr_start == NULL)	return NULL;
        
        
        uint32_t vaddr = (uint32_t)vaddr_start,cnt = pg_cnt;
        struct pool* mem_pool = pf & PF_KERNEL ? &kernel_pool : &user_pool;
        
        while(cnt-- > 0)
        { 
        	void* page_phyaddr = palloc(mem_pool);
        	if(page_phyaddr == NULL)	return NULL;
        	page_table_add((void*)vaddr,page_phyaddr);
        	vaddr += PG_SIZE;
        }
        return vaddr_start;
    }
    
    void* get_kernel_pages(uint32_t pg_cnt)
    { 
        void* vaddr = malloc_page(PF_KERNEL,pg_cnt);
        if(vaddr != NULL)	memset(vaddr,0,pg_cnt*PG_SIZE);
        return vaddr;
    }
    
    void* get_user_pages(uint32_t pg_cnt)
    { 
        lock_acquire(&user_pool.lock);	//用户进程可能会产生冲突 大部分时间都在用户进程 内核进程可以理解基本不会冲突
        void* vaddr = malloc_page(PF_USER,pg_cnt);
        if(vaddr != NULL)	memset(vaddr,0,pg_cnt*PG_SIZE);
        lock_release(&user_pool.lock);
        return vaddr;
    }
    
    void* get_a_page(enum pool_flags pf,uint32_t vaddr)
    { 
        struct pool* mem_pool = (pf == PF_KERNEL) ? &kernel_pool : &user_pool;
        lock_acquire(&mem_pool->lock);
        
        struct task_struct* cur = running_thread();
        int32_t bit_idx = -1;
        
        //虚拟地址位图置1
        if(cur->pgdir != NULL && pf == PF_USER)
        { 
        	bit_idx = (vaddr - cur->userprog_vaddr.vaddr_start) / PG_SIZE;
        	ASSERT(bit_idx > 0);
        	bitmap_set(&cur->userprog_vaddr.vaddr_bitmap,bit_idx,1);
        }
        else if(cur->pgdir == NULL && pf == PF_KERNEL) 
        { 
        	bit_idx = (vaddr - kernel_vaddr.vaddr_start) / PG_SIZE;
        	ASSERT(bit_idx > 0);
        	bitmap_set(&kernel_vaddr.vaddr_bitmap,bit_idx,1);
        }
        else
        	PANIC("get_a_page:not allow kernel alloc userspace or user alloc kernelspace by get_a_page");
        	
        void* page_phyaddr = palloc(mem_pool);
        if(page_phyaddr == NULL)
        	return NULL;
        page_table_add((void*)vaddr,page_phyaddr);
        lock_release(&mem_pool->lock);
        return (void*)vaddr;
    }
    
    /* 得到虚拟地址映射的物理地址 */
    uint32_t addr_v2p(uint32_t vaddr)
    { 
        uint32_t* pte = pte_ptr(vaddr);
        return ((*pte & 0xfffff000) + (vaddr & 0x00000fff));
    }
    
    void mem_pool_init(uint32_t all_mem)
    { 
        put_str(" mem_pool_init start!\n");
        uint32_t page_table_size = PG_SIZE * 256;       //页表占用的大小
        uint32_t used_mem = page_table_size + 0x100000; //低端1MB的内存 + 页表所占用的大小
        uint32_t free_mem = all_mem - used_mem;
        
        uint16_t all_free_pages = free_mem / PG_SIZE;   //空余的页数 = 总空余内存 / 一页的大小
        
        uint16_t kernel_free_pages = all_free_pages /2; //内核 与 用户 各平分剩余内存
        uint16_t user_free_pages = all_free_pages - kernel_free_pages; //万一是奇数 就会少1 减去即可
        
        //kbm kernel_bitmap ubm user_bitmap
        uint32_t kbm_length = kernel_free_pages / 8;    //一位即可表示一页 8位一个数
        uint32_t ubm_length = user_free_pages / 8;
        
        //kp kernel_pool up user_pool
        uint32_t kp_start = used_mem;
        uint32_t up_start = kp_start + kernel_free_pages * PG_SIZE;
        
        kernel_pool.phy_addr_start = kp_start;
        user_pool.phy_addr_start = up_start;
        
        kernel_pool.pool_size = kernel_free_pages * PG_SIZE;
        user_pool.pool_size = user_free_pages * PG_SIZE;
        
        kernel_pool.pool_bitmap.bits = (void*)MEM_BITMAP_BASE;
        user_pool.pool_bitmap.bits = (void*)(MEM_BITMAP_BASE + kbm_length);
        
        kernel_pool.pool_bitmap.btmp_bytes_len = kbm_length;
        user_pool.pool_bitmap.btmp_bytes_len = ubm_length; 
        
        put_str(" kernel_pool_bitmap_start:");
        put_int((int)kernel_pool.pool_bitmap.bits);
        put_str(" kernel_pool_phy_addr_start:");
        put_int(kernel_pool.phy_addr_start);
        put_char('\n');
        put_str(" user_pool_bitmap_start:");
        put_int((int)user_pool.pool_bitmap.bits);
        put_str(" user_pool_phy_addr_start:");
        put_int(user_pool.phy_addr_start);
        put_char('\n');
        
        bitmap_init(&kernel_pool.pool_bitmap);
        bitmap_init(&user_pool.pool_bitmap);
        
        kernel_vaddr.vaddr_bitmap.bits = (void*)(MEM_BITMAP_BASE + kbm_length + ubm_length);
        kernel_vaddr.vaddr_bitmap.btmp_bytes_len = kbm_length;
        
        kernel_vaddr.vaddr_start = K_HEAP_START;
        bitmap_init(&kernel_vaddr.vaddr_bitmap);
        lock_init(&kernel_pool.lock);
        lock_init(&user_pool.lock);
        put_str(" mem_pool_init done\n");
        return;
    }
    
    void block_desc_init(struct mem_block_desc* desc_array)
    { 
        uint16_t desc_idx,block_size = 16;
        for(desc_idx = 0;desc_idx < DESC_CNT;desc_idx++)
        { 
        	desc_array[desc_idx].block_size = block_size;
        	desc_array[desc_idx].block_per_arena = (PG_SIZE - sizeof(struct arena)) / block_size;
        	list_init(&desc_array[desc_idx].free_list);
        	block_size *= 2;
        }   
    }
    
    void mem_init()
    { 
        put_str("mem_init start!\n");
        uint32_t mem_bytes_total = (*(uint32_t*)(0x800)); //我们把总内存的值放在了0x800 我之前为了显示比较独特 放在了0x800处了
        mem_pool_init(mem_bytes_total);
        block_desc_init(k_block_descs);
        put_str("mem_init done!\n");
        return;
    }
    
    //返回idx个内存块的地址 空间布局为 arena元信息+n个内存块
    struct mem_block* arena2block(struct arena* a,uint32_t idx)
    { 
        return (struct mem_block*)((uint32_t)a + sizeof(struct arena) + idx * a->desc->block_size);
    }
    
    //自然页框的最低点处
    struct arena* block2arena(struct mem_block* b)
    { 
        return (struct arena*)((uint32_t)b & 0xfffff000);
    }
    
    void* sys_malloc(uint32_t size)
    { 
        enum pool_flags PF;
        struct pool* mem_pool;
        uint32_t pool_size;
        struct mem_block_desc* descs;
        struct task_struct* cur_thread = running_thread();
        
        if(cur_thread->pgdir == NULL)
        { 
        	PF = PF_KERNEL;
        	pool_size = kernel_pool.pool_size;
        	mem_pool = &kernel_pool;
        	descs = k_block_descs;
        }
        else
        { 
        	PF = PF_USER;
        	pool_size = user_pool.pool_size;
        	mem_pool = &user_pool;
        	descs = cur_thread->u_block_desc;
        }
        //size 超出空间大小或者为 0 负数
        if(!(size > 0 && size < pool_size))
        { 
        	return NULL;
        }
        
        struct arena* a;
        struct mem_block* b;
        lock_acquire(&mem_pool->lock);
        
        //超过页框直接分配页框
        if(size > 1024)
        { 
        	uint32_t page_cnt = DIV_ROUND_UP(size + sizeof(struct arena),PG_SIZE);
        	a = malloc_page(PF,page_cnt);
        	if(a != NULL)
        	{ 
        	    memset(a,0,page_cnt * PG_SIZE);
    	    a->desc = NULL;
    	    a->cnt  = page_cnt;
    	    a->large = true;    
    	    lock_release(&mem_pool->lock);
    	    return (void*)(a+1); //返回地址 struct arena + sizeof(struct arena)
    	}
    	else
    	{ 
    	    lock_release(&mem_pool->lock);
    	    return NULL;
    	}
        }
        else
        { 
        	uint8_t desc_idx;
        	for(desc_idx = 0;desc_idx < DESC_CNT;desc_idx++)
        	{ 
        	    if(size <= descs[desc_idx].block_size)
        	    { 
        	    	break;
        	    }
        	}
        	
        	//已经空了
        	if(list_empty(&descs[desc_idx].free_list))
        	{ 
        	    a = malloc_page(PF,1);
        	    if(a == NULL)
        	    { 
        	    	lock_release(&mem_pool->lock);
        	    	return NULL;
        	    }
        	    memset(a,0,PG_SIZE);
        	    
        	    a->desc = &descs[desc_idx];
        	    a->large = false;
        	    a->cnt = descs[desc_idx].block_per_arena;
        	    uint32_t block_idx;
        	    
        	    enum intr_status old_status = intr_disable();
        	    
        	    for(block_idx = 0;block_idx < descs[desc_idx].block_per_arena;++block_idx)
        	    { 
        	    	b = arena2block(a,block_idx);
        	    	ASSERT(!elem_find(&a->desc->free_list,&b->free_elem));
        	    	list_append(&a->desc->free_list,&b->free_elem);
        	    }
        	    intr_set_status(old_status);
        	}
        	b = elem2entry(struct mem_block,free_elem,list_pop(&(descs[desc_idx].free_list)));
        	memset(b,0,descs[desc_idx].block_size);
        	
        	a = block2arena(b);
        	--a->cnt;
        	lock_release(&mem_pool->lock);
        	return (void*)b;
        }
    }
    
    void pfree(uint32_t pg_phy_addr)
    { 
        struct pool* mem_pool;
        uint32_t bit_idx = 0;
        if(pg_phy_addr >= user_pool.phy_addr_start)
        { 
        	mem_pool = &user_pool;
        	bit_idx = (pg_phy_addr - user_pool.phy_addr_start) / PG_SIZE;
        }
        else
        { 
        	mem_pool = &kernel_pool;
        	bit_idx = (pg_phy_addr - kernel_pool.phy_addr_start) / PG_SIZE;
        }
        bitmap_set(&mem_pool->pool_bitmap,bit_idx,0);	//全部置0
    }
    
    void page_table_pte_remove(uint32_t vaddr)
    { 
        uint32_t* pte = pte_ptr(vaddr);
        *pte = ~PG_P_1;
        asm volatile("invlpg %0"::"m"(vaddr):"memory");	//更新tlb
    }
    
    void vaddr_remove(enum pool_flags pf,void* _vaddr,uint32_t pg_cnt)
    { 
        uint32_t bit_idx_start = 0,vaddr = (uint32_t)_vaddr,cnt = 0;
        
        if(pf == PF_KERNEL)
        { 
        	bit_idx_start = (vaddr - kernel_vaddr.vaddr_start) / PG_SIZE;
        	while(cnt < pg_cnt)
        	{ 
        	    bitmap_set(&kernel_vaddr.vaddr_bitmap,bit_idx_start + (cnt++),0);
        	}
        }
        else
        { 
        	struct task_struct* cur_thread = running_thread();
        	bit_idx_start = (vaddr - cur_thread->userprog_vaddr.vaddr_start) / PG_SIZE;
        	while(cnt < pg_cnt)
        	{ 
        	    bitmap_set(&cur_thread->userprog_vaddr.vaddr_bitmap,bit_idx_start + (cnt++),0);
        	}
        }
    }
    
    void mfree_page(enum pool_flags pf,void* _vaddr,uint32_t pg_cnt)
    { 
        uint32_t pg_phy_addr;
        uint32_t vaddr = (int32_t)_vaddr,page_cnt = 0;
        ASSERT(pg_cnt >= 1 && vaddr % PG_SIZE == 0);
        pg_phy_addr = addr_v2p(vaddr);
        
        ASSERT((pg_phy_addr % PG_SIZE) == 0 && pg_phy_addr >= 0x102000);
        
        if(pg_phy_addr >= user_pool.phy_addr_start)
        { 
        	vaddr -= PG_SIZE;
        	while(page_cnt < pg_cnt)
        	{ 
        	    vaddr += PG_SIZE;
        	    pg_phy_addr = addr_v2p(vaddr);
        	    ASSERT((pg_phy_addr % PG_SIZE) == 0 && pg_phy_addr >= user_pool.phy_addr_start);
        	    pfree(pg_phy_addr);
        	    page_table_pte_remove(vaddr);
        	    page_cnt++;
        	}
        	vaddr_remove(pf,_vaddr,pg_cnt);
       }
       else
       { 
       	vaddr -= PG_SIZE;
       	while(page_cnt < pg_cnt)
       	{ 
       	    vaddr += PG_SIZE;
       	    pg_phy_addr = addr_v2p(vaddr);
       	    ASSERT((pg_phy_addr % PG_SIZE) == 0 && pg_phy_addr >= kernel_pool.phy_addr_start && pg_phy_addr < user_pool.phy_addr_start);
       	    pfree(pg_phy_addr);
       	    page_table_pte_remove(vaddr);
       	    page_cnt++;
       	}
       	vaddr_remove(pf,_vaddr,pg_cnt);
       }
    }
    
    void sys_free(void* ptr)
    { 
        ASSERT(ptr != NULL);
        if(ptr != NULL)
        { 
        	enum pool_flags PF;
        	struct pool* mem_pool;
        	
        	if(running_thread()->pgdir == NULL)
        	{ 
        	    ASSERT((uint32_t)ptr >= K_HEAP_START);
        	    PF = PF_KERNEL;
        	    mem_pool = &kernel_pool;
        	}
        	else
        	{ 
        	    PF = PF_USER;
        	    mem_pool = &user_pool;
        	}
        	
        	lock_acquire(&mem_pool->lock);
        	struct mem_block* b = ptr;
        	struct arena* a = block2arena(b);
        	
        	ASSERT(a->large == 0 || a->large == 1);
        	if(a->desc == NULL && a->large == true)
        	{ 
        	    mfree_page(PF,a,a->cnt);
        	}
        	else
        	{ 
        	    list_append(&a->desc->free_list,&b->free_elem);
        	    if(++a->cnt == a->desc->block_per_arena)
        	    { 
        	    	uint32_t block_idx;
        	    	for(block_idx = 0;block_idx < a->desc->block_per_arena;block_idx++)
        	    	{ 
        	    	    struct mem_block* b = arena2block(a,block_idx);
        	    	    ASSERT(elem_find(&a->desc->free_list,&b->free_elem));
        	    	    list_remove(&b->free_elem);
        	    	}
        	    	mfree_page(PF,a,1);
        	    }
        	}
        	lock_release(&mem_pool->lock);
        }
    }
    
    //得到1页大小内存并复制到页表中 专门针对fork时虚拟地址位图无需操作
    //因为位图我们后面会复制父进程的 所以当然不用继续对虚拟位图操作了
    void* get_a_page_without_opvaddrbitmap(enum pool_flags pf,uint32_t vaddr)
    { 
        struct pool* mem_pool = (pf == PF_KERNEL) ? &kernel_pool : &user_pool;
        lock_acquire(&mem_pool->lock);
        void* page_phyaddr = palloc(mem_pool);
        //分配失败
        if(page_phyaddr == NULL)
        { 
            lock_release(&mem_pool->lock);
            return NULL;
        }
        page_table_add((void*)vaddr,page_phyaddr);
        lock_release(&mem_pool->lock);
        return (void*)vaddr;
    }

--------------------

### 编写完的memory.h ###

--------------------

#ifndef __KERNEL_MEMORY_H
    #define __KERNEL_MEMORY_H
    #include "stdint.h"
    #include "bitmap.h"
    #include "list.h"
    
    struct virtual_addr
    { 
        struct bitmap vaddr_bitmap;
        uint32_t vaddr_start;
    };
    
    enum pool_flags
    { 
        PF_KERNEL = 1,
        PF_USER = 2
    };
    
    struct mem_block
    { 
        struct list_elem free_elem;
    };
    
    struct mem_block_desc
    { 
        uint32_t block_size;
        uint32_t block_per_arena;
        struct list free_list;	
    };
    
    struct arena
    { 
        struct mem_block_desc* desc;
        uint32_t cnt;
        bool large; 
    };
    
    #define PG_P_1 1
    #define PG_P_0 0
    #define PG_RW_R 0
    #define PG_RW_W 2
    #define PG_US_S 0
    #define PG_US_U 4
    
    #define DESC_CNT 7
    
    extern struct pool kernel_pool,user_pool;
    void* vaddr_get(enum pool_flags pf,uint32_t pg_cnt);
    uint32_t* pte_ptr(uint32_t vaddr);
    uint32_t* pde_ptr(uint32_t vaddr);
    void* palloc(struct pool* m_pool);
    void page_table_add(void* _vaddr,void* _page_phyaddr);
    void* malloc_page(enum pool_flags pf,uint32_t pg_cnt);
    void* get_kernel_pages(uint32_t pg_cnt);
    void* get_user_pages(uint32_t pg_cnt);
    void* get_a_page(enum pool_flags pf,uint32_t vaddr);
    uint32_t addr_v2p(uint32_t vaddr);
    void mem_pool_init(uint32_t all_mem);
    void mem_init(void);
    void block_desc_init(struct mem_block_desc* desc_array);
    struct mem_block* arena2block(struct arena* a,uint32_t idx);
    struct arena* block2arena(struct mem_block* b);
    void* sys_malloc(uint32_t size);
    void pfree(uint32_t pg_phy_addr);
    void page_table_pte_remove(uint32_t vaddr);
    void vaddr_remove(enum pool_flags pf,void* _vaddr,uint32_t pg_cnt);
    void mfree_page(enum pool_flags pf,void* _vaddr,uint32_t pg_cnt);
    void sys_free(void* ptr);
    void* get_a_page_without_opvaddrbitmap(enum pool_flags pf,uint32_t vaddr);
    
    #endif

[Link 1]: https://love6.blog.csdn.net/article/details/119133589