FreeDOS 代码学习

不点

以下是 kernel.asm 中的片段。代码显示出有关中断向量的重要信息。

1.         ; dummy interrupt return handlers
   
2. 
   
3.                 global _int22_handler
   
4.                 global _int28_handler
   
5.                 global _int2a_handler
   
6.                 global _empty_handler
   
7. _int22_handler:         
   
8. _int28_handler:
   
9. _int2a_handler:
   
10. _empty_handler:
    
11.                 iret
    
12.    
    
13. 
    
14. global _initforceEnableA20
    
15. initforceEnableA20:
    
16.                 call near forceEnableA20
    
17.                 retf   
    
18. 
    
19.     global __HMARelocationTableStart
    
20. __HMARelocationTableStart:   
    
21. 
    
22.                 global  _int2f_handler
    
23.                 extern  reloc_call_int2f_handler
    
24. _int2f_handler: jmp 0:reloc_call_int2f_handler
    
25.                 call near forceEnableA20
    
26. 
    
27.                 global  _int20_handler
    
28.                 extern  reloc_call_int20_handler
    
29. _int20_handler: jmp 0:reloc_call_int20_handler
    
30.                 call near forceEnableA20
    
31. 
    
32.                 global  _int21_handler
    
33.                 extern  reloc_call_int21_handler
    
34. _int21_handler: jmp 0:reloc_call_int21_handler
    
35.                 call near forceEnableA20
    
36. 
    
37. 
    
38.                 global  _low_int25_handler
    
39.                 extern  reloc_call_low_int25_handler
    
40. _low_int25_handler: jmp 0:reloc_call_low_int25_handler
    
41.                 call near forceEnableA20
    
42. 
    
43.                 global  _low_int26_handler
    
44.                 extern  reloc_call_low_int26_handler
    
45. _low_int26_handler: jmp 0:reloc_call_low_int26_handler
    
46.                 call near forceEnableA20
    
47. 
    
48.                 global  _int27_handler
    
49.                 extern  reloc_call_int27_handler
    
50. _int27_handler: jmp 0:reloc_call_int27_handler
    
51.                 call near forceEnableA20
    
52. 
    
53.                 global  _int0_handler
    
54.                 extern  reloc_call_int0_handler
    
55. _int0_handler:  jmp 0:reloc_call_int0_handler
    
56.                 call near forceEnableA20
    
57. 
    
58.                 global  _int6_handler
    
59.                 extern  reloc_call_int6_handler
    
60. _int6_handler:  jmp 0:reloc_call_int6_handler
    
61.                 call near forceEnableA20
    
62. 
    
63.                 global  _int19_handler
    
64.                 extern  reloc_call_int19_handler
    
65. _int19_handler: jmp 0:reloc_call_int19_handler
    
66.                 call near forceEnableA20
    
67. 
    
68.                 global  _cpm_entry
    
69.                 extern  reloc_call_cpm_entry
    
70. _cpm_entry:     jmp 0:reloc_call_cpm_entry
    
71.                 call near forceEnableA20
    
72. 
    
73.                 global  _reloc_call_blk_driver
    
74.                 extern  _blk_driver
    
75. _reloc_call_blk_driver:
    
76.                 jmp 0:_blk_driver
    
77.                 call near forceEnableA20
    
78. 
    
79.                 global  _reloc_call_clk_driver
    
80.                 extern  _clk_driver
    
81. _reloc_call_clk_driver:
    
82.                 jmp 0:_clk_driver
    
83.                 call near forceEnableA20
    
84. 
    
85.                 global  _CharMapSrvc ; in _DATA (see AARD)
    
86.                 extern  _reloc_call_CharMapSrvc
    
87. _CharMapSrvc:   jmp 0:_reloc_call_CharMapSrvc
    
88.                 call near forceEnableA20
    
89. 
    
90.                 global _init_call_p_0
    
91.                 extern reloc_call_p_0
    
92. _init_call_p_0: jmp  0:reloc_call_p_0
    
93.                 call near forceEnableA20

复制代码

不点

以下是 grub4dos 有关实模式与保护模式环境切换的关键接口函数。

1. /*
   
2. * long realmode_run(long regs_ptr)
   
3. *
   
4. */
   
5. 
   
6. ENTRY(realmode_run)
   
7. 
   
8.         .code32
   
9. 
   
10.         pushl        %ebp
    
11.         movl        %esp, %ebp
    
12. 
    
13.         pushl        %ebx
    
14.         movl        8(%ebp), %ebx                /* EBX=regs_ptr */
    
15. 
    
16.         /* check sanity */
    
17. 
    
18.         xorl        %eax, %eax                /* EAX=0 for failure */
    
19. 
    
20.         movl        0x20(%ebx), %ecx        /* GS */
    
21.         incl        %ecx
    
22.         jz        1f
    
23.         decl        %ecx
    
24.         shrl        $16, %ecx
    
25.         jnz        2f                        /* failure */
    
26. 1:
    
27. 
    
28.         movl        0x24(%ebx), %ecx        /* FS */
    
29.         incl        %ecx
    
30.         jz        1f
    
31.         decl        %ecx
    
32.         shrl        $16, %ecx
    
33.         jnz        2f                        /* failure */
    
34. 1:
    
35. 
    
36.         movl        0x28(%ebx), %ecx        /* ES */
    
37.         incl        %ecx
    
38.         jz        1f
    
39.         decl        %ecx
    
40.         shrl        $16, %ecx
    
41.         jnz        2f                        /* failure */
    
42. 1:
    
43. 
    
44.         movl        0x2C(%ebx), %ecx        /* DS */
    
45.         incl        %ecx
    
46.         jz        1f
    
47.         decl        %ecx
    
48.         shrl        $16, %ecx
    
49.         jnz        2f                        /* failure */
    
50. 1:
    
51. 
    
52.         movl        0x30(%ebx), %ecx        /* SS */
    
53.         movl        0x0C(%ebx), %edx        /* ESP */
    
54.         incl        %ecx
    
55.         jz        1f
    
56.         decl        %ecx
    
57.         orl        %edx, %ecx
    
58.         shrl        $16, %ecx
    
59.         jnz        2f                        /* failure */
    
60.         jmp        3f
    
61. 1:
    
62.         incl        %edx
    
63.         jnz        2f                        /* failure */
    
64. 3:
    
65. 
    
66.         movl        0x38(%ebx), %ecx        /* CS */
    
67.         movl        0x34(%ebx), %edx        /* EIP */
    
68.         incl        %ecx
    
69.         jz        1f
    
70.         decl        %ecx
    
71.         orl        %edx, %ecx
    
72.         shrl        $16, %ecx
    
73.         jnz        2f                        /* failure */
    
74.         jmp        3f
    
75. 1:
    
76.         cmpb        $0xCD, %dl
    
77.         jnz        2f                        /* failure */
    
78.         shrl        $16, %edx
    
79.         incw        %dx
    
80.         jnz        2f                        /* failure */
    
81. 3:
    
82.         /* sanity check ok, run it! */
    
83. 
    
84.         pushal
    
85.         pushal
    
86.         pushal
    
87.         pushal
    
88.         movl        %esp, ABS(chain_stage1_esp)
    
89. 
    
90.         /* mov the struct to stack */
    
91.         subl        $64, %esp
    
92.         movl        %esp, %edi
    
93.         movl        %ebx, %esi
    
94.         movl        $16, %ecx
    
95.         cld
    
96.         repz movsl
    
97. 
    
98.         movl        %esp, %ebp        /* EBP point to struct on stack */
    
99. 
    
100.         call        EXT_C(prot_to_real)
     
101. 
     
102.         .code16
     
103. 
     
104.         sti
     
105. 
     
106.         movl        %ebp, %esp
     
107. 
     
108.         /* check CS:EIP */
     
109. 
     
110.         movl        0x38(%bp), %ecx                /* CS */
     
111.         movl        0x34(%bp), %edx                /* EIP */
     
112.         incl        %ecx                        /* CS = -1? */
     
113.         jz        3f                        /* yes, jump to INTxx code */
     
114. 
     
115.         /* run user defined code */
     
116.         decl        %ecx                        /* CS */
     
117.         /* 0xEA might have been changed to 0xCD previously, so we must restore
     
118.          * it back to 0xEA.
     
119.          */
     
120.         movb        $0xEA, ABS(1f-1)        /* opcode for "far jump" */
     
121.         movw        %dx, ABS(1f)                /* IP in the far jump instruction */
     
122.         movw        %cx, ABS(1f + 2)        /* CS in the far jump instruction */
     
123. 
     
124.         /* set return address for user code to return */
     
125.         movl        $ABS(4f), %ecx
     
126.         movl        %ecx, 0x8201
     
127.         jmp        6f
     
128. 3:
     
129.         /* run int xx */
     
130.         movw        %dx, ABS(1f - 1)        /* int XX */
     
131.         movb        $0xE9, ABS(1f + 1)        /* jmp */
     
132.         movw        $(4f - 1f - 4), ABS(1f + 2)
     
133. 6:
     
134.         movw        %sp, ABS(8f)                /* initial SP */
     
135.         movw        %ss, ABS(7f)                /* initial SS */
     
136. 
     
137.         /* set DS, ES, FS, GS */
     
138.         movl        0x20(%bp), %ecx                /* GS */
     
139.         incl        %ecx
     
140.         jz        5f
     
141.         decl        %ecx
     
142.         movw        %cx, %gs
     
143. 5:
     
144. 
     
145.         movl        0x24(%bp), %ecx                /* FS */
     
146.         incl        %ecx
     
147.         jz        5f
     
148.         decl        %ecx
     
149.         movw        %cx, %fs
     
150. 5:
     
151. 
     
152.         movl        0x28(%bp), %ecx                /* ES */
     
153.         incl        %ecx
     
154.         jz        5f
     
155.         decl        %ecx
     
156.         movw        %cx, %es
     
157. 5:
     
158. 
     
159.         movl        0x2C(%bp), %ecx                /* DS */
     
160.         incl        %ecx
     
161.         jz        5f
     
162.         decl        %ecx
     
163.         movw        %cx, %ds
     
164. 5:
     
165. 
     
166.         movl        0x30(%bp), %ecx                /* SS */
     
167.         incl        %ecx
     
168.         jz        5f
     
169.         decl        %ecx
     
170.         movw        %cx, ABS(7f)
     
171.         movw        0x0C(%bp), %dx                /* SP */
     
172.         movw        %dx, ABS(8f)
     
173. 5:
     
174.         movl        0x3C(%bp), %ecx                /* EFLAGS */
     
175.         incl        %ecx
     
176.         jz        5f
     
177.         decl        %ecx
     
178.         pushl        %ecx
     
179.         popfl
     
180. 5:
     
181.         popal                                /* setup general registers */
     
182. 
     
183.         /* move SS and SP */
     
184.         .byte        0xBC                        /* MOV SP */
     
185. 7:
     
186.         .word        0                        /* SS */
     
187.         movw        %sp, %ss
     
188.         .byte        0xBC                        /* MOV SP */
     
189. 8:
     
190.         .word        0                        /* SP */
     
191. 
     
192.         /* far jump to user code */
     
193.         .byte        0xEA                        /* ljmp */
     
194. 1:
     
195.         .word        0                        /* IP */
     
196.         .word        0                        /* CS */
     
197. 
     
198. 4:        /* return from user code */
     
199. 
     
200.         /* CS:IP need not care */
     
201. 
     
202.         /* use the stack already built by the user */
     
203. 
     
204.         pushal
     
205.         pushfl
     
206.         pushl        %cs
     
207.         pushl        $0
     
208.         pushl        %ss
     
209.         pushl        %ds
     
210.         pushl        %es
     
211.         pushl        %fs
     
212.         pushl        %gs
     
213. 
     
214.         movl        %ss, %ebp
     
215.         shll        $4, %ebp
     
216.         xorl        %eax, %eax
     
217.         movw        %ax, %ds
     
218.         movw        %ax, %es
     
219.         movw        %sp, %ax
     
220.         addl        %eax, %ebp                /* physical address of stack */
     
221. 
     
222.         call        EXT_C(real_to_prot)
     
223. 
     
224.         .code32
     
225. 
     
226.         sti
     
227. 
     
228.         cld
     
229.         movl        %ebp, %esi
     
230. 
     
231.         movl        ABS(chain_stage1_esp), %esp
     
232.         movl        16(%esp), %ebx                /* EBX=regs_ptr */
     
233. 
     
234.         leal        32(%ebx), %edi
     
235.         movl        $8, %ecx
     
236.         repz movsl
     
237. 
     
238.         leal        32(%ebp), %esi
     
239.         movl        %ebx, %edi
     
240.         movl        $8, %ecx
     
241.         repz movsl
     
242. 
     
243.         /* the stack should not change! */
     
244. 
     
245.         /* fix the pushed ESPs before checking */
     
246.         movl        $32, %ecx
     
247.         subl        %ecx, (32 + 12)(%esp)
     
248.         movl        $64, %ecx
     
249.         subl        %ecx, (64 + 12)(%esp)
     
250.         movl        $96, %ecx
     
251.         subl        %ecx, (96 + 12)(%esp)
     
252. 
     
253.         movl        %esp, %esi
     
254.         leal        32(%esp), %edi
     
255.         movl        $8, %ecx
     
256.         repz cmpsl
     
257.         jnz        1f
     
258.         movl        %esp, %esi
     
259.         leal        64(%esp), %edi
     
260.         movl        $16, %ecx
     
261.         repz cmpsl
     
262.         jnz        1f
     
263.         popal
     
264.         popal
     
265.         popal
     
266.         popal
     
267.         movl        $1, %eax                /* success */
     
268.         popl        %ebx
     
269.         popl        %ebp
     
270.         ret
     
271. 1:
     
272.         popal
     
273.         popal
     
274.         popal
     
275.         popal
     
276.         xorl        %eax, %eax                /* failure */
     
277. 2:
     
278.         popl        %ebx
     
279.         popl        %ebp
     
280.         ret

复制代码