1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
|
#include <mini-os/os.h>
#include <mini-os/x86/arch_limits.h>
#include <xen/arch-x86_32.h>
.section __xen_guest
.ascii "GUEST_OS=Mini-OS"
.ascii ",XEN_VER=xen-3.0"
.ascii ",VIRT_BASE=0x0" /* &_text from minios_x86_32.lds */
.ascii ",ELF_PADDR_OFFSET=0x0"
.ascii ",HYPERCALL_PAGE=0x2"
.ascii ",PAE=yes[extended-cr3]"
.ascii ",LOADER=generic"
.byte 0
.text
.globl _start, shared_info, hypercall_page
_start:
cld
lss stack_start,%esp
andl $(~(__STACK_SIZE-1)), %esp
push %esi
call start_kernel
stack_start:
.long stack+(2*__STACK_SIZE), __KERNEL_SS
/* Unpleasant -- the PTE that maps this page is actually overwritten */
/* to map the real shared-info page! :-) */
.org 0x1000
shared_info:
.org 0x2000
hypercall_page:
.org 0x3000
ES = 0x20
ORIG_EAX = 0x24
EIP = 0x28
CS = 0x2C
#define ENTRY(X) .globl X ; X :
#define SAVE_ALL \
cld; \
pushl %es; \
pushl %ds; \
pushl %eax; \
pushl %ebp; \
pushl %edi; \
pushl %esi; \
pushl %edx; \
pushl %ecx; \
pushl %ebx; \
movl $(__KERNEL_DS),%edx; \
movl %edx,%ds; \
movl %edx,%es;
#define RESTORE_ALL \
popl %ebx; \
popl %ecx; \
popl %edx; \
popl %esi; \
popl %edi; \
popl %ebp; \
popl %eax; \
popl %ds; \
popl %es; \
addl $4,%esp; \
iret;
ENTRY(divide_error)
pushl $0 # no error code
pushl $do_divide_error
do_exception:
pushl %ds
pushl %eax
xorl %eax, %eax
pushl %ebp
pushl %edi
pushl %esi
pushl %edx
decl %eax # eax = -1
pushl %ecx
pushl %ebx
cld
movl %es, %ecx
movl ES(%esp), %edi # get the function address
movl ORIG_EAX(%esp), %edx # get the error code
movl %eax, ORIG_EAX(%esp)
movl %ecx, ES(%esp)
movl $(__KERNEL_DS), %ecx
movl %ecx, %ds
movl %ecx, %es
movl %esp,%eax # pt_regs pointer
pushl %edx
pushl %eax
call *%edi
jmp ret_from_exception
ret_from_exception:
movb CS(%esp),%cl
addl $8,%esp
RESTORE_ALL
# A note on the "critical region" in our callback handler.
# We want to avoid stacking callback handlers due to events occurring
# during handling of the last event. To do this, we keep events disabled
# until weve done all processing. HOWEVER, we must enable events before
# popping the stack frame (cant be done atomically) and so it would still
# be possible to get enough handler activations to overflow the stack.
# Although unlikely, bugs of that kind are hard to track down, so wed
# like to avoid the possibility.
# So, on entry to the handler we detect whether we interrupted an
# existing activation in its critical region -- if so, we pop the current
# activation and restart the handler using the previous one.
ENTRY(hypervisor_callback)
pushl %eax
SAVE_ALL
movl EIP(%esp),%eax
cmpl $scrit,%eax
jb 11f
cmpl $ecrit,%eax
jb critical_region_fixup
11: push %esp
xorl %ebp,%ebp
call do_hypervisor_callback
add $4,%esp
movl HYPERVISOR_shared_info,%esi
xorl %eax,%eax
movb CS(%esp),%cl
test $2,%cl # slow return to ring 2 or 3
jne safesti
safesti:movb $0,1(%esi) # reenable event callbacks
scrit: /**** START OF CRITICAL REGION ****/
testb $0xFF,(%esi)
jnz 14f # process more events if necessary...
RESTORE_ALL
14: movb $1,1(%esi)
jmp 11b
ecrit: /**** END OF CRITICAL REGION ****/
# [How we do the fixup]. We want to merge the current stack frame with the
# just-interrupted frame. How we do this depends on where in the critical
# region the interrupted handler was executing, and so how many saved
# registers are in each frame. We do this quickly using the lookup table
# 'critical_fixup_table'. For each byte offset in the critical region, it
# provides the number of bytes which have already been popped from the
# interrupted stack frame.
critical_region_fixup:
addl $critical_fixup_table-scrit,%eax
movzbl (%eax),%eax # %eax contains num bytes popped
mov %esp,%esi
add %eax,%esi # %esi points at end of src region
mov %esp,%edi
add $0x34,%edi # %edi points at end of dst region
mov %eax,%ecx
shr $2,%ecx # convert words to bytes
je 16f # skip loop if nothing to copy
15: subl $4,%esi # pre-decrementing copy loop
subl $4,%edi
movl (%esi),%eax
movl %eax,(%edi)
loop 15b
16: movl %edi,%esp # final %edi is top of merged stack
jmp 11b
critical_fixup_table:
.byte 0x00,0x00,0x00 # testb $0xff,(%esi)
.byte 0x00,0x00 # jne 14f
.byte 0x00 # pop %ebx
.byte 0x04 # pop %ecx
.byte 0x08 # pop %edx
.byte 0x0c # pop %esi
.byte 0x10 # pop %edi
.byte 0x14 # pop %ebp
.byte 0x18 # pop %eax
.byte 0x1c # pop %ds
.byte 0x20 # pop %es
.byte 0x24,0x24,0x24 # add $4,%esp
.byte 0x28 # iret
.byte 0x00,0x00,0x00,0x00 # movb $1,1(%esi)
.byte 0x00,0x00 # jmp 11b
# Hypervisor uses this for application faults while it executes.
ENTRY(failsafe_callback)
pop %ds
pop %es
pop %fs
pop %gs
iret
ENTRY(coprocessor_error)
pushl $0
pushl $do_coprocessor_error
jmp do_exception
ENTRY(simd_coprocessor_error)
pushl $0
pushl $do_simd_coprocessor_error
jmp do_exception
ENTRY(device_not_available)
iret
ENTRY(debug)
pushl $0
pushl $do_debug
jmp do_exception
ENTRY(int3)
pushl $0
pushl $do_int3
jmp do_exception
ENTRY(overflow)
pushl $0
pushl $do_overflow
jmp do_exception
ENTRY(bounds)
pushl $0
pushl $do_bounds
jmp do_exception
ENTRY(invalid_op)
pushl $0
pushl $do_invalid_op
jmp do_exception
ENTRY(coprocessor_segment_overrun)
pushl $0
pushl $do_coprocessor_segment_overrun
jmp do_exception
ENTRY(invalid_TSS)
pushl $do_invalid_TSS
jmp do_exception
ENTRY(segment_not_present)
pushl $do_segment_not_present
jmp do_exception
ENTRY(stack_segment)
pushl $do_stack_segment
jmp do_exception
ENTRY(general_protection)
pushl $do_general_protection
jmp do_exception
ENTRY(alignment_check)
pushl $do_alignment_check
jmp do_exception
ENTRY(page_fault)
pushl $do_page_fault
jmp do_exception
ENTRY(machine_check)
pushl $0
pushl $do_machine_check
jmp do_exception
ENTRY(spurious_interrupt_bug)
pushl $0
pushl $do_spurious_interrupt_bug
jmp do_exception
ENTRY(thread_starter)
popl %eax
popl %ebx
pushl $0
xorl %ebp,%ebp
pushl %eax
call *%ebx
call exit_thread
ENTRY(__arch_switch_threads)
movl 4(%esp), %ecx /* prev */
movl 8(%esp), %edx /* next */
pushl %ebp
pushl %ebx
pushl %esi
pushl %edi
movl %esp, (%ecx) /* save ESP */
movl (%edx), %esp /* restore ESP */
movl $1f, 4(%ecx) /* save EIP */
pushl 4(%edx) /* restore EIP */
ret
1:
popl %edi
popl %esi
popl %ebx
popl %ebp
ret
|
