《操作系统真象还原》第十二章 ---- 实现系统调用深入浅出进一步完善堆内存分配与Printf函数让用户进程有话可说（下）

迈不过友情╰ 2022-09-02 12:51 65阅读 0赞

### 文章目录 ###

*   *  专栏博客链接
     *  相关查阅博客链接
     *  本书中错误勘误
     *  实现堆内存管理（实现malloc部分）
     *   *  修改完的memory.h
         *  修改完的memory.c
         *  修改完的thread.c（task\_struct部分）
         *  修改完的process.c(process\_execute函数)
         *  修改完的memory.c
         *  修改完的makefile
         *  修改后的main.c
         *  make all 验证成果
     *  实现free函数
     *   *  修改后的memory.c
         *  修改后的memory.h
         *  修改后的main.c
         *  make all 验收成果
     *  结束语

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

## 专栏博客链接 ##

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

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

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

## 相关查阅博客链接 ##

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

**[C语言static 关键字总结][C_static]**

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

## 本书中错误勘误 ##

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

## 实现堆内存管理（实现malloc部分） ##

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

**这部分呢 哈哈 说实话 其实我觉得各位看官把代码看懂就行了  
虽然我还是从上到下挨个代码一行行的看完理解完了 把`malloc`实现了再过来写的 但是呢 哈哈 这部分真从头让我写 确实写不出来**

**构局的缜密 而且各种小细节 哈哈 果然还是积聚了很多很多人的智慧写出来的操作系统 不容易啊 不容易 为了局部性和连贯性考虑 我还是一部分一部分的放 就先放实现`malloc`当前的代码吧 很多地方呢 我还是加了注释 那就走起**

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

### 修改完的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);
    #endif

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

### 修改完的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 = (struct mem_block*)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;
        }
    }

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

### 修改完的thread.c（task\_struct部分） ###

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

struct task_struct
    { 
        uint32_t* self_kstack;                          //pcb中的 kernel_stack 内核栈
        pid_t pid;
        enum task_status status;                        //线程状态
        uint8_t priority;				      //特权级
        uint8_t ticks;				      //在cpu 运行的滴答数 看ticks 来判断是否用完了时间片
        uint32_t elapsed_ticks;                         //一共执行了多久
        char name[16];
        
        struct list_elem general_tag;                   //就绪队列中的连接节点
        struct list_elem all_list_tag;		      //总队列的连接节点
        
        uint32_t* pgdir;				      //进程自己页表的虚拟地址 线程没有 
        struct virtual_addr userprog_vaddr;	      //用户进程的虚拟空间 
        struct mem_block_desc u_block_desc[DESC_CNT];   //内存块描述符
        uint32_t stack_magic;			      //越界检查 因为我们pcb上面的就是我们要用的栈了 到时候还要越界检查
    };

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

### 修改完的process.c(process\_execute函数) ###

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

**需要增加加头文件 我直接把头文件全放出来**

#include "tss.h"
    #include "process.h"
    #include "string.h"
    #include "global.h"
    #include "memory.h"
    #include "print.h"
    #include "../thread/thread.h"
    #include "../kernel/interrupt.h"
    #include "debug.h"
    #include "../device/console.h"

void process_execute(void* filename,char* name)
    { 
        struct task_struct* thread = get_kernel_pages(1);  //分配一页空间 得到pcb
        init_thread(thread,name,default_prio);		 //初始化pcb
        create_user_vaddr_bitmap(thread);			 //为虚拟地址位图初始化 分配空间
        thread_create(thread,start_process,filename);	 //创造线程 start_process 之后通过start_process intr_exit跳转到用户进程
        thread->pgdir = create_page_dir();		 //把页目录表的地址分配了 并且把内核的页目录都给复制过去 这样操作系统对每个进程都可见
        block_desc_init(thread->u_block_desc);
        
        enum intr_status old_status = intr_disable();     
        ASSERT(!elem_find(&thread_ready_list,&thread->general_tag));
        list_append(&thread_ready_list,&thread->general_tag);     //添加线程 start_process到就绪队列中
        
        ASSERT(!elem_find(&thread_all_list,&thread->all_list_tag));
        list_append(&thread_all_list,&thread->all_list_tag);
        intr_set_status(old_status);
    }

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

### 修改完的memory.c ###

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

### 修改完的makefile ###

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

BUILD_DIR = ./build
    ENTRY_POINT = 0xc0001500
    AS = nasm
    CC = gcc
    LD = ld
    LIB = -I lib/ -I lib/kernel/ -I lib/user/ -I kernel/ -I device/ 
    ASFLAGS = -f elf
    CFLAGS = -Wall -m32 -fno-stack-protector $(LIB) -c -fno-builtin -W -Wstrict-prototypes -Wmissing-prototypes
    LDFLAGS =  -m elf_i386 -Ttext $(ENTRY_POINT) -e main -Map $(BUILD_DIR)/kernel.map
    OBJS = $(BUILD_DIR)/main.o $(BUILD_DIR)/init.o $(BUILD_DIR)/interrupt.o \
          $(BUILD_DIR)/timer.o $(BUILD_DIR)/kernel.o $(BUILD_DIR)/print.o $(BUILD_DIR)/switch.o \
          $(BUILD_DIR)/debug.o $(BUILD_DIR)/string.o $(BUILD_DIR)/memory.o \
          $(BUILD_DIR)/bitmap.o $(BUILD_DIR)/thread.o $(BUILD_DIR)/list.o \
          $(BUILD_DIR)/sync.o $(BUILD_DIR)/console.o $(BUILD_DIR)/keyboard.o \
          $(BUILD_DIR)/ioqueue.o $(BUILD_DIR)/tss.o $(BUILD_DIR)/process.o \
          $(BUILD_DIR)/syscall-init.o $(BUILD_DIR)/syscall.o $(BUILD_DIR)/stdio.o
          
    ##############     c代码编译     ###############
    $(BUILD_DIR)/main.o: kernel/main.c lib/kernel/print.h \
            lib/stdint.h kernel/init.h lib/string.h kernel/memory.h \
            thread/thread.h kernel/interrupt.h device/console.h \
            device/keyboard.h device/ioqueue.h userprog/process.h \
            lib/user/syscall.h userprog/syscall-init.h lib/stdio.h
    	$(CC) $(CFLAGS) $< -o $@
    
    $(BUILD_DIR)/init.o: kernel/init.c kernel/init.h lib/kernel/print.h \
            lib/stdint.h kernel/interrupt.h device/timer.h kernel/memory.h \
            thread/thread.h device/console.h device/keyboard.h userprog/tss.h \
            userprog/syscall-init.h
    	$(CC) $(CFLAGS) $< -o $@
    
    $(BUILD_DIR)/interrupt.o: kernel/interrupt.c kernel/interrupt.h \
            lib/stdint.h kernel/global.h lib/kernel/io.h lib/kernel/print.h \
            kernel/kernel.h
    	$(CC) $(CFLAGS) $< -o $@
    
    $(BUILD_DIR)/timer.o: device/timer.c device/timer.h lib/kernel/io.h lib/kernel/print.h \
            kernel/interrupt.h thread/thread.h kernel/debug.h
    	$(CC) $(CFLAGS) $< -o $@
    
    $(BUILD_DIR)/debug.o: kernel/debug.c kernel/debug.h \
            lib/kernel/print.h lib/stdint.h kernel/interrupt.h
    	$(CC) $(CFLAGS) $< -o $@
    	
    $(BUILD_DIR)/string.o: lib/string.c lib/string.h \
    	kernel/debug.h kernel/global.h
    	$(CC) $(CFLAGS) $< -o $@
    	
    $(BUILD_DIR)/memory.o: kernel/memory.c kernel/memory.h \
    	lib/stdint.h lib/kernel/bitmap.h kernel/debug.h lib/string.h kernel/global.h \
    	thread/sync.h thread/thread.h lib/kernel/list.h kernel/interrupt.h
    	$(CC) $(CFLAGS) $< -o $@
    	
    $(BUILD_DIR)/bitmap.o: lib/kernel/bitmap.c lib/kernel/bitmap.h kernel/global.h \
    	lib/string.h kernel/interrupt.h lib/kernel/print.h kernel/debug.h
    	$(CC) $(CFLAGS) $< -o $@
    	
    $(BUILD_DIR)/thread.o: thread/thread.c thread/thread.h \
    	lib/stdint.h lib/string.h kernel/global.h kernel/memory.h \
    	kernel/debug.h kernel/interrupt.h lib/kernel/print.h \
    	userprog/process.h thread/sync.h
    	$(CC) $(CFLAGS) $< -o $@
    	
    $(BUILD_DIR)/list.o: lib/kernel/list.c lib/kernel/list.h \
    	kernel/interrupt.h lib/stdint.h kernel/debug.h
    	$(CC) $(CFLAGS) $< -o $@
    	
    $(BUILD_DIR)/sync.o: thread/sync.c thread/sync.h \
    	lib/stdint.h thread/thread.h kernel/debug.h kernel/interrupt.h
    	$(CC) $(CFLAGS) $< -o $@
    	
    $(BUILD_DIR)/console.o: device/console.c device/console.h \
    	lib/kernel/print.h thread/sync.h
    	$(CC) $(CFLAGS) $< -o $@
    	
    $(BUILD_DIR)/keyboard.o: device/keyboard.c device/keyboard.h \
    	lib/kernel/print.h lib/kernel/io.h kernel/interrupt.h \
    	kernel/global.h lib/stdint.h device/ioqueue.h
    	$(CC) $(CFLAGS) $< -o $@
    	
    $(BUILD_DIR)/ioqueue.o: device/ioqueue.c device/ioqueue.h \
    	kernel/interrupt.h kernel/global.h kernel/debug.h
    	$(CC) $(CFLAGS) $< -o $@
    	
    $(BUILD_DIR)/tss.o: userprog/tss.c userprog/tss.h \
    	kernel/global.h thread/thread.h lib/kernel/print.h
    	$(CC) $(CFLAGS) $< -o $@
    	
    $(BUILD_DIR)/process.o: userprog/process.c userprog/process.h \
    	lib/string.h kernel/global.h kernel/memory.h lib/kernel/print.h \
    	thread/thread.h kernel/interrupt.h kernel/debug.h device/console.h
    	$(CC) $(CFLAGS) $< -o $@
    	
    $(BUILD_DIR)/syscall-init.o: userprog/syscall-init.c userprog/syscall-init.h \
    	lib/user/syscall.h lib/stdint.h lib/kernel/print.h kernel/interrupt.h thread/thread.h
    	$(CC) $(CFLAGS) $< -o $@
    	
    $(BUILD_DIR)/syscall.o: lib/user/syscall.c lib/user/syscall.h 
    	$(CC) $(CFLAGS) $< -o $@
    
    $(BUILD_DIR)/stdio.o: lib/stdio.c lib/stdio.h lib/stdint.h lib/string.h lib/user/syscall.h
    	$(CC) $(CFLAGS) $< -o $@
    	
    ##############    汇编代码编译    ###############
    $(BUILD_DIR)/kernel.o: kernel/kernel.S
    	$(AS) $(ASFLAGS) $< -o $@
    
    $(BUILD_DIR)/print.o: lib/kernel/print.S
    	$(AS) $(ASFLAGS) $< -o $@
    
    $(BUILD_DIR)/switch.o: thread/switch.S
    	$(AS) $(ASFLAGS) $< -o $@
    
    ##############    链接所有目标文件    #############
    $(BUILD_DIR)/kernel.bin: $(OBJS)
    	$(LD) $(LDFLAGS) $^ -o $@
    
    .PHONY : mk_dir hd clean all
    
    mk_dir:
    	if [ ! -d $(BUILD_DIR) ]; then mkdir $(BUILD_DIR); fi
    
    hd:
    	dd if=$(BUILD_DIR)/kernel.bin \
               of=/home/cooiboi/bochs/hd60M.img \
               bs=512 count=200 seek=9 conv=notrunc
    
    clean:
    	cd $(BUILD_DIR) && rm -f  ./* build: $(BUILD_DIR)/kernel.bin all: mk_dir build hd

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

### 修改后的main.c ###

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

### make all 验证成果 ###

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

**看成果应该是ok了 此时的网页已经超级卡了 后面还有些内容我就加到一起来写了**![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTAwNTE2_size_16_color_FFFFFF_t_70][]

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

## 实现free函数 ##

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

\*\*实话实说 哈哈 里面的大部分内容我都是看了一眼就直接写上去了 没有多想 因为内存分配的那个地方我就是看懂了就直接写上去了 没有太多印象 而且今天人也比较困 理解一下老年人吧 只不过最后我调试了半小时 发现之前的用户进程的虚拟地址管理出现了点问题 这个在文末的时候会将 \*\*

**那代码就直接走起**

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

### 修改后的memory.c ###

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

**这里是我在写第十四章的时候 回来来写的  
为什么会二次编辑呢 呜呜 因为写到第十四章的中间因为这里有两行代码写错了 而导致后面  
`asm volatile ("movl %0,%%cr3" : : "r"(pagedir_phy_addr) : "memory");`页表切换错误 导致了我debug了五个小时才慢慢一点点找到 服了  
希望大家还是写的时候仔细一点 不要出现我这种情况**

#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 = (struct mem_block*)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);
        }
    }

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

### 修改后的memory.h ###

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

### 修改后的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"
    
    void k_thread_a(void* );
    void k_thread_b(void* );
    void u_prog_a (void);
    void u_prog_b (void);
    
    int main(void) { 
       put_str("I am kernel\n");
       init_all();
    
       intr_enable();
       process_execute(u_prog_a, "u_prog_a");
       process_execute(u_prog_b, "u_prog_b"); 
       thread_start("k_thread_a", 31, k_thread_a, "argA ");
       thread_start("k_thread_b", 31, k_thread_b, "argB ");  
       while(1);
       return 0;
    }
    
    void k_thread_a(void* arg){ 
    
    	void* addr1 = sys_malloc(256);
    	void* addr2 = sys_malloc(255);
    	void* addr3 = sys_malloc(254);
    	console_put_str(" thread_a malloc addr:0x");
    	console_put_int((int)addr1);
    	console_put_char(',');
    	console_put_int((int)addr2);
    	console_put_char(',');
    	console_put_int((int)addr3);
    	console_put_char('\n');
    	int cpu_delay = 100000;
    	while(cpu_delay-->0);
    	sys_free(addr1);
    	sys_free(addr2);
    	sys_free(addr3);
    	while(1);
    }
    
    void k_thread_b(void* arg){ 
    	void* addr1 = sys_malloc(256);
    	void* addr2 = sys_malloc(255);
    	void* addr3 = sys_malloc(254);
    	console_put_str(" thread_b malloc addr:0x");
    	console_put_int((int)addr1);
    	console_put_char(',');
    	console_put_int((int)addr2);
    	console_put_char(',');
    	console_put_int((int)addr3);
    	console_put_char('\n');
    	int cpu_delay = 100000;
    	while(cpu_delay-->0);
    	sys_free(addr1);
    	sys_free(addr2);
    	sys_free(addr3);
    	while(1);
    }
    
    void u_prog_a(void) { 
    	void* addr1 = malloc(256);
    	void* addr2 = malloc(255);
    	void* addr3 = malloc(254);
    	printf(" prog_a malloc addr:0x%x, 0x%x, 0x%x\n", (int)addr1,(int)addr2,(int)addr3);
    	int cpu_delay = 100000;
    	while(cpu_delay-->0);
    	free(addr1);
    	free(addr2);
    	free(addr3);
    	while(1);
    }
    
    void u_prog_b(void) { 
    	void* addr1 = malloc(256);
    	void* addr2 = malloc(255);
    	void* addr3 = malloc(254);
    	printf(" prog_b malloc addr:0x%x, 0x%x, 0x%x\n", (int)addr1,(int)addr2,(int)addr3);
    	int cpu_delay = 100000;
    	while(cpu_delay-->0);
    	free(addr1);
    	free(addr2);
    	free(addr3);
    	while(1);
    }

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

### make all 验收成果 ###

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

**ok了 homie 没问题了 那这一章就到此结束了！ 感谢一直看到这里 哈哈**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTAwNTE2_size_16_color_FFFFFF_t_70 1]

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

## 结束语 ##

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

**因为觉得浏览起来不方便 于是把十二章一篇改成两篇上下了 哈哈 闲聊没什么好聊的 想去睡会觉了 IT人也是很辛苦的 哈哈 睡觉去了~**

[Link 1]: https://love6.blog.csdn.net/article/details/119133589
[C_static]: https://blog.csdn.net/t595180928/article/details/80448249
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTAwNTE2_size_16_color_FFFFFF_t_70]: /images/20220829/38822858ffff4d9798135e46a0974ad4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTAwNTE2_size_16_color_FFFFFF_t_70 1]: /images/20220829/4119fa1706874fedb2f5269655c3bbea.png