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 }