devbox
代码优化者
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

获取物理内存容量(下)

作者：代码优化者 | 2024-02-04 13:16:46

赞

踩

获取物理内存容量(下)

我们这节课BIOS提供的(int 0x15)号中断的高级功能(eax = 0xE820)，遍历主机上所有的内存范围(内存地址段)，获取各个内存范围的详细信息

int 0x15 进阶版功能

中断参数

  • eax = 0xE820 (固定值)
  • edx = 0x534D4150 (固定值)
  • ebx --> 初始参数必须为0，终止标志
  • ecx --> ARDS 结构体大小 (20字节)
  • es : di --> ARDS 结构体数组 (每个元素占用20字节)



地址范围描述结构 (Address Range Descriptor Structure)

int 0x15 进阶功能示例

  1. %include "inc.asm"
  2.  
  3. org 0x9000
  4.  
  5. jmp ENTRY_SEGMENT
  6.  
  7. [section .gdt]
  8. ; GDT definition
  9. ;                                 段基址，       段界限，       段属性
  10. GDT_ENTRY		: Descriptor		0, 			    0,		      0
  11. CODE32_DESC		: Descriptor		0, 	   Code32SegLen - 1,  DA_32 + DA_C
  12. VIDEO_DESC	    : Descriptor     0xb8000,       0x7fff,       DA_32 + DA_DRWA
  13. DATA32_DESC		: Descriptor	    0,     Data32SegLen - 1,  DA_32 + DA_DRW
  14. STACK32_DESC	: Descriptor        0,      TopOfStack32,     DA_32 + DA_DRW
  15. ; GDT end  
  16.  
  17. GdtLen	  equ	   $ - GDT_ENTRY
  18. GdtPtr:    
  19. 		dw	GdtLen - 1
  20. 		dd	0
  21.  
  22. ; GDT Selector
  23. Code32Selector	equ    (0x0001 << 3) + SA_TIG + SA_RPL0
  24. VideoSelector	equ    (0x0002 << 3) + SA_TIG + SA_RPL0
  25. Data32Selector  equ    (0x0003 << 3) + SA_TIG + SA_RPL0
  26. Stack32Selector equ    (0x0004 << 3) + SA_TIG + SA_RPL0
  27. ; end of [section .gdt]
  28.  
  29. TopOfStack16	equ    0x7c00
  30.  
  31. ; get hardware memory infomation
  32. MEM_SIZE	  times	   4     db  0x00	; int mem_size = 0
  33. MEM_ARDS_NUM  times    4     db  0x00	; int men_addr_num = 0
  34. MEM_ARDS	  times 20 * 64  db  0x00	; ARDS mem_adrs[64] = {0}
  35.  
  36. [section .dat]
  37. [bits 32]
  38. DATA32_SEGMENT:
  39. 	DTOS		        db    "D.T.OS!", 0
  40. 	DTOS_Offset	        equ	  DTOS - $$ 
  41.  
  42. 	HELLOWORLD		    db    "Hello, World!", 0
  43. 	HELLOWORLD_Offset   equ   HELLOWORLD - $$
  44.  
  45. Data32SegLen	equ   $ - DATA32_SEGMENT
  46.  
  47. [section .s16]
  48. [bits 16]
  49. ENTRY_SEGMENT:
  50. 	mov ax, cs
  51. 	mov ds, ax
  52. 	mov es, ax
  53. 	mov ss, ax
  54. 	mov sp, TopOfStack16
  55.  
  56. 	;
  57. 	call InitSysMemBuf
  58.  
  59. 	; initialize GDT for 32 bits code segment
  60. 	mov esi, CODE32_SEGMENT
  61. 	mov edi, CODE32_DESC
  62. 	call InitDescItem
  63.  
  64. 	mov esi, DATA32_SEGMENT
  65. 	mov edi, DATA32_DESC
  66. 	call InitDescItem
  67.  
  68. 	mov esi, STACK32_SEGMENT
  69. 	mov edi, STACK32_DESC
  70. 	call InitDescItem
  71.  
  72. 	; initalize GDT pointer struct
  73. 	mov eax, 0
  74. 	mov ax, ds
  75. 	shl eax, 4
  76. 	add eax, GDT_ENTRY
  77. 	mov dword [GdtPtr + 2], eax
  78.  
  79. 	; 1. load GDT
  80.     lgdt [GdtPtr]
  81.     
  82.     ; 2. close interrupt
  83.     cli 
  84.     
  85.     ; 3. open A20
  86.     in al, 0x92
  87.     or al, 00000010b
  88.     out 0x92, al
  89.     
  90.     ; 4. enter protect mode
  91.     mov eax, cr0
  92.     or eax, 0x01
  93.     mov cr0, eax
  94.     
  95.     ; 5. jump to 32 bits code
  96.     jmp dword Code32Selector : 0
  97.  
  98.  
  99. ; esi    --> code segment labelBACK_ENTRY_SEGMENT
  100. ; edi    --> descriptor label
  101. InitDescItem:
  102. 	push eax
  103.  
  104. 	mov eax, 0
  105. 	mov ax, cs
  106. 	shl eax, 4
  107. 	add eax, esi
  108. 	mov word [edi + 2], ax
  109. 	shr eax, 16
  110. 	mov byte [edi + 4], al
  111. 	mov byte [edi + 7], ah
  112. 	
  113. 	pop eax
  114.  
  115. 	ret
  116.  
  117. ;
  118. ;
  119. GetMemSize:
  120. 	push eax
  121. 	push ebx
  122. 	push ecx
  123. 	push edx
  124.  
  125. 	mov dword [MEM_SIZE], 0
  126.  
  127. 	xor eax, eax
  128. 	mov eax, 0xE801
  129. 	int 0x15	
  130.  
  131. 	jc geterr
  132.  
  133. 	mov ecx, 1
  134.  
  135. 	shl eax, 10    ; eax = eax * 1024
  136. 	shl ebx, 6     ; ebx = ebx * 64
  137. 	shl ebx, 10    ; ebx = ebx * 1024
  138. 	shl ecx, 20	   ; ecx = 1M
  139.  
  140. 	add [MEM_SIZE], eax
  141. 	add [MEM_SIZE], ebx
  142. 	add [MEM_SIZE], ecx
  143.  
  144. 	jmp getok
  145.  
  146. geterr:
  147. 	mov dword [MEM_SIZE], 0
  148.  
  149. getok:
  150. 	pop edx
  151. 	pop ecx
  152. 	pop ebx
  153. 	pop eax
  154.  
  155. 	ret
  156.  
  157. ; return
  158. ;    eax  --> 0 : successd    1 : failed
  159. InitSysMemBuf:
  160. 	push edi
  161. 	push edx
  162. 	push ebx
  163. 	push ecx
  164.  
  165. 	mov edi, MEM_ARDS
  166. 	mov ebx, 0
  167.  
  168. doloop:
  169. 	mov eax, 0xE820
  170. 	mov edx, 0x534D4150
  171.     mov ecx, 20
  172. 	int 0x15
  173. 	
  174. 	jc memerr
  175. 	
  176. 	add edi, 20
  177. 	inc dword [MEM_ARDS_NUM]
  178. 	
  179. 	cmp ebx, 0
  180. 	jne doloop
  181.  
  182. 	mov eax, 0
  183. 	jmp memok
  184.  
  185. memerr:
  186. 	mov eax, 1
  187.  
  188. memok:
  189. 	pop ecx
  190. 	pop ebx
  191. 	pop edx
  192. 	pop edi
  193.  
  194. 	ret
  195.  
  196. [section .s32]
  197. [bits 32]
  198. CODE32_SEGMENT:
  199. 	mov ax, VideoSelector
  200. 	mov gs, ax
  201.  
  202. 	mov ax, Stack32Selector
  203. 	mov ss, ax
  204.  
  205. 	mov eax, TopOfStack32
  206. 	mov esp, eax
  207.  
  208. 	mov ax, Data32Selector
  209. 	mov ds, ax
  210.  
  211. 	mov ebp, DTOS_Offset
  212. 	mov bx, 0x0c
  213. 	mov dh, 13
  214. 	mov dl, 33
  215. 	call PrintString
  216.  
  217. 	mov ebp, HELLOWORLD_Offset
  218. 	mov bx, 0x0c
  219. 	mov dh, 14
  220. 	mov dl, 30
  221. 	call PrintString
  222. 	
  223.  
  224. 	jmp $
  225.  
  226. ; ds:ebp    --> string address
  227. ; bx        --> attribute
  228. ; dx        --> dh : row, dl : col
  229. PrintString:
  230. 	push ebp
  231. 	push cx
  232. 	push eax
  233. 	push dx
  234. 	push edi
  235.  
  236. print:
  237. 	mov cl, [ds:ebp]
  238. 	cmp cl, 0
  239. 	je end
  240. 	mov eax, 80
  241. 	mul dh
  242. 	add al, dl
  243. 	shl eax, 1
  244. 	mov edi, eax
  245. 	mov ah, bl
  246. 	mov al, cl
  247. 	mov [gs:edi], ax
  248. 	inc ebp
  249. 	inc dl
  250. 	jmp print
  251. 	
  252. end:
  253. 	pop edi
  254. 	pop dx
  255. 	pop eax
  256. 	pop cx
  257. 	pop ebp
  258.  
  259. 	ret
  260.  
  261. Code32SegLen	equ    $ - CODE32_SEGMENT
  262.  
  263.  
  264. [section .gs]
  265. [bits 32]
  266. STACK32_SEGMENT:
  267. 	times 1024 * 4 db 0
  268.  
  269. Stack32SegLen	equ    $ - STACK32_SEGMENT
  270. TopOfStack32    equ    Stack32SegLen - 1

 第33行我们定义了MEM_ARDS_NUM，MEM_ARDS_NUM表示主机上有多少个段。第34行我们定义了MEM_ARDS，MEM_ARDS为ARDS数组的起始地址，大小我们定义为64个ARDS，每个ARDS为20个字节。

157 - 193行，我们定义了InitSysMemBuf，这个函数利用BIOS提供的 int 0x15 的高级功能来获取主机上所有段的段信息。

第57行，我们通过调用InitSysMemBuf这个函数来获取主机上的所有段信息。

下面我们来进行断点调试

 InitSysMemBuf函数调用前，MEM_ARDS_NUM = 0；InitSysMemBuf函数调用后，eax = 0，说明这个函数没有调用出错，MEM_ARDS_NUM = 6，表明这个主机上一共有6个段。

下面我们来查看这6个段的具体信息

 在查看前6个段的段信息时，它的值不为0。在查看第7个段的段信息，它的值为0，则又说明了这个我们一个查到了6个段。

ARDS记录中并没有包含物理内存容量的信息，那么获取这些记录有什么意义？


ARDS结构体中的TYPE成员

1 - AddressRangeMemory

  • 这段内存可以被操作系统使用

2 - AddressRangeReserved

  • 内存使用中或被保留，操作系统不可用

其他值 - 未定义

  • 保留，可用作 AddressRangeMemory 处理

在32位系统中

ARDS结构体中的 BaseAddrHigh 和 LengthHigh 均为0

物理内存容量需要通过属性为1的内存段计算

计算方式为：max{BaseAddrLow + LengthLow}

  • BaseAddrLow + LengthLow 是一段内存的地址上限

 根据ARDS记录计算物理内存

我们修改了InitSysMemBuf这个函数，如下

  1. ; return
  2. ;    eax  --> 0 : successd    1 : failed
  3. InitSysMemBuf:
  4. 	push edi
  5. 	push edx
  6. 	push ebx
  7. 	push ecx
  8.  
  9. 	mov edi, MEM_ARDS
  10. 	mov ebx, 0
  11.  
  12. doloop:
  13. 	mov eax, 0xE820
  14. 	mov edx, 0x534D4150
  15.     mov ecx, 20
  16. 	int 0x15
  17. 	
  18. 	jc memerr
  19. 	
  20. 	mov eax, [edi + 16]
  21. 	cmp eax, 1
  22. 	jne next
  23. 	
  24. 	mov eax, [edi]
  25. 	add eax, [edi + 8]
  26. 	cmp dword [MEM_SIZE], eax
  27. 	jnb next
  28.  
  29. 	mov dword [MEM_SIZE], eax
  30.  
  31. next:
  32. 	add edi, 20
  33. 	inc dword [MEM_ARDS_NUM]
  34. 	
  35. 	cmp ebx, 0
  36. 	jne doloop
  37.  
  38. 	mov eax, 0
  39. 	jmp memok
  40.  
  41. memerr:
  42. 	mov eax, 1
  43.  
  44. memok:
  45. 	pop ecx
  46. 	pop ebx
  47. 	pop edx
  48. 	pop edi
  49.  
  50. 	ret

 TYPE为1表示这段物理内存可被操作系统使用，我们取这段物理内存的最大值，放入MEM_SIZE中。

下面，我们来进行断点调试，查看MEM_SIZE的值

在调用 InitSysMemBuf 之后，MEM_SIZE = 0x01FF0000字节，并不等于我们设置的32M，我们来查看ARDS中的值，来判断我们实现的算法是否存在错误

我们发现TYPE为1的最大物理内存为 0x01FF0000字节，和我们得到的大小是一样的，这样就证明了我们实现的算法并没有出错。

 这里有一个TYPE为3的一个段，大小为0x10000，我们获取到的物理内存加上这个大小就为32M。我们猜想：我们要获得的物理内存大小可能和这个段有关系。

Linux中获取物理内存的策略

 在Linux中，获取物理内存是比对了BIOS中断提供的三种获取物理内存的办法。

 实验中使用的策略

  1. 通过 0xE801 计算物理内存大小
  2. 通过 0xE820 获取各个ARDS 并填入结构体数组
  3. 根据 ARDS 结构体数组计算物理内存大小
  4.  选择计算得到的较大内存容量作为最终结果
  1. %include "inc.asm"
  2.  
  3. org 0x9000
  4.  
  5. jmp ENTRY_SEGMENT
  6.  
  7. [section .gdt]
  8. ; GDT definition
  9. ;                                 段基址，       段界限，       段属性
  10. GDT_ENTRY		: Descriptor		0, 			    0,		      0
  11. CODE32_DESC		: Descriptor		0, 	   Code32SegLen - 1,  DA_32 + DA_C
  12. VIDEO_DESC	    : Descriptor     0xb8000,       0x7fff,       DA_32 + DA_DRWA
  13. DATA32_DESC		: Descriptor	    0,     Data32SegLen - 1,  DA_32 + DA_DRW
  14. STACK32_DESC	: Descriptor        0,      TopOfStack32,     DA_32 + DA_DRW
  15. SYSDAT32_DESC   : Descriptor        0,    SysDat32SegLen - 1, DA_32 + DA_DR
  16. ; GDT end  
  17.  
  18. GdtLen	  equ	   $ - GDT_ENTRY
  19. GdtPtr:    
  20. 		dw	GdtLen - 1
  21. 		dd	0
  22.  
  23. ; GDT Selector
  24. Code32Selector	 equ    (0x0001 << 3) + SA_TIG + SA_RPL0
  25. VideoSelector	 equ    (0x0002 << 3) + SA_TIG + SA_RPL0
  26. Data32Selector   equ    (0x0003 << 3) + SA_TIG + SA_RPL0
  27. Stack32Selector  equ    (0x0004 << 3) + SA_TIG + SA_RPL0
  28. SysDat32Selector equ    (0x0004 << 3) + SA_TIG + SA_RPL0
  29. ; end of [section .gdt]
  30.  
  31. TopOfStack16	equ    0x7c00
  32.  
  33. [section .sysdat]
  34. SYSDAT32_SEGMENT:
  35. 	MEM_SIZE	         times 4 db  0x00	; int mem_size = 0
  36. 	MEM_SIZE_OFFSET      equ   MEM_SIZE - $$  
  37. 	MEM_ARDS_NUM         times 4 db  0x00	; int men_addr_num = 0
  38. 	MEM_ADDR_NUM_OFFSET  equ   MEM_ARDS_NUM - $$
  39. 	MEM_ARDS	         times 20 * 64  db  0x00	; ARDS mem_adrs[64] = {0}
  40. 	MEM_ARDS_OFFSET      equ   MEM_ARDS - $$
  41.  
  42. SysDat32SegLen	equ    $ - SYSDAT32_SEGMENT
  43.  
  44. [section .d16]
  45. DATA16_SEGMENT:
  46. 	MEM_ERR_MSG      db  "[FAILED] memory check error..."
  47. 	MEM_ERR_MSG_LEN  equ $ - MEM_ERR_MSG
  48.  
  49. Data16SegLen    equ    $ - DATA16_SEGMENT
  50.  
  51. [section .dat]
  52. [bits 32]
  53. DATA32_SEGMENT:
  54. 	DTOS		        db    "D.T.OS!", 0
  55. 	DTOS_Offset	        equ	  DTOS - $$ 
  56.  
  57. 	HELLOWORLD		    db    "Hello, World!", 0
  58. 	HELLOWORLD_Offset   equ   HELLOWORLD - $$
  59.  
  60. Data32SegLen	equ   $ - DATA32_SEGMENT
  61.  
  62. [section .s16]
  63. [bits 16]
  64. ENTRY_SEGMENT:
  65. 	mov ax, cs
  66. 	mov ds, ax
  67. 	mov es, ax
  68. 	mov ss, ax
  69. 	mov sp, TopOfStack16
  70.  
  71. 	; get system memory information
  72. 	call InitSysMemBuf
  73.  
  74. 	cmp eax, 0
  75. 	jnz CODE16_MEM_ERROR
  76.  
  77. 	; initialize GDT for 32 bits code segment
  78. 	mov esi, CODE32_SEGMENT
  79. 	mov edi, CODE32_DESC
  80. 	call InitDescItem
  81.  
  82. 	mov esi, DATA32_SEGMENT
  83. 	mov edi, DATA32_DESC
  84. 	call InitDescItem
  85.  
  86. 	mov esi, STACK32_SEGMENT
  87. 	mov edi, STACK32_DESC
  88. 	call InitDescItem
  89.  
  90. 	mov esi, SYSDAT32_SEGMENT
  91. 	mov edi, SYSDAT32_DESC
  92. 	call InitDescItem
  93.  
  94. 	; initalize GDT pointer struct
  95. 	mov eax, 0
  96. 	mov ax, ds
  97. 	shl eax, 4
  98. 	add eax, GDT_ENTRY
  99. 	mov dword [GdtPtr + 2], eax
  100.  
  101. 	; 1. load GDT
  102.     lgdt [GdtPtr]
  103.     
  104.     ; 2. close interrupt
  105.     cli 
  106.     
  107.     ; 3. open A20
  108.     in al, 0x92
  109.     or al, 00000010b
  110.     out 0x92, al
  111.     
  112.     ; 4. enter protect mode
  113.     mov eax, cr0
  114.     or eax, 0x01
  115.     mov cr0, eax
  116.     
  117.     ; 5. jump to 32 bits code
  118.     jmp dword Code32Selector : 0
  119.  
  120. CODE16_MEM_ERROR:
  121. 	mov bp, MEM_ERR_MSG
  122. 	mov cx, MEM_ERR_MSG_LEN
  123. 	call Print
  124.  
  125. 	jmp $
  126.  
  127. ; es:bp  --> string address
  128. ; cx     --> string length
  129. Print:
  130. 	push ax
  131. 	push bx
  132.  
  133. 	mov dx, 0
  134. 	mov ax, 0x1301
  135. 	mov bx, 0x0007
  136.  
  137. 	int 0x10
  138.  
  139. 	pop bx
  140. 	pop ax
  141.  
  142. 	ret 
  143.  
  144. ; esi    --> code segment labelBACK_ENTRY_SEGMENT
  145. ; edi    --> descriptor label
  146. InitDescItem:
  147. 	push eax
  148.  
  149. 	mov eax, 0
  150. 	mov ax, cs
  151. 	shl eax, 4
  152. 	add eax, esi
  153. 	mov word [edi + 2], ax
  154. 	shr eax, 16
  155. 	mov byte [edi + 4], al
  156. 	mov byte [edi + 7], ah
  157. 	
  158. 	pop eax
  159.  
  160. 	ret
  161.  
  162. ;
  163. ;
  164. GetMemSize:
  165. 	push eax
  166. 	push ebx
  167. 	push ecx
  168. 	push edx
  169.  
  170. 	mov dword [MEM_SIZE], 0
  171.  
  172. 	xor eax, eax
  173. 	mov eax, 0xE801
  174. 	int 0x15	
  175.  
  176. 	jc geterr
  177.  
  178. 	mov ecx, 1
  179.  
  180. 	shl eax, 10    ; eax = eax * 1024
  181. 	shl ebx, 6     ; ebx = ebx * 64
  182. 	shl ebx, 10    ; ebx = ebx * 1024
  183. 	shl ecx, 20	   ; ecx = 1M
  184.  
  185. 	add [MEM_SIZE], eax
  186. 	add [MEM_SIZE], ebx
  187. 	add [MEM_SIZE], ecx
  188.  
  189. 	jmp getok
  190.  
  191. geterr:
  192. 	mov dword [MEM_SIZE], 0
  193.  
  194. getok:
  195. 	pop edx
  196. 	pop ecx
  197. 	pop ebx
  198. 	pop eax
  199.  
  200. 	ret
  201.  
  202. ; return
  203. ;    eax  --> 0 : successd    1 : failed
  204. InitSysMemBuf:
  205. 	push edi
  206. 	push edx
  207. 	push ebx
  208. 	push ecx
  209.  
  210. 	call GetMemSize
  211.  
  212. 	mov edi, MEM_ARDS
  213. 	mov ebx, 0
  214.  
  215. doloop:
  216. 	mov eax, 0xE820
  217. 	mov edx, 0x534D4150
  218.     mov ecx, 20
  219. 	int 0x15
  220. 	
  221. 	jc memerr
  222. 	
  223. 	mov eax, [edi + 16]
  224. 	cmp eax, 1
  225. 	jne next
  226. 	
  227. 	mov eax, [edi]
  228. 	add eax, [edi + 8]
  229. 	cmp dword [MEM_SIZE], eax
  230. 	jnb next
  231.  
  232. 	mov dword [MEM_SIZE], eax
  233.  
  234. next:
  235. 	add edi, 20
  236. 	inc dword [MEM_ARDS_NUM]
  237. 	
  238. 	cmp ebx, 0
  239. 	jne doloop
  240.  
  241. 	mov eax, 0
  242. 	jmp memok
  243.  
  244. memerr:
  245. 	mov eax, 1
  246. 	mov dword [MEM_SIZE], 0
  247. 	mov dword [MEM_ARDS_NUM], 0
  248.  
  249. memok:
  250. 	pop ecx
  251. 	pop ebx
  252. 	pop edx
  253. 	pop edi
  254.  
  255. 	ret
  256.  
  257. [section .s32]
  258. [bits 32]
  259. CODE32_SEGMENT:
  260. 	mov ax, VideoSelector
  261. 	mov gs, ax
  262.  
  263. 	mov ax, Stack32Selector
  264. 	mov ss, ax
  265.  
  266. 	mov eax, TopOfStack32
  267. 	mov esp, eax
  268.  
  269. 	mov ax, Data32Selector
  270. 	mov ds, ax
  271.  
  272. 	mov ebp, DTOS_Offset
  273. 	mov bx, 0x0c
  274. 	mov dh, 13
  275. 	mov dl, 33
  276. 	call PrintString
  277.  
  278. 	mov ebp, HELLOWORLD_Offset
  279. 	mov bx, 0x0c
  280. 	mov dh, 14
  281. 	mov dl, 30
  282. 	call PrintString
  283. 	
  284.  
  285. 	jmp $
  286.  
  287. ; ds:ebp    --> string address
  288. ; bx        --> attribute
  289. ; dx        --> dh : row, dl : col
  290. PrintString:
  291. 	push ebp
  292. 	push cx
  293. 	push eax
  294. 	push dx
  295. 	push edi
  296.  
  297. print:
  298. 	mov cl, [ds:ebp]
  299. 	cmp cl, 0
  300. 	je end
  301. 	mov eax, 80
  302. 	mul dh
  303. 	add al, dl
  304. 	shl eax, 1
  305. 	mov edi, eax
  306. 	mov ah, bl
  307. 	mov al, cl
  308. 	mov [gs:edi], ax
  309. 	inc ebp
  310. 	inc dl
  311. 	jmp print
  312. 	
  313. end:
  314. 	pop edi
  315. 	pop dx
  316. 	pop eax
  317. 	pop cx
  318. 	pop ebp
  319.  
  320. 	ret
  321.  
  322. Code32SegLen	equ    $ - CODE32_SEGMENT
  323.  
  324.  
  325. [section .gs]
  326. [bits 32]
  327. STACK32_SEGMENT:
  328. 	times 1024 * 4 db 0
  329.  
  330. Stack32SegLen	equ    $ - STACK32_SEGMENT
  331. TopOfStack32    equ    Stack32SegLen - 1

我们通过InitSysMemBuf这个函数返回 0xE820 和 0xE801 中较大的物理内存，MEM_SIZE记录了较大的物理内存。

 MEM_SIZE 的值为32M。

我们在16位实模式下新增了 InitSysMemBuf 这个函数的出错处理，我们打印一个出错字符串，我们在241行故意令eax = 1， 查看运行结果。

正确的打印出了出错字符串。

下面我们将有关物理内存大小的数据定义为32位保护模式下的只读数据段，因为系统上电后，一开始是工作在实模式下，进行初始化工作，包括获取物理内存，随后就进入了保护模式，系统大部分时间是运行在保护模式下的。这些数据是系统相关的数据，需要保护起来，并将特权级设为0，只有内核才能访问这段数据。 

  1. %include "inc.asm"
  2.  
  3. org 0x9000
  4.  
  5. jmp ENTRY_SEGMENT
  6.  
  7. [section .gdt]
  8. ; GDT definition
  9. ;                                 段基址，       段界限，       段属性
  10. GDT_ENTRY		: Descriptor		0, 			    0,		      0
  11. CODE32_DESC		: Descriptor		0, 	   Code32SegLen - 1,  DA_32 + DA_C
  12. VIDEO_DESC	    : Descriptor     0xb8000,       0x7fff,       DA_32 + DA_DRWA
  13. DATA32_DESC		: Descriptor	    0,     Data32SegLen - 1,  DA_32 + DA_DRW
  14. STACK32_DESC	: Descriptor        0,      TopOfStack32,     DA_32 + DA_DRW
  15. SYSDAT32_DESC   : Descriptor        0,    SysDat32SegLen - 1, DA_32 + DA_DR
  16. ; GDT end  
  17.  
  18. GdtLen	  equ	   $ - GDT_ENTRY
  19. GdtPtr:    
  20. 		dw	GdtLen - 1
  21. 		dd	0
  22.  
  23. ; GDT Selector
  24. Code32Selector	 equ    (0x0001 << 3) + SA_TIG + SA_RPL0
  25. VideoSelector	 equ    (0x0002 << 3) + SA_TIG + SA_RPL0
  26. Data32Selector   equ    (0x0003 << 3) + SA_TIG + SA_RPL0
  27. Stack32Selector  equ    (0x0004 << 3) + SA_TIG + SA_RPL0
  28. SysDat32Selector equ    (0x0004 << 3) + SA_TIG + SA_RPL0
  29. ; end of [section .gdt]
  30.  
  31. TopOfStack16	equ    0x7c00
  32.  
  33. [section .sysdat]
  34. SYSDAT32_SEGMENT:
  35. 	MEM_SIZE	         times 4 db  0x00	; int mem_size = 0
  36. 	MEM_SIZE_OFFSET      equ   MEM_SIZE - $$  
  37. 	MEM_ARDS_NUM         times 4 db  0x00	; int men_addr_num = 0
  38. 	MEM_ADDR_NUM_OFFSET  equ   MEM_ARDS_NUM - $$
  39. 	MEM_ARDS	         times 20 * 64  db  0x00	; ARDS mem_adrs[64] = {0}
  40. 	MEM_ARDS_OFFSET      equ   MEM_ARDS - $$
  41.  
  42. SysDat32SegLen	equ    $ - SYSDAT32_SEGMENT
  43.  
  44. [section .d16]
  45. DATA16_SEGMENT:
  46. 	MEM_ERR_MSG      db  "[FAILED] memory check error..."
  47. 	MEM_ERR_MSG_LEN  equ $ - MEM_ERR_MSG
  48.  
  49. Data16SegLen    equ    $ - DATA16_SEGMENT
  50.  
  51. [section .dat]
  52. [bits 32]
  53. DATA32_SEGMENT:
  54. 	DTOS		        db    "D.T.OS!", 0
  55. 	DTOS_Offset	        equ	  DTOS - $$ 
  56.  
  57. 	HELLOWORLD		    db    "Hello, World!", 0
  58. 	HELLOWORLD_Offset   equ   HELLOWORLD - $$
  59.  
  60. Data32SegLen	equ   $ - DATA32_SEGMENT
  61.  
  62. [section .s16]
  63. [bits 16]
  64. ENTRY_SEGMENT:
  65. 	mov ax, cs
  66. 	mov ds, ax
  67. 	mov es, ax
  68. 	mov ss, ax
  69. 	mov sp, TopOfStack16
  70.  
  71. 	; get system memory information
  72. 	call InitSysMemBuf
  73.  
  74. 	cmp eax, 0
  75. 	jnz CODE16_MEM_ERROR
  76.  
  77. 	; initialize GDT for 32 bits code segment
  78. 	mov esi, CODE32_SEGMENT
  79. 	mov edi, CODE32_DESC
  80. 	call InitDescItem
  81.  
  82. 	mov esi, DATA32_SEGMENT
  83. 	mov edi, DATA32_DESC
  84. 	call InitDescItem
  85.  
  86. 	mov esi, STACK32_SEGMENT
  87. 	mov edi, STACK32_DESC
  88. 	call InitDescItem
  89.  
  90. 	mov esi, SYSDAT32_SEGMENT
  91. 	mov edi, SYSDAT32_DESC
  92. 	call InitDescItem
  93.  
  94. 	; initalize GDT pointer struct
  95. 	mov eax, 0
  96. 	mov ax, ds
  97. 	shl eax, 4
  98. 	add eax, GDT_ENTRY
  99. 	mov dword [GdtPtr + 2], eax
  100.  
  101. 	; 1. load GDT
  102.     lgdt [GdtPtr]
  103.     
  104.     ; 2. close interrupt
  105.     cli 
  106.     
  107.     ; 3. open A20
  108.     in al, 0x92
  109.     or al, 00000010b
  110.     out 0x92, al
  111.     
  112.     ; 4. enter protect mode
  113.     mov eax, cr0
  114.     or eax, 0x01
  115.     mov cr0, eax
  116.     
  117.     ; 5. jump to 32 bits code
  118.     jmp dword Code32Selector : 0
  119.  
  120. CODE16_MEM_ERROR:
  121. 	mov bp, MEM_ERR_MSG
  122. 	mov cx, MEM_ERR_MSG_LEN
  123. 	call Print
  124.  
  125. 	jmp $
  126.  
  127. ; es:bp  --> string address
  128. ; cx     --> string length
  129. Print:
  130. 	push ax
  131. 	push bx
  132.  
  133. 	mov dx, 0
  134. 	mov ax, 0x1301
  135. 	mov bx, 0x0007
  136. mov eax, 0
  137. 	jmp memok
  138.  
  139. 	int 0x10
  140.  
  141. 	pop bx
  142. 	pop ax
  143.  
  144. 	ret 
  145.  
  146. ; esi    --> code segment labelBACK_ENTRY_SEGMENT
  147. ; edi    --> descriptor label
  148. InitDescItem:
  149. 	push eax
  150.  
  151. 	mov eax, 0
  152. 	mov ax, cs
  153. 	shl eax, 4
  154. 	add eax, esi
  155. 	mov word [edi + 2], ax
  156. 	shr eax, 16
  157. 	mov byte [edi + 4], al
  158. 	mov byte [edi + 7], ah
  159. 	
  160. 	pop eax
  161.  
  162. 	ret
  163.  
  164. ;
  165. ;
  166. GetMemSize:
  167. 	push eax
  168. 	push ebx
  169. 	push ecx
  170. 	push edx
  171.  
  172. 	mov dword [MEM_SIZE], 0
  173.  
  174. 	xor eax, eax
  175. 	mov eax, 0xE801
  176. 	int 0x15	
  177.  
  178. 	jc geterr
  179.  
  180. 	mov ecx, 1
  181.  
  182. 	shl eax, 10    ; eax = eax * 1024
  183. 	shl ebx, 6     ; ebx = ebx * 64
  184. 	shl ebx, 10    ; ebx = ebx * 1024
  185. 	shl ecx, 20	   ; ecx = 1M
  186.  
  187. 	add [MEM_SIZE], eax
  188. 	add [MEM_SIZE], ebx
  189. 	add [MEM_SIZE], ecx
  190.  
  191. 	jmp getok
  192.  
  193. geterr:
  194. 	mov dword [MEM_SIZE], 0
  195.  
  196. getok:
  197. 	pop edx
  198. 	pop ecx
  199. 	pop ebx
  200. 	pop eax
  201.  
  202. 	ret
  203.  
  204. ; return
  205. ;    eax  --> 0 : successd    1 : failed
  206. InitSysMemBuf:
  207. 	push edi
  208. 	push edx
  209. 	push ebx
  210. 	push ecx
  211.  
  212. 	call GetMemSize
  213.  
  214. 	mov edi, MEM_ARDS
  215. 	mov ebx, 0
  216.  
  217. doloop:
  218. 	mov eax, 0xE820
  219. 	mov edx, 0x534D4150
  220. 	mov ecx, 20
  221. 	int 0x15
  222. 	
  223. 	jc memerr
  224. 	
  225. 	mov eax, [edi + 16]
  226. 	cmp eax, 1
  227. 	jne next
  228. 	
  229. 	mov eax, [edi]
  230. 	add eax, [edi + 8]
  231. 	cmp dword [MEM_SIZE], eax
  232. 	jnb next
  233.  
  234. 	mov dword [MEM_SIZE], eax
  235.  
  236. next:
  237. 	add edi, 20
  238. 	inc dword [MEM_ARDS_NUM]
  239. 	
  240. 	cmp ebx, 0
  241. 	jne doloop
  242.  
  243. 	mov eax, 0
  244. 	jmp memok
  245.  
  246. memerr:
  247. 	mov eax, 1
  248. 	mov dword [MEM_SIZE], 0
  249. 	mov dword [MEM_ARDS_NUM], 0
  250.  
  251. memok:
  252. 	pop ecx
  253. 	pop ebx
  254. 	pop edx
  255. 	pop edi
  256.  
  257. 	ret
  258.  
  259. [section .s32]
  260. [bits 32]
  261. CODE32_SEGMENT:
  262. 	mov ax, VideoSelector
  263. 	mov gs, ax
  264.  
  265. 	mov ax, Stack32Selector
  266. 	mov ss, ax
  267.  
  268. 	mov eax, TopOfStack32
  269. 	mov esp, eax
  270.  
  271. 	mov ax, Data32Selector
  272. 	mov ds, ax
  273.  
  274. 	mov ebp, DTOS_Offset
  275. 	mov bx, 0x0c
  276. 	mov dh, 13
  277. 	mov dl, 33
  278. 	call PrintString
  279.  
  280. 	mov ebp, HELLOWORLD_Offset
  281. 	mov bx, 0x0c
  282. 	mov dh, 14
  283. 	mov dl, 30
  284. 	call PrintString
  285. 	
  286.  
  287. 	jmp $
  288.  
  289. ; ds:ebp    --> string address
  290. ; bx        --> attribute
  291. ; dx        --> dh : row, dl : col
  292. PrintString:
  293. 	push ebp
  294. 	push cx
  295. 	push eax
  296. 	push dx
  297. 	push edi
  298.  
  299. print:
  300. 	mov cl, [ds:ebp]
  301. 	cmp cl, 0
  302. 	je end
  303. 	mov eax, 80
  304. 	mul dh
  305. 	add al, dl
  306. 	shl eax, 1
  307. 	mov edi, eax
  308. 	mov ah, bl
  309. 	mov al, cl
  310. 	mov [gs:edi], ax
  311. 	inc ebp
  312. 	inc dl
  313. 	jmp print
  314. 	
  315. end:
  316. 	pop edi
  317. 	pop dx
  318. 	pop eax
  319. 	pop cx
  320. 	pop ebp
  321.  
  322. 	ret
  323.  
  324. Code32SegLen	equ    $ - CODE32_SEGMENT
  325.  
  326.  
  327. [section .gs]
  328. [bits 32]
  329. STACK32_SEGMENT:
  330. 	times 1024 * 4 db 0
  331.  
  332. Stack32SegLen	equ    $ - STACK32_SEGMENT
  333. TopOfStack32    equ    Stack32SegLen - 1
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/article/detail/58735
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号