《操作系统30天》-合川秀实-学习日志day9

清疚 2022-03-22 07:18 179阅读 0赞

# 一、整理源文件 #

*  改造bootpack.c文件，整理程序：

![20190126205653827.png][]

*  键盘中断放在keyboard.c中，鼠标中断放在mouse.c中，这样程序看起来简洁清晰

![20190126205713885.png][]

*  在bootpack.c分了两个头文件出来之后，需要在makefile中的objs\_bootpack中添加相应的.obj文件（编译后的二进制文件）

# 二、内存检查 #

*  对内存检查前，要关闭高速缓存。如果不关闭高速缓存，我们往内存中写数据会直接保存到高速缓存中，再次查询会直接从高速缓存中查找，这样就不能实现内存检查。386的CPU没有缓存，所以要先检查CPU是386还是486。

程序如下图所示：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2ODA0MzYz_size_16_color_FFFFFF_t_70][]

#define EFLAGS_AC_BIT		0x00040000
    #define CR0_CACHE_DISABLE	0x60000000
    
    unsigned int memtest(unsigned int start, unsigned int end)
    {
    	char flg486 = 0;
    	unsigned int eflg, cr0, i;
    
    	/* 确认CPU是386还是486以上的 */
    	eflg = io_load_eflags();
    	eflg |= EFLAGS_AC_BIT; /* AC-bit = 1 */
    	io_store_eflags(eflg);
    	eflg = io_load_eflags();
    	if ((eflg & EFLAGS_AC_BIT) != 0) { /* 如果是386，即使设定AC=1，AC的值还会自动回到0 */
    		flg486 = 1;
    	}
    	eflg &= ~EFLAGS_AC_BIT; /* AC-bit = 0 */
    	io_store_eflags(eflg);
    
    	if (flg486 != 0) {
    		cr0 = load_cr0();
    		cr0 |= CR0_CACHE_DISABLE; /*禁止缓存 */
    		store_cr0(cr0);
    	}
    
    	i = memtest_sub(start, end);
    
    	if (flg486 != 0) {
    		cr0 = load_cr0();
    		cr0 &= ~CR0_CACHE_DISABLE; /* 允许缓存 */
    		store_cr0(cr0);
    	}
    
    	return i;
    }
    代码所用到的load_cr0和store_cr0只能用汇编语言实现：
    _load_cr0:		; int load_cr0(void);
    		MOV		EAX,CR0
    		RET
    
    _store_cr0:		; void store_cr0(int cr0);
    		MOV		EAX,[ESP+4]
    		MOV		CR0,EAX
    		RET
    Memtest_sub函数是内存检查处理的实现部分：
    unsigned int memtest_sub(unsigned int start, unsigned int end)
    {
    	unsigned int i, *p, old, pat0 = 0xaa55aa55, pat1 = 0x55aa55aa;
    	for (i = start; i <= end; i += 0x1000[作者本来是+4，运行时速度太慢改成了+0x1000，相当于4kb，速度提高1000倍。下面的p赋值本身是p=i（只检查开头的四个字节）现在修改成p=i+0xffc只检查末尾四个字节]) {
    		p = (unsigned int *) (i + 0xffc);
    		old = *p;			/* 先记住修改前的值 */
    		*p = pat0;			/* 试写 */
    		*p ^= 0xffffffff;		/* 反转	 */
    		if (*p != pat1) {		/* 检查反转结果 */
    not_memory:
    			*p = old;
    			break;
    		}
    		*p ^= 0xffffffff;	/* 再次反转 */
    		if (*p != pat0) {	/* 检查值是否恢复 */
    			goto not_memory;
    		}
    		*p = old;			/* 恢复为修改前的值 */
    	}
    	return i;
    }

程序所做的事情：

![20190126210047915.png][]

最后恢复为修改前的old。以上每次检查如果出错都会在那个环节停止并返回终止地址。

主函数中加入：

i = memtest(0x00400000, 0xbfffffff) 	/ (1024 * 1024);
    	        sprintf(s, "memory %dMB", i);
    		putfonts8_asc(binfo->vram, binfo->scrnx, 0, 32, COL8_FFFFFF, s);

暂时先用以上程序对0x00400000~0xbfffffff的内存检查，最大可以识别3GB内存。0x00400000号以上的内存已被占用（下图），内存单位为MB。

![201901262102373.png][]

运行结果为3072MB

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2ODA0MzYz_size_16_color_FFFFFF_t_70 1][]

# 三、优化容量检查（改错） #

_memtest_sub:
    	PUSH	EBP						；C编译器的固定语句
    	MOV	EBP,ESP
    	MOV	EDX,DWORD [12+EBP]		；EDX=end；
    	MOV	EAX,DWORD [8+EBP]		；EAX=start；/*EAX是i*/
    	CMP	EAX,EDX					；if（EAX>EDX） goto L30
    	JA	L30
    L36:
    L34:
    	ADD	EAX,4096					；EAX+=0x1000
    	CMP	EAX,EDX					；if（EAX<=EDX）goto L36
    	JBE	L36	
    L30:
    	POP	EBP							；接收前文中的PUSH的EBP
    	RET									；return

与memtest\_sub比较，发现编译结果连异或语句都没有。分析编译器编译过程：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2ODA0MzYz_size_16_color_FFFFFF_t_70 2][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2ODA0MzYz_size_16_color_FFFFFF_t_70 3][]

编译器做了最优化处理，作者最后用汇编写memtest\_sub。保存在naskfunc.nas中：

_memtest_sub:	; unsigned int memtest_sub(unsigned int start, unsigned int end)
    		PUSH	EDI						; （由于还要使用EBX, ESI, EDI）
    		PUSH	ESI
    		PUSH	EBX
    		MOV		ESI,0xaa55aa55			; pat0 = 0xaa55aa55;
    		MOV		EDI,0x55aa55aa			; pat1 = 0x55aa55aa;
    		MOV		EAX,[ESP+12+4]			; i = start;
    mts_loop:
    		MOV		EBX,EAX
    		ADD		EBX,0xffc				; p = i + 0xffc;
    		MOV		EDX,[EBX]				; old = *p;
    		MOV		[EBX],ESI				; *p = pat0;
    		XOR		DWORD [EBX],0xffffffff		; *p ^= 0xffffffff;
    		CMP		EDI,[EBX]				; if (*p != pat1) goto fin;
    		JNE		mts_fin
    		XOR		DWORD [EBX],0xffffffff		; *p ^= 0xffffffff;
    		CMP		ESI,[EBX]				; if (*p != pat0) goto fin;
    		JNE		mts_fin
    		MOV		[EBX],EDX				; *p = old;
    		ADD		EAX,0x1000				; i += 0x1000;
    		CMP		EAX,[ESP+12+8]			; if (i <= end) goto mts_loop;
    		JBE		mts_loop
    		POP		EBX
    		POP		ESI
    		POP		EDI
    		RET
    mts_fin:
    		MOV		[EBX],EDX				; *p = old;
    		POP		EBX
    		POP		ESI
    		POP		EDI
    		RET

根据注释，汇编对应C语言的工作，最后运行结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2ODA0MzYz_size_16_color_FFFFFF_t_70 4][]

# 四、内存管理 #

什么是内存管理？

内存管理的基础：内存分配，内存释放

![20190126210708790.png][]

作者举例说明：

假设有128MB=0x08000000个字节的内存，假设以0x1000（4KB）管理，根据0x08000000/0x1000=0x08000=32768得

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2ODA0MzYz_size_16_color_FFFFFF_t_70 5][]

以上方法好理解但是如果内存过大，管理表也会因此变大，虽然最后计算出所占的比例之后0.02%，如果要用这种方法且使管理表尽量小，那么可以用bit来构成管理表，这样管理表可以缩减到原来的1/8，如果内存是3GB那么管理表大小![20190126210838291.png][]这样算出的比例为0.003%。

第二种方法是类似于“从xxx号地址开始的yyy字节的空间是空着的”这种信息存在表里：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2ODA0MzYz_size_16_color_FFFFFF_t_70 6][]

第二种方法比第一种占用的内存少，memman=8x1000+4，不到8KB的大小。除所占空间小之外，在分配内存时，运算只需要执行一次，缺点在于管理程序复杂，空间零碎，有些小块内存没有空余的信息表可用智能被割舍，作者用这种方法的同时，实现把小块内存找回。

#define MEMMAN_FREES		4090	/* 大约是32KB */
    #define MEMMAN_ADDR			0x003c0000
    
    struct FREEINFO {	/* 可用信息 */
    	unsigned int addr, size;
    };
    struct MEMMAN {		/* 内存管理 */
    	int frees, maxfrees, lostsize, losts;
    	struct FREEINFO free[MEMMAN_FREES];
    };
    	void memman_init(struct MEMMAN *man[内存初始化函数，全部置0处理]) 
    {
    	man->frees = 0;			/* 可用信息数目 */
    	man->maxfrees = 0;		/* 用于观察可用状况：frees的最大値 */
    	man->lostsize = 0;		/* 释放失败的内存的大小总和 */
    	man->losts = 0;			/* 释放失败次数 */
    	return;
    }
    
    unsigned int memman_total(struct MEMMAN *man[计算的是全部空余内存的大小，不连续的加起来])
    /* 报告空余内存大小的合计 */
    {
    	unsigned int i, t = 0;
    	for (i = 0; i < man->frees; i++) {
    		t += man->free[i].size;
    	}
    	return t;
    }
    
    unsigned int memman_alloc(struct MEMMAN *man, unsigned int size)
    /*分配 */
    {
    	unsigned int i, a;
    	for (i = 0; i < man->frees; i++) {
    		if (man->free[i].size >= size) {
    			/* 找到足够大的内存[找到时，地址往后移size大小，同时本身的size-分出去的size，如果size=0，表示刚好用完说明该块不可用，减去] */
    			a = man->free[i].addr;
    			man->free[i].addr += size;
    			man->free[i].size -= size;
    			if (man->free[i].size == 0) {
    				/* 如果free[i]变成0，就剪掉一条可用信息 */
    				man->frees--;
    				for (; i < man->frees; i++) {
    					man->free[i] = man->free[i + 1]; /* 代入结构体[结构体赋值方法，可以直接赋值，表示结构体中的信息（size，addr一致）] */
    				}
    			}
    			return a;
    		}
    	}
    	return 0; /*没有可用空间 */
    }
    	
    	释放内存函数：
    int memman_free(struct MEMMAN *man, unsigned int addr, unsigned int size)
    /* 释放 */
    {
    	int i, j;
    	/* 为便于归纳内存，将free[]按照addr的顺序排列 */
    	/* 所以，先决定应该放在哪里*/
    	for (i = 0; i < man->frees; i++) {
    		if (man->free[i].addr > addr[从i=0开始找，如果addr后面有可用的内存那么此时i保持找到内存的值，退出。此时的i大于0]) {
    			break;
    		}
    	}
    	/* free[i - 1].addr < addr < free[i].addr */
    	if (i > 0) {
    		/*前面有可用内存 */
    		if (man->free[i - 1].addr + man->free[i - 1].size == addr) {
    			/* 可以与前面的可用内存归纳到一起 */
    			man->free[i - 1].size += size;
    			if (i < man->frees) {
    				/*后面也有 */
    				if (addr + size == man->free[i].addr) {
    					/* 也可以与后面的可用内存归纳到一起 */
    					man->free[i - 1].size += man->free[i].size;
    					/* man->free[i]删除 */
    					/* free[i]变成0后归纳到前面去 */
    					man->frees--;
    					for (; i < man->frees; i++) {
    						man->free[i] = man->free[i + 1]; /* 结构体赋值 */
    					}
    				}
    			}
    			return 0; /* 成功完成 */
    		}
    	}
    	/* 不能与前面的可用空间归纳到一起 */
    	if (i < man->frees) {
    		/* 后面还有 */
    		if (addr + size == man->free[i].addr) {
    			/* 可以与后面的归纳到一起 */
    			man->free[i].addr = addr;
    			man->free[i].size += size;
    			return 0; /* 成功完成*/
    		}
    	}
    	/* 既不能与前面归纳到一起，也不能与后面的归纳到一起 */
    	if (man->frees < MEMMAN_FREES[如果前面两种情况都不满足，那么此时应先判断是否溢出，如果frees满了那么就不会保存了，返回失败，lost++]) {
    		/* free[i]之后的，向后移动，腾出一点可用空间 */
    		for (j = man->frees; j > i; j--) {
    			man->free[j] = man->free[j - 1];
    		}
    		man->frees++;
    		if (man->maxfrees < man->frees) {
    			man->maxfrees = man->frees; /* 更新最大值 */
    		}
    		man->free[i].addr = addr;
    		man->free[i].size = size;
    		return 0; /* 成功完成*/
    	}
    	/* 不能往后移动 */
    	man->losts++;
    	man->lostsize += size;
    	return -1; /* 失败 */
    }

放入主函数中：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2ODA0MzYz_size_16_color_FFFFFF_t_70 7][]

释放了0x00001000开始0x0009e000大小和4MB后面的内存。

这个函数主要表达的意思：

*  第一种情况：若此时的addr=free\[i-1\]+size且man\[i-1\]+size+size（新的）=free\[i\].addr说明刚好放进去，此时三个合并，frees--，后面的结构体往前移，如下图所示：

![20190126211116886.png][]

*  第二种情况：若此时的addr=free\[i-1\]+size后面没有空间或者不满足man\[i-1\]+size+size（新的）=free\[i\].addr，则只是把新的和free\[i-1\]合并，如下图所示：

![20190126211143515.png][]

*  第三种情况：若此时找到的i<frees（最大值）且addr+size=man.free\[i\].addr说明刚好与后面的块连接，如下图所示：

![20190126211200270.png][]

*  第四种情况：若此时找到的i<frees（最大值）但是上面三种情况都不满足，只能新建一个free\[i\],后面的块往后一个挪一位，frees++如下图所示：

![20190126211205346.png][]

*  如果都都不满足条件说明释放失败！lost+1，下面是运行结果

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2ODA0MzYz_size_16_color_FFFFFF_t_70 8][]

[20190126205653827.png]: /images/20220322/f89aaa3d878342239bc1bfd9d0c8aa2d.png
[20190126205713885.png]: /images/20220322/99263e9fba984f6c9f40a934b5aa5749.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2ODA0MzYz_size_16_color_FFFFFF_t_70]: /images/20220322/578dd5ff555249c6a158fba53a43c0cd.png
[20190126210047915.png]: /images/20220322/5737bf287ab245df8fc6250233f173d1.png
[201901262102373.png]: /images/20220322/4c93d3d5e1ad401594b9436c443aedea.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2ODA0MzYz_size_16_color_FFFFFF_t_70 1]: /images/20220322/de4123e2578240faa37a53632eeab969.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2ODA0MzYz_size_16_color_FFFFFF_t_70 2]: /images/20220322/584e19a868714d6a8ddfce21c961a155.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2ODA0MzYz_size_16_color_FFFFFF_t_70 3]: /images/20220322/13bfe2f8dfab47ba8e51295dc3a62a93.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2ODA0MzYz_size_16_color_FFFFFF_t_70 4]: /images/20220322/cb8c4f4d9110476b90ad132fc90b699f.png
[20190126210708790.png]: /images/20220322/1224f91f5e2d4d35ac957bfa43f80293.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2ODA0MzYz_size_16_color_FFFFFF_t_70 5]: /images/20220322/582e9d9f374a42d089a66c98e31942c2.png
[20190126210838291.png]: /images/20220322/3d52575f1f26467ea62655d64f2c22d2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2ODA0MzYz_size_16_color_FFFFFF_t_70 6]: /images/20220322/323782d046a74a0da52d10e5bd44628d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2ODA0MzYz_size_16_color_FFFFFF_t_70 7]: /images/20220322/519acbd919c64250b970f79d6482a4ef.png
[20190126211116886.png]: /images/20220322/0f81ed4fb3994d38a7e96459c0f9c73f.png
[20190126211143515.png]: /images/20220322/92c33e4df51c4cf59e9d24e8ba2698a9.png
[20190126211200270.png]: /images/20220322/0d3da1ef78ab4817bf008b38c8f580bd.png
[20190126211205346.png]: /images/20220322/c2b51409b7934e0f84a4fee27c38e827.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2ODA0MzYz_size_16_color_FFFFFF_t_70 8]: /images/20220322/b231394464654cc89d2bfdabc5d9252f.png