filename renaming to meet coding style.
[mirror_edk2.git] / MdeModulePkg / Universal / DebugSupportDxe / Ia32 / PlDebugSupport.c
1 /**@file
2 IA32 specific debug support functions
3
4 Copyright (c) 2006 - 2007, Intel Corporation
5 All rights reserved. This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
9
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12
13 **/
14
15 //
16 // private header files
17 //
18 #include "PlDebugSupport.h"
19
20 //
21 // This the global main table to keep track of the interrupts
22 //
23 IDT_ENTRY *IdtEntryTable = NULL;
24 DESCRIPTOR NullDesc = 0;
25
26 EFI_STATUS
27 CreateEntryStub (
28 IN EFI_EXCEPTION_TYPE ExceptionType,
29 OUT VOID **Stub
30 )
31 /*++
32
33 Routine Description: Allocate pool for a new IDT entry stub. Copy the generic
34 stub into the new buffer and fixup the vector number and jump target address.
35
36 Arguments:
37 ExceptionType - This is the exception type that the new stub will be created
38 for.
39 Stub - On successful exit, *Stub contains the newly allocated entry stub.
40 Returns:
41 Typically EFI_SUCCESS
42 other possibilities are passed through from AllocatePool
43
44 --*/
45 {
46 UINT8 *StubCopy;
47
48 StubCopy = *Stub;
49
50 //
51 // Fixup the stub code for this vector
52 //
53
54 // The stub code looks like this:
55 //
56 // 00000000 89 25 00000004 R mov AppEsp, esp ; save stack top
57 // 00000006 BC 00008014 R mov esp, offset DbgStkBot ; switch to debugger stack
58 // 0000000B 6A 00 push 0 ; push vector number - will be modified before installed
59 // 0000000D E9 db 0e9h ; jump rel32
60 // 0000000E 00000000 dd 0 ; fixed up to relative address of CommonIdtEntry
61 //
62
63 //
64 // poke in the exception type so the second push pushes the exception type
65 //
66 StubCopy[0x0c] = (UINT8) ExceptionType;
67
68 //
69 // fixup the jump target to point to the common entry
70 //
71 *(UINT32 *) &StubCopy[0x0e] = (UINT32) CommonIdtEntry - (UINT32) &StubCopy[StubSize];
72
73 return EFI_SUCCESS;
74 }
75
76 EFI_STATUS
77 HookEntry (
78 IN EFI_EXCEPTION_TYPE ExceptionType,
79 IN VOID (*NewCallback) ()
80 )
81 /*++
82
83 Routine Description:
84 Creates a nes entry stub. Then saves the current IDT entry and replaces it
85 with an interrupt gate for the new entry point. The IdtEntryTable is updated
86 with the new registered function.
87
88 This code executes in boot services context. The stub entry executes in interrupt
89 context.
90
91 Arguments:
92 ExceptionType - specifies which vector to hook.
93 NewCallback - a pointer to the new function to be registered.
94
95 Returns:
96 EFI_SUCCESS
97 Other possibilities are passed through by CreateEntryStub
98
99 --*/
100 {
101 BOOLEAN OldIntFlagState;
102 EFI_STATUS Status;
103
104 Status = CreateEntryStub (ExceptionType, (VOID **) &IdtEntryTable[ExceptionType].StubEntry);
105 if (Status == EFI_SUCCESS) {
106 OldIntFlagState = WriteInterruptFlag (0);
107 ReadIdt (ExceptionType, &(IdtEntryTable[ExceptionType].OrigDesc));
108
109 ((UINT16 *) &IdtEntryTable[ExceptionType].OrigVector)[0] = ((UINT16 *) &IdtEntryTable[ExceptionType].OrigDesc)[0];
110 ((UINT16 *) &IdtEntryTable[ExceptionType].OrigVector)[1] = ((UINT16 *) &IdtEntryTable[ExceptionType].OrigDesc)[3];
111
112 Vect2Desc (&IdtEntryTable[ExceptionType].NewDesc, IdtEntryTable[ExceptionType].StubEntry);
113 IdtEntryTable[ExceptionType].RegisteredCallback = NewCallback;
114 WriteIdt (ExceptionType, &(IdtEntryTable[ExceptionType].NewDesc));
115 WriteInterruptFlag (OldIntFlagState);
116 }
117
118 return Status;
119 }
120
121 EFI_STATUS
122 UnhookEntry (
123 IN EFI_EXCEPTION_TYPE ExceptionType
124 )
125 /*++
126
127 Routine Description:
128 Undoes HookEntry. This code executes in boot services context.
129
130 Arguments:
131 ExceptionType - specifies which entry to unhook
132
133 Returns:
134 EFI_SUCCESS
135
136 --*/
137 {
138 BOOLEAN OldIntFlagState;
139
140 OldIntFlagState = WriteInterruptFlag (0);
141 WriteIdt (ExceptionType, &(IdtEntryTable[ExceptionType].OrigDesc));
142 WriteInterruptFlag (OldIntFlagState);
143
144 return EFI_SUCCESS;
145 }
146
147 EFI_STATUS
148 ManageIdtEntryTable (
149 VOID (*NewCallback)(),
150 EFI_EXCEPTION_TYPE ExceptionType
151 )
152 /*++
153
154 Routine Description:
155 This is the main worker function that manages the state of the interrupt
156 handlers. It both installs and uninstalls interrupt handlers based on the
157 value of NewCallback. If NewCallback is NULL, then uninstall is indicated.
158 If NewCallback is non-NULL, then install is indicated.
159
160 Arguments:
161 NewCallback - If non-NULL, NewCallback specifies the new handler to register.
162 If NULL, specifies that the previously registered handler should
163 be uninstalled.
164 ExceptionType - Indicates which entry to manage
165
166 Returns:
167 EFI_SUCCESS
168 EFI_INVALID_PARAMETER - requested uninstalling a handler from a vector that has
169 no handler registered for it
170 EFI_ALREADY_STARTED - requested install to a vector that already has a handler registered.
171
172 Other possible return values are passed through from UnHookEntry and HookEntry.
173
174 --*/
175 {
176 EFI_STATUS Status;
177
178 Status = EFI_SUCCESS;
179
180 if (!FeaturePcdGet (PcdNtEmulatorEnable)) {
181 if (CompareDescriptor (&IdtEntryTable[ExceptionType].NewDesc, &NullDesc)) {
182 //
183 // we've already installed to this vector
184 //
185 if (NewCallback != NULL) {
186 //
187 // if the input handler is non-null, error
188 //
189 Status = EFI_ALREADY_STARTED;
190 } else {
191 Status = UnhookEntry (ExceptionType);
192 }
193 } else {
194 //
195 // no user handler installed on this vector
196 //
197 if (NewCallback == NULL) {
198 //
199 // if the input handler is null, error
200 //
201 Status = EFI_INVALID_PARAMETER;
202 } else {
203 Status = HookEntry (ExceptionType, NewCallback);
204 }
205 }
206 }
207
208 return Status;
209 }
210
211 EFI_STATUS
212 EFIAPI
213 GetMaximumProcessorIndex (
214 IN EFI_DEBUG_SUPPORT_PROTOCOL *This,
215 OUT UINTN *MaxProcessorIndex
216 )
217 /*++
218
219 Routine Description: This is a DebugSupport protocol member function.
220
221 Arguments:
222 This - The DebugSupport instance
223 MaxProcessorIndex - The maximuim supported processor index
224
225 Returns:
226 Always returns EFI_SUCCESS with *MaxProcessorIndex set to 0
227
228 --*/
229 {
230 *MaxProcessorIndex = 0;
231 return (EFI_SUCCESS);
232 }
233
234 EFI_STATUS
235 EFIAPI
236 RegisterPeriodicCallback (
237 IN EFI_DEBUG_SUPPORT_PROTOCOL *This,
238 IN UINTN ProcessorIndex,
239 IN EFI_PERIODIC_CALLBACK PeriodicCallback
240 )
241 /*++
242
243 Routine Description: This is a DebugSupport protocol member function.
244
245 Arguments:
246 This - The DebugSupport instance
247 ProcessorIndex - Which processor the callback applies to.
248 PeriodicCallback - Callback function
249
250 Returns:
251
252 EFI_SUCCESS
253 EFI_INVALID_PARAMETER - requested uninstalling a handler from a vector that has
254 no handler registered for it
255 EFI_ALREADY_STARTED - requested install to a vector that already has a handler registered.
256
257 Other possible return values are passed through from UnHookEntry and HookEntry.
258
259 --*/
260 {
261 return ManageIdtEntryTable (PeriodicCallback, SYSTEM_TIMER_VECTOR);
262 }
263
264 EFI_STATUS
265 EFIAPI
266 RegisterExceptionCallback (
267 IN EFI_DEBUG_SUPPORT_PROTOCOL *This,
268 IN UINTN ProcessorIndex,
269 IN EFI_EXCEPTION_CALLBACK NewCallback,
270 IN EFI_EXCEPTION_TYPE ExceptionType
271 )
272 /*++
273
274 Routine Description:
275 This is a DebugSupport protocol member function.
276
277 This code executes in boot services context.
278
279 Arguments:
280 This - The DebugSupport instance
281 ProcessorIndex - Which processor the callback applies to.
282 NewCallback - Callback function
283 ExceptionType - Which exception to hook
284
285 Returns:
286
287 EFI_SUCCESS
288 EFI_INVALID_PARAMETER - requested uninstalling a handler from a vector that has
289 no handler registered for it
290 EFI_ALREADY_STARTED - requested install to a vector that already has a handler registered.
291
292 Other possible return values are passed through from UnHookEntry and HookEntry.
293
294 --*/
295 {
296 return ManageIdtEntryTable (NewCallback, ExceptionType);
297 }
298
299 EFI_STATUS
300 EFIAPI
301 InvalidateInstructionCache (
302 IN EFI_DEBUG_SUPPORT_PROTOCOL *This,
303 IN UINTN ProcessorIndex,
304 IN VOID *Start,
305 IN UINT64 Length
306 )
307 /*++
308
309 Routine Description:
310 This is a DebugSupport protocol member function.
311 Calls assembly routine to flush cache.
312
313 Arguments:
314 This - The DebugSupport instance
315 ProcessorIndex - Which processor the callback applies to.
316 Start - Physical base of the memory range to be invalidated
317 Length - mininum number of bytes in instruction cache to invalidate
318
319 Returns:
320
321 EFI_SUCCESS - always return success
322
323 --*/
324 {
325 AsmWbinvd ();
326 return EFI_SUCCESS;
327 }
328
329 EFI_STATUS
330 plInitializeDebugSupportDriver (
331 VOID
332 )
333 /*++
334
335 Routine Description:
336 Initializes driver's handler registration database.
337
338 This code executes in boot services context.
339
340 Arguments:
341 None
342
343 Returns:
344 EFI_SUCCESS
345 EFI_UNSUPPORTED - if IA32 processor does not support FXSTOR/FXRSTOR instructions,
346 the context save will fail, so these processor's are not supported.
347 EFI_OUT_OF_RESOURCES - not resource to finish initialization
348
349 --*/
350 {
351 EFI_EXCEPTION_TYPE ExceptionType;
352
353 if (!FxStorSupport ()) {
354 return EFI_UNSUPPORTED;
355 }
356
357 IdtEntryTable = AllocateZeroPool (sizeof (IDT_ENTRY) * NUM_IDT_ENTRIES);
358 if (IdtEntryTable == NULL) {
359 return EFI_OUT_OF_RESOURCES;
360 }
361
362 for (ExceptionType = 0; ExceptionType < NUM_IDT_ENTRIES; ExceptionType++) {
363 IdtEntryTable[ExceptionType].StubEntry = (DEBUG_PROC) (UINTN) AllocatePool (StubSize);
364 if (IdtEntryTable[ExceptionType].StubEntry == NULL) {
365 goto ErrorCleanup;
366 }
367
368 CopyMem ((VOID *)(UINTN)IdtEntryTable[ExceptionType].StubEntry, InterruptEntryStub, StubSize);
369 }
370 return EFI_SUCCESS;
371
372 ErrorCleanup:
373
374 for (ExceptionType = 0; ExceptionType < NUM_IDT_ENTRIES; ExceptionType++) {
375 if (IdtEntryTable[ExceptionType].StubEntry != NULL) {
376 FreePool ((VOID *)(UINTN)IdtEntryTable[ExceptionType].StubEntry);
377 }
378 }
379 FreePool (IdtEntryTable);
380
381 return EFI_OUT_OF_RESOURCES;
382 }
383
384 EFI_STATUS
385 EFIAPI
386 plUnloadDebugSupportDriver (
387 IN EFI_HANDLE ImageHandle
388 )
389 /*++
390
391 Routine Description:
392 This is the callback that is written to the LoadedImage protocol instance
393 on the image handle. It uninstalls all registered handlers and frees all entry
394 stub memory.
395
396 This code executes in boot services context.
397
398 Arguments:
399 ImageHandle - The image handle of the unload handler
400
401 Returns:
402
403 EFI_SUCCESS - always return success
404
405 --*/
406 {
407 EFI_EXCEPTION_TYPE ExceptionType;
408
409 for (ExceptionType = 0; ExceptionType < NUM_IDT_ENTRIES; ExceptionType++) {
410 ManageIdtEntryTable (NULL, ExceptionType);
411 }
412
413 FreePool (IdtEntryTable);
414 return EFI_SUCCESS;
415 }
416
417 VOID
418 InterruptDistrubutionHub (
419 EFI_EXCEPTION_TYPE ExceptionType,
420 EFI_SYSTEM_CONTEXT_IA32 *ContextRecord
421 )
422 /*++
423
424 Routine Description: Common piece of code that invokes the registered handlers.
425
426 This code executes in exception context so no efi calls are allowed.
427
428 Arguments:
429 ExceptionType - exception type
430 ContextRecord - system context
431
432 Returns:
433
434 None
435
436 --*/
437 {
438 if (IdtEntryTable[ExceptionType].RegisteredCallback != NULL) {
439 if (ExceptionType != SYSTEM_TIMER_VECTOR) {
440 IdtEntryTable[ExceptionType].RegisteredCallback (ExceptionType, ContextRecord);
441 } else {
442 OrigVector = IdtEntryTable[ExceptionType].OrigVector;
443 IdtEntryTable[ExceptionType].RegisteredCallback (ContextRecord);
444 }
445 }
446 }