GeekOS源代码学习(3)Main函数中Init_Mem初始化内存

待我称王封你为后i 2022-06-13 11:28 278阅读 0赞

这此来分析Main中的第三个函数Init\_Mem(bootInfo)。

参数bootInfo是在主函数Main中传入的，为struct Boot\_Info类型

定义在./include/geekos/bootinfo.h

struct Boot_Info {
        int bootInfoSize;    /* size of this struct; for versioning */
        int memSizeKB;       /* number of KB, as reported by int 15h */
    };

内存信息是setup代码获得的，在进入main函数前按照Boot\_Info \*类型作为参数压入。

如下

xor eax, eax 
        mov ax, [(SETUPSEG<<4)+mem_size_kbytes]
        push    eax     ; memSizeKB
        push    dword 8     ; bootInfoSize
    
        ; Pass pointer to Boot_Info struct as argument to kernel
        ; entry point.
        push    esp     ;注意这里，传入的是一个指针!!作为Main函数的参数
    
        ; Push return address to make this look like a call , yes, it like a call. 
        ; XXX - untested
        push    dword (SETUPSEG<<4)+.returnAddr
    
        ; Far jump into kernel
        jmp KERNEL_CS:ENTRY_POINT ; 直接跳到Main函数入口处!!!!!!!

注意压入的参数是一个指针类型

Init\_Mem函数位于./src/geekos/mem.c中，有点长了。

/*
     * Initialize memory management data structures.
     * Enables the use of Alloc_Page() and Free_Page() functions.
     */
    void Init_Mem(struct Boot_Info* bootInfo)
    {
        ulong_t numPages = bootInfo->memSizeKB >> 2;
        ulong_t endOfMem = numPages * PAGE_SIZE;
        unsigned numPageListBytes = sizeof(struct Page) * numPages;
        ulong_t pageListAddr;
        ulong_t kernEnd;
    
        KASSERT(bootInfo->memSizeKB > 0);
    
        /*
         * Before we do anything, switch from setup.asm's temporary GDT
         * to the kernel's permanent GDT.
         */
        Init_GDT();
    
        /*
         * We'll put the list of Page objects right after the end
         * of the kernel, and mark it as "kernel".  This will bootstrap
         * us sufficiently that we can start allocating pages and
         * keeping track of them.
         */
        pageListAddr = Round_Up_To_Page((ulong_t) &end);
        g_pageList = (struct Page*) pageListAddr;
        kernEnd = Round_Up_To_Page(pageListAddr + numPageListBytes);
        s_numPages = numPages;
    
        /*
         * The initial kernel thread and its stack are placed
         * just beyond the ISA hole.
         */
        KASSERT(ISA_HOLE_END == KERN_THREAD_OBJ);
        KASSERT(KERN_STACK == KERN_THREAD_OBJ + PAGE_SIZE);
    
        /*
         * Memory looks like this:
         * 0 - start: available (might want to preserve BIOS data area)
         * start - end: kernel
         * end - ISA_HOLE_START: available
         * ISA_HOLE_START - ISA_HOLE_END: used by hardware (and ROM BIOS?)
         * ISA_HOLE_END - HIGHMEM_START: used by initial kernel thread
         * HIGHMEM_START - end of memory: available
         *    (the kernel heap is located at HIGHMEM_START; any unused memory
         *    beyond that is added to the freelist)
         */
    
        Add_Page_Range(0, PAGE_SIZE, PAGE_UNUSED);
        Add_Page_Range(PAGE_SIZE, KERNEL_START_ADDR, PAGE_AVAIL);
        Add_Page_Range(KERNEL_START_ADDR, kernEnd, PAGE_KERN);
        Add_Page_Range(kernEnd, ISA_HOLE_START, PAGE_AVAIL);
        Add_Page_Range(ISA_HOLE_START, ISA_HOLE_END, PAGE_HW);
        Add_Page_Range(ISA_HOLE_END, HIGHMEM_START, PAGE_ALLOCATED);
        Add_Page_Range(HIGHMEM_START, HIGHMEM_START + KERNEL_HEAP_SIZE, PAGE_HEAP);
        Add_Page_Range(HIGHMEM_START + KERNEL_HEAP_SIZE, endOfMem, PAGE_AVAIL);
    
        /* Initialize the kernel heap */
        Init_Heap(HIGHMEM_START, KERNEL_HEAP_SIZE);
    
        Print("%uKB memory detected, %u pages in freelist, %d bytes in kernel heap\n",
    	bootInfo->memSizeKB, g_freePageCount, KERNEL_HEAP_SIZE);
    }

先看前两句  
ulong\_t numPages = bootInfo->memSizeKB >> 2;  
ulong\_t endOfMem = numPages \* PAGE\_SIZE;

实际调试中，bootInfo->memSizeKB = 32768

numPages=8192 PAGE\_SIZE则是一个物理页的大小4K，  
endOfMem为8192\*4K，为32768K

memSizeKB是系统可用的物理内存，以K为单位，系统为每一个4K的物理页建立一个描述项，numPages得到描述项的个数。

endOfMem则得到可用内存的最终地址。  
比如说如果boot\_SIZE为32769，那么最终得到endOfMem为32768，剩余的1K不用，因为这个物理页不完整，无法用一个描述项描述。

下一句  
unsigned numPageListBytes = sizeof(struct Page) \* numPages;  
得到这些描述项共占内存大小。

struct Page是物理页描述项的类型

定义在./include/geekos/mem.h中  
/\*  
\* Each page of physical memory has one of these structures  
\* associated with it, to do allocation and bookkeeping.  
\*/  
struct Page \{  
unsigned flags; /\* Flags indicating state of page \*/  
DEFINE\_LINK(Page\_List, Page); /\* Link fields for Page\_List \*/  
\};

其中DEFINE\_LINK()是一个宏，定义在./include/geekos/list.h中

/*
     * Define members of a struct to be used as link fields for
     * membership in given list type.
     */
    #define DEFINE_LINK(listTypeName, nodeTypeName) \
        struct nodeTypeName * prev##listTypeName, * next##listTypeName

在struct Page中展开就是  
struct Page\{  
unsigned flags;  
struct Page \* prevPage\_List, \* nextPage\_list;  
\};

熟悉吧，^\_^，DEFINE\_LINK不就是Linux内核中的struct list\_head双向链表结构吗，这里就把所有的物理页描述项连接了起来。

再看下一句  
KASSERT(bootInfo->memSizeKB > 0);  
物理内存大小大于0，这当然是必须的了。

下一句  
Init\_GDT();  
明显是初始化全局描述符表GDT的,看它的实现

位于./src/geekos/gdt.c

/*
     * Initialize the kernel's GDT.
     */
    void Init_GDT(void)
    {
        ushort_t limitAndBase[3];
        ulong_t gdtBaseAddr = (ulong_t) s_GDT;
        struct Segment_Descriptor* desc;
        int i;
    
        KASSERT(sizeof(struct Segment_Descriptor) == 8);
    
        /* Clear out entries. */
        for (i = 0; i < NUM_GDT_ENTRIES; ++i) {
    	desc = &s_GDT[ i ];
    	Init_Null_Segment_Descriptor(desc);
    	desc->avail = 1;
        }
    
        /* Kernel code segment. */
        desc = Allocate_Segment_Descriptor();
        Init_Code_Segment_Descriptor(
    	desc,
    	0,		 /* base address */
    	0x100000,	 /* num pages (== 2^20) */
    	0		 /* privilege level (0 == kernel) */
        );
        KASSERT(Get_Descriptor_Index(desc) == (KERNEL_CS >> 3));
    
        /* Kernel data segment. */
        desc = Allocate_Segment_Descriptor();
        Init_Data_Segment_Descriptor(
    	desc,
    	0,		 /* base address */
    	0x100000,	 /* num pages (== 2^20) */
    	0		 /* privilege level (0 == kernel) */
        );
        KASSERT(Get_Descriptor_Index(desc) == (KERNEL_DS >> 3));
    
        /* Activate the kernel GDT. */
        limitAndBase[0] = sizeof(struct Segment_Descriptor) * NUM_GDT_ENTRIES;
        limitAndBase[1] = gdtBaseAddr & 0xffff;
        limitAndBase[2] = gdtBaseAddr >> 16;
        Load_GDTR(limitAndBase);
    }

好，来看一下这个Init\_GDT()函数，先看s\_GDT这个东东是哪儿来的

位于./src/geekos/gdt.c

/*
     * Number of entries in the kernel GDT.
     */
    #define NUM_GDT_ENTRIES 16
    
    /*
     * This is the kernel's global descriptor table.
     */
    static struct Segment_Descriptor s_GDT[ NUM_GDT_ENTRIES ];

GDT就是系统进入保护模式后的全局描述符表。

这里定义了16个全局描述符，Segment\_Descriptor结构就不说了，还是那一套。

下一句  
KASSERT(sizeof(struct Segment\_Descriptor) == 8);

下一句用for循环清空了这一段GDT内存，并置标志avail为1，avail为1表示此项可用。Init\_Null\_Segment\_Descriptor调用了memset函数来完成了清空内存。

再看下句Allocate\_Segment\_Descriptor()函数。

位于gdt.c

/*
     * Allocate an descriptor from the GDT.
     * Returns null if there are none left.
     */
    struct Segment_Descriptor* Allocate_Segment_Descriptor(void)
    {
        struct Segment_Descriptor* result = 0;
        int i;
        bool iflag;
    
        iflag = Begin_Int_Atomic();
    
        /* Note; entry 0 is unused (thus never allocated) */
        for (i = 1; i < NUM_GDT_ENTRIES; ++i) {
    	struct Segment_Descriptor *desc = &s_GDT[ i ];
    	if (desc->avail) {
    	    ++s_numAllocated;
    	    desc->avail = 0;
    	    result = desc;
    	    break;
    	}
        }
    
        End_Int_Atomic(iflag);
    
        return result;
    }

分配了一个描述符项，分配之后将描述符项中的avail标志置0表示此项已用。

看下一句  
/\* Kernel code segment. \*/  
desc = Allocate\_Segment\_Descriptor();  
Init\_Code\_Segment\_Descriptor(  
desc,  
0,/\* base address \*/  
0x100000, /\* num pages (== 2^20) \*/  
0/\* privilege level (0 == kernel) \*/  
);  
KASSERT(Get\_Descriptor\_Index(desc) == (KERNEL\_CS >> 3));

初始化了s\_GDT中的第1项(s\_GDT的第0项不使用)。

完成了代码段描述符的设置。映射了4G的内存。

再下面是完成数据段描述符的设置，同样映射了4G的内存。

KASSERT()用于确保偏移字节一致。

Init\_GDT函数的最后4句  
/\* Activate the kernel GDT. \*/  
limitAndBase\[0\] = sizeof(struct Segment\_Descriptor) \* NUM\_GDT\_ENTRIES;  
limitAndBase\[1\] = gdtBaseAddr & 0xffff;  
limitAndBase\[2\] = gdtBaseAddr >> 16;  
Load\_GDTR(limitAndBase);  
  
  
设置GDT的基址和界限并将新的GDT载入到gdtr寄存器。

最后一个函数Load\_GDTR位于src/geekos/lowlevel.asm  
align 8  
Load\_GDTR:  
moveax, \[esp+4\]  
lgdt\[eax\]  
; Reload segment registers  
movax, KERNEL\_DS  
movds, ax  
moves, ax  
movfs, ax  
movgs, ax  
movss, ax  
jmpKERNEL\_CS:.here  
.here:  
ret

Init\_GDT函数到此结束。

回到Init\_Mem()函数中，下面

pageListAddr = Round\_Up\_To\_Page((ulong\_t) &end);  
g\_pageList = (struct Page\*) pageListAddr;  
kernEnd = Round\_Up\_To\_Page(pageListAddr + numPageListBytes);  
s\_numPages = numPages;

内联函数Round\_Up\_To\_Page((ulong\_t) &end)将end地址向上补齐成4K对齐。  
g\_pageList是全局变量，在这里设置成为Page链表的开始内存地址。  
这四句准备在end地址后面建立物理页的描述链表。

接下来  
Add\_Page\_Range(0, PAGE\_SIZE, PAGE\_UNUSED);  
Add\_Page\_Range(PAGE\_SIZE, KERNEL\_START\_ADDR, PAGE\_AVAIL);  
Add\_Page\_Range(KERNEL\_START\_ADDR, kernEnd, PAGE\_KERN);  
Add\_Page\_Range(kernEnd, ISA\_HOLE\_START, PAGE\_AVAIL);  
Add\_Page\_Range(ISA\_HOLE\_START, ISA\_HOLE\_END, PAGE\_HW);  
Add\_Page\_Range(ISA\_HOLE\_END, HIGHMEM\_START, PAGE\_ALLOCATED);  
Add\_Page\_Range(HIGHMEM\_START, HIGHMEM\_START + KERNEL\_HEAP\_SIZE, PAGE\_HEAP);  
Add\_Page\_Range(HIGHMEM\_START + KERNEL\_HEAP\_SIZE, endOfMem, PAGE\_AVAIL);  
在链表中增加了描述项，参数分别为起始地址，结束地址，标志。  
可以看到内存的存储情况，结合前面的注释，一看就懂了。

来看一下Add\_Page\_Range()的实现，位于./src/geekos/mem.c中

/*
     * Add a range of pages to the inventory of physical memory.
     */
    static void Add_Page_Range(ulong_t start, ulong_t end, int flags)
    {
        ulong_t addr;
    
        KASSERT(Is_Page_Multiple(start));
        KASSERT(Is_Page_Multiple(end));
        KASSERT(start < end);
    
        for (addr = start; addr < end; addr += PAGE_SIZE) {
    	struct Page *page = Get_Page(addr);
    
    	page->flags = flags;
    
    	if (flags == PAGE_AVAIL) {
    	    /* Add the page to the freelist */
    	    Add_To_Back_Of_Page_List(&s_freeList, page);
    
    	    /* Update free page count */
    	    ++g_freePageCount;
    	} else {
    	    Set_Next_In_Page_List(page, 0);
    	    Set_Prev_In_Page_List(page, 0);
    	}
    
        }
    }

内联函数Is\_Page\_Multiple()确定地址是4K地址对齐的(就是地址的低12位必须全为0)。

再看一下for循环中的Get\_Page实现

位于/include/geekos/mem.h

/*
     * Get the index of the page in memory.
     */
    static __inline__ int Page_Index(ulong_t addr)
    {
        return (int) (addr >> PAGE_POWER);
    }
    
    /*
     * Get the Page struct associated with given address.
     */
    static __inline__ struct Page *Get_Page(ulong_t addr)
    {
        extern struct Page* g_pageList;
        return &g_pageList[Page_Index(addr)];
    }

明白了，每一个物理页的描述项都照物理页的内存地址从小到大在g\_pageList开始的内存地址整齐的存放着。  
比如说4K~8K这个1号物理页的Page结构(从0号开始)，在g\_pageList\[1\]中描述。

看Add\_Page\_Range下一句  
Add\_To\_Back\_Of\_Page\_List(&s\_freeList, page);  
居然找不到s\_freeList的定义，函数也找不到，包括下面的Set\_Next\_In\_Page\_List(page, 0)和Set\_Prev\_In\_Page\_List(page, 0);？？？？！！！！  
怎么搞的。。正好我先偷个懒。。。  
调试出来了，它跑到list.h里执行了一个很长的宏IMPLEMENT\_LIST(Page\_List, Page);  
原来在mem.h中声明了此宏  
IMPLEMENT\_LIST(Page\_List, Page);  
IMPLEMENT\_LIST就为以Page\_List为头，Page为节点类型的链表定义了一套方法。  
列一下好了

/*
     * Define inline list manipulation and access functions.
     */
    #define IMPLEMENT_LIST(LType, NType)								\
    static __inline__ void Clear_##LType(struct LType *listPtr) {					\
        listPtr->head = listPtr->tail = 0;								\
    }												\
    static __inline__ bool Is_Member_Of_##LType(struct LType *listPtr, struct NType *nodePtr) {	\
        struct NType *cur = listPtr->head;								\
        while (cur != 0) {										\
    	if (cur == nodePtr)									\
    	    return true;									\
    	cur = cur->next##LType;									\
        }												\
        return false;										\
    }												\
    static __inline__ struct NType * Get_Front_Of_##LType(struct LType *listPtr) {			\
        return listPtr->head;									\
    }												\
    static __inline__ struct NType * Get_Back_Of_##LType(struct LType *listPtr) {			\
        return listPtr->tail;									\
    }												\
    static __inline__ struct NType * Get_Next_In_##LType(struct NType *nodePtr) {			\
        return nodePtr->next##LType;								\
    }												\
    static __inline__ void Set_Next_In_##LType(struct NType *nodePtr, struct NType *value) {	\
        nodePtr->next##LType = value;								\
    }												\
    static __inline__ struct NType * Get_Prev_In_##LType(struct NType *nodePtr) {			\
        return nodePtr->prev##LType;								\
    }												\
    static __inline__ void Set_Prev_In_##LType(struct NType *nodePtr, struct NType *value) {	\
        nodePtr->prev##LType = value;								\
    }												\
    static __inline__ void Add_To_Front_Of_##LType(struct LType *listPtr, struct NType *nodePtr) {	\
        KASSERT(!Is_Member_Of_##LType(listPtr, nodePtr));						\
        nodePtr->prev##LType = 0;									\
        if (listPtr->head == 0) {									\
    	listPtr->head = listPtr->tail = nodePtr;						\
    	nodePtr->next##LType = 0;								\
        } else {											\
    	listPtr->head->prev##LType = nodePtr;							\
    	nodePtr->next##LType = listPtr->head;							\
    	listPtr->head = nodePtr;								\
        }												\
    }												\
    static __inline__ void Add_To_Back_Of_##LType(struct LType *listPtr, struct NType *nodePtr) {	\
        KASSERT(!Is_Member_Of_##LType(listPtr, nodePtr));						\
        nodePtr->next##LType = 0;									\
        if (listPtr->tail == 0) {									\
    	listPtr->head = listPtr->tail = nodePtr;						\
    	nodePtr->prev##LType = 0;								\
        }												\
        else {											\
    	listPtr->tail->next##LType = nodePtr;							\
    	nodePtr->prev##LType = listPtr->tail;							\
    	listPtr->tail = nodePtr;								\
        }												\
    }												\
    static __inline__ void Append_##LType(struct LType *listToModify, struct LType *listToAppend) {	\
        if (listToAppend->head != 0) {								\
    	if (listToModify->head == 0) {								\
    	    listToModify->head = listToAppend->head;						\
    	    listToModify->tail = listToAppend->tail;						\
    	} else {										\
    	    KASSERT(listToAppend->head != 0);							\
    	    KASSERT(listToModify->tail != 0);							\
    	    listToAppend->head->prev##LType = listToModify->tail;				\
    	    listToModify->tail->next##LType = listToAppend->head;				\
    	    listToModify->tail = listToAppend->tail;						\
    	}											\
        }												\
        listToAppend->head = listToAppend->tail = 0;						\
    }												\
    static __inline__ struct NType * Remove_From_Front_Of_##LType(struct LType *listPtr) {		\
        struct NType *nodePtr;									\
        nodePtr = listPtr->head;									\
        KASSERT(nodePtr != 0);									\
        listPtr->head = listPtr->head->next##LType;							\
        if (listPtr->head == 0)									\
    	listPtr->tail = 0;									\
        else											\
    	listPtr->head->prev##LType = 0;								\
        return nodePtr;										\
    }												\
    static __inline__ void Remove_From_##LType(struct LType *listPtr, struct NType *nodePtr) {	\
        KASSERT(Is_Member_Of_##LType(listPtr, nodePtr));						\
        if (nodePtr->prev##LType != 0)								\
    	nodePtr->prev##LType->next##LType = nodePtr->next##LType;				\
        else											\
    	listPtr->head = nodePtr->next##LType;							\
        if (nodePtr->next##LType != 0)								\
    	nodePtr->next##LType->prev##LType = nodePtr->prev##LType;				\
        else											\
    	listPtr->tail = nodePtr->prev##LType;							\
    }												\
    static __inline__ bool Is_##LType##_Empty(struct LType *listPtr) {				\
        return listPtr->head == 0;									\
    }

在调试中使用  
(gdb)ptype s\_freeList发现s\_freeList的类型是是  
struct Page\_List \{  
struct Page \*head;  
struct Page \*tail;  
\}

追宗溯源，看一下是怎么得出的。

在mem.c中s\_freeList是这样定义的  
static struct Page\_List s\_freeList;

在mem.h中有  
/\*  
\* List datatype for doubly-linked list of Pages.  
\*/  
DEFINE\_LIST(Page\_List, Page);

再看DEFINE\_LIST这个宏  
位于list.h中

/*
     * Define a list type.
     */
    #define DEFINE_LIST(listTypeName, nodeTypeName)         \
    struct listTypeName {                                   \
        struct nodeTypeName *head, *tail;                   \
    }

代入DEFINE\_LIST(Page\_List, Page)即得Page\_List结构  
struct Page\_List \{  
struct Page \*head, \*tail;  
\}

再结合Page结构  
struct Page \{  
unsigned flags;/\* Flags indicating state of page \*/  
struct Page \*prevPage\_List, \*nextPage\_List;/\*这里我把宏DEFINE\_LINK展开了\*/  
\};

来看这个函数的具体实现  
Add\_To\_Back\_Of\_Page\_List(&s\_freeList, page);  
看IMPLEMENT\_LIST宏对应的函数

static __inline__ void Add_To_Back_Of_##LType(struct LType *listPtr, struct NType *nodePtr) {	\
        KASSERT(!Is_Member_Of_##LType(listPtr, nodePtr));						\
        nodePtr->next##LType = 0;									\
        if (listPtr->tail == 0) {									\
    	listPtr->head = listPtr->tail = nodePtr;						\
    	nodePtr->prev##LType = 0;								\
        }												\
        else {											\
    	listPtr->tail->next##LType = nodePtr;							\
    	nodePtr->prev##LType = listPtr->tail;							\
    	listPtr->tail = nodePtr;								\
        }												\
    }

展开

static __inline__ void Add_To_Back_Of_Page_List(struct Page_List *listPtr, struct Page *nodePtr) {	\
        KASSERT(!Is_Member_Of_Page_List(listPtr, nodePtr));						\
        nodePtr->nextPage_List = 0;									\
        if (listPtr->tail == 0) {									\
    	listPtr->head = listPtr->tail = nodePtr;						\
    	nodePtr->prevPage_List = 0;								\
        }												\
        else {											\
    	listPtr->tail->nextPage_List = nodePtr;							\
    	nodePtr->prevPage_List = listPtr->tail;							\
    	listPtr->tail = nodePtr;								\
        }												\
    }

就是把page结构链入到双向链表末尾，这个双向链表是有个struct Page\_List头的。  
Add\_Page\_Range()完成的功能就是，如果一个物理页是可用的，把它的Page结构链入到双向链表中。  
物理页的Page结构照物理页的索引放在符号end后。

终于到最后一个函数了  
Init\_Heap(HIGHMEM\_START, KERNEL\_HEAP\_SIZE);  
初始化内核堆，最后系统分配了1M的内核堆。  
Init\_Heap函数实现在./src/geekos/malloc.c中

/*
     * Initialize the heap starting at given address and occupying
     * specified number of bytes.
     */
    void Init_Heap(ulong_t start, ulong_t size)
    {
        /*Print("Creating kernel heap: start=%lx, size=%ld\n", start, size);*/
        bpool((void*) start, size);
    }

调用的

bpool函数在内存池中加入一段内存。

位于./src/geekos/bget.c中

/*  BPOOL  --  Add a region of memory to the buffer pool.  */
    
    void bpool(buf, len)
      void *buf;
      bufsize len;
    {
        struct bfhead *b = BFH(buf);//将内存头部一段空间作为bfhead结构
        struct bhead *bn;
    
    #ifdef SizeQuant
        len &= ~(SizeQuant - 1);//分配需要SizeQuant个字节对齐，这里向下裁剪len。
    #endif
    #ifdef BECtl
        if (pool_len == 0) {//pool_len初始化为0，
    	pool_len = len;
        } else if (len != pool_len) {//-1表示不是所有分配的内存块大小都是相同的
    	pool_len = -1;
        }
    #ifdef BufStats
        numpget++;			      /* Number of block acquisitions */
        numpblk++;			      /* Number of blocks total */
        assert(numpblk == numpget - numprel);
    #endif /* BufStats */
    #endif /* BECtl */
    
        /* Since the block is initially occupied by a single free  buffer,
           it  had	better	not  be  (much) larger than the largest buffer
           whose size we can store in bhead.bsize. */
    						//调试发现右侧为4字节，有符号整数类型的最大正整数
        assert(len - sizeof(struct bhead) <= -((bufsize) ESent + 1));
    
        /* Clear  the  backpointer at  the start of the block to indicate that
           there  is  no  free  block  prior  to  this   one.    That   blocks
           recombination when the first block in memory is released. */
    
        b->bh.prevfree = 0;//0表示此块之前的内存块是已分配的，不能随意访问。
    
        /* Chain the new block to the free list. 将新的内存池结构体链接到链表中*/
    
        assert(freelist.ql.blink->ql.flink == &freelist);
        assert(freelist.ql.flink->ql.blink == &freelist);
        b->ql.flink = &freelist;			//blink表示先驱节点，flink表示后继节点。
        b->ql.blink = freelist.ql.blink;		//这里将结构插入到链表的头。
        freelist.ql.blink = b;
        b->ql.blink->ql.flink = b;
    
        /* Create a dummy allocated buffer at the end of the pool.	This dummy
           buffer is seen when a buffer at the end of the pool is released and
           blocks  recombination  of  the last buffer with the dummy buffer at
           the end.  The length in the dummy buffer  is  set  to  the  largest
           negative  number  to  denote  the  end  of  the pool for diagnostic
           routines (this specific value is  not  counted  on  by  the  actual
           allocation and release functions). */
    
        len -= sizeof(struct bhead);
        b->bh.bsize = (bufsize) len;
    #ifdef FreeWipe	//清空可用内存空间
        V memset(((char *) b) + sizeof(struct bfhead), 0x55,
    	     (MemSize) (len - sizeof(struct bfhead)));
    #endif		//在内存尾部添加bhead结构
        bn = BH(((char *) b) + len);
        bn->prevfree = (bufsize) len;//说明在此地址前面可用的内存大小
        /* Definition of ESent assumes two's complement! */
        assert((~0) == -1);
        bn->bsize = ESent;//在空间尾部放置最大的负数，来做标记。
    }

来看第一个BFH是什么  
位于./src/geekos/bget.c

#define BFH(p)  ((struct bfhead *) (p))

原来是一个宏，再看struct bfhead类型  
  
  
位于./src/geekos/bget.c

/* Header in free buffers */
    
    struct bfhead {
        struct bhead bh;		      /* Common allocated/free header */
        struct qlinks ql;		      /* Links on free list */
    };

bfhead结构将在内存池的首地址处。  
看bhead类型  
位于./src/geekos/bget.c

/* Header in allocated and free buffers */
    
    struct bhead {
        bufsize prevfree;		      /* Relative link back to previous
    					 free buffer in memory or 0 if
    					 previous buffer is allocated.	*/
        bufsize bsize;		      /* Buffer size: positive if free,
    					 negative if allocated. */
    };

prevfree用来存放在此之前的可用内存。  
bsize用来放最大的负数，以此作为标志。  
  
  
看qlinks类型，双链表结构  
位于./src/geekos/bget.c

/* Queue links */
    
    struct qlinks {
        struct bfhead *flink;	      /* Forward link */
        struct bfhead *blink;	      /* Backward link */
    };

初始化的内存池链表头freelist  
位于./src/geekos/bget.c

static struct bfhead freelist = {     /* List of free buffers */
        {0, 0},
        {&freelist, &freelist}
    };

到这里Init\_Mem初始化内存就完成了。可以看到在Init\_Mem中我们填充了保护模式下的GDT，在内存end地址后面为系统内存的每一个物理页建立了Page描述结构，并且初始化了内核1M的堆空间。

到这里Init\_Mem分析完毕。