Nt32Pkg/Library/DxeNt32PeCoffExtraActionLib/DxeNt32PeCoffExtraActionLib.c

   1 /**@file
   2
   3 Copyright (c) 2006, Intel Corporation
   4 All rights reserved. This program and the accompanying materials
   5 are licensed and made available under the terms and conditions of the BSD License
   6 which accompanies this distribution.  The full text of the license may be found at
   7 http://opensource.org/licenses/bsd-license.php
   8
   9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11
  12 Module Name:
  13
  14   PeiNt32PeCoffExtraActionLib.c
  15
  16 Abstract:
  17
  18   Provides services to perform additional actions to relocate and unload
  19   PE/Coff image for NT32 environment specific purpose such as souce level debug.
  20   This version only works for DXE phase
  21
  22
  23 **/
  24 //
  25 // The package level header files this module uses
  26 //
  27 #include <FrameworkDxe.h>
  28 #include <WinNtDxe.h>
  29
  30 //
  31 // The protocols, PPI and GUID defintions for this module
  32 //
  33 #include <Protocol/WinNtThunk.h>
  34
  35 #include <Library/PeCoffLib.h>
  36 #include <Library/PeiServicesLib.h>
  37
  38 #include <Library/BaseLib.h>
  39 #include <Library/DebugLib.h>
  40 #include <Library/HobLib.h>
  41 #include <Library/BaseMemoryLib.h>
  42 #include <Library/PeCoffExtraActionLib.h>
  43
  44 #define MAX_PDB_NAME_TO_MOD_HANDLE_ARRAY_SIZE 0x100
  45
  46 typedef struct {
  47   CHAR8   *PdbPointer;
  48   VOID    *ModHandle;
  49 } PDB_NAME_TO_MOD_HANDLE;
  50
  51
  52 //
  53 // Cache of WinNtThunk protocol
  54 //
  55 EFI_WIN_NT_THUNK_PROTOCOL   *mWinNt = NULL;
  56
  57 //
  58 // An Array to hold the ModHandle
  59 //
  60 PDB_NAME_TO_MOD_HANDLE  *mPdbNameModHandleArray = NULL;
  61 UINTN                   mPdbNameModHandleArraySize = 0;
  62
  63
  64 /**
  65   The constructor function gets  the pointer of the WinNT thunk functions
  66   It will ASSERT() if NT thunk protocol is not installed.
  67
  68   @retval EFI_SUCCESS   WinNT thunk protocol is found and cached.
  69
  70 **/
  71 EFI_STATUS
  72 EFIAPI
  73 DxeNt32PeCoffLibExtraActionConstructor (
  74   IN EFI_HANDLE        ImageHandle,
  75   IN EFI_SYSTEM_TABLE  *SystemTable
  76   )
  77 {
  78         EFI_HOB_GUID_TYPE   *GuidHob;
  79
  80   //
  81   // Retrieve WinNtThunkProtocol from GUID'ed HOB
  82   //
  83   GuidHob = GetFirstGuidHob (&gEfiWinNtThunkProtocolGuid);
  84   ASSERT (GuidHob != NULL);
  85   mWinNt = (EFI_WIN_NT_THUNK_PROTOCOL *)(*(UINTN *)(GET_GUID_HOB_DATA (GuidHob)));
  86   ASSERT (mWinNt != NULL);
  87
  88
  89   return EFI_SUCCESS;
  90 }
  91
  92 /**
  93   Convert the passed in Ascii string to Unicode.
  94
  95   This function  Convert the passed in Ascii string to Unicode.Optionally return
  96    the length of the strings..
  97
  98   @param  AsciiString    Pointer to an AscII string
  99   @param  StrLen         Length of string
 100
 101   @return  Pointer to malloc'ed Unicode version of Ascii
 102
 103 **/
 104 CHAR16 *
 105 AsciiToUnicode (
 106   IN  CHAR8   *Ascii,
 107   IN  UINTN   *StrLen OPTIONAL
 108   )
 109 {
 110   UINTN   Index;
 111   CHAR16  *Unicode;
 112
 113   //
 114   // Allocate a buffer for unicode string
 115   //
 116   for (Index = 0; Ascii[Index] != '\0'; Index++)
 117     ;
 118   Unicode = mWinNt->HeapAlloc ( mWinNt->GetProcessHeap (),
 119                                 HEAP_ZERO_MEMORY,
 120                                 ((Index + 1) * sizeof (CHAR16))
 121                                );
 122   if (Unicode == NULL) {
 123     return NULL;
 124   }
 125
 126   for (Index = 0; Ascii[Index] != '\0'; Index++) {
 127     Unicode[Index] = (CHAR16) Ascii[Index];
 128   }
 129
 130   Unicode[Index] = '\0';
 131
 132   if (StrLen != NULL) {
 133     *StrLen = Index;
 134   }
 135
 136   return Unicode;
 137 }
 138 /**
 139   Store the ModHandle in an array indexed by the Pdb File name.
 140   The ModHandle is needed to unload the image.
 141
 142
 143   @param ImageContext - Input data returned from PE Laoder Library. Used to find the
 144                  .PDB file name of the PE Image.
 145   @param ModHandle    - Returned from LoadLibraryEx() and stored for call to
 146                  FreeLibrary().
 147
 148   @return   return EFI_SUCCESS when ModHandle was stored.
 149
 150 --*/
 151 EFI_STATUS
 152 AddModHandle (
 153   IN  PE_COFF_LOADER_IMAGE_CONTEXT         *ImageContext,
 154   IN  VOID                                 *ModHandle
 155   )
 156
 157 {
 158   UINTN                   Index;
 159   PDB_NAME_TO_MOD_HANDLE  *Array;
 160   UINTN                   PreviousSize;
 161   PDB_NAME_TO_MOD_HANDLE  *TempArray;
 162   HANDLE                  Handle;
 163
 164   Array = mPdbNameModHandleArray;
 165   for (Index = 0; Index < mPdbNameModHandleArraySize; Index++, Array++) {
 166     if (Array->PdbPointer == NULL) {
 167       //
 168       // Make a copy of the stirng and store the ModHandle
 169       //
 170       Handle = mWinNt->GetProcessHeap ();
 171       Array->PdbPointer = mWinNt->HeapAlloc ( Handle,
 172                                 HEAP_ZERO_MEMORY,
 173                                 AsciiStrLen (ImageContext->PdbPointer) + 1
 174                                );
 175
 176       ASSERT (Array->PdbPointer != NULL);
 177
 178       AsciiStrCpy (Array->PdbPointer, ImageContext->PdbPointer);
 179       Array->ModHandle = ModHandle;
 180       return EFI_SUCCESS;
 181     }
 182   }
 183
 184   //
 185   // No free space in mPdbNameModHandleArray so grow it by
 186   // MAX_PDB_NAME_TO_MOD_HANDLE_ARRAY_SIZE entires.
 187   //
 188   PreviousSize = mPdbNameModHandleArraySize * sizeof (PDB_NAME_TO_MOD_HANDLE);
 189   mPdbNameModHandleArraySize += MAX_PDB_NAME_TO_MOD_HANDLE_ARRAY_SIZE;
 190   //
 191   // re-allocate a new buffer and copy the old values to the new locaiton.
 192   //
 193   TempArray = mWinNt->HeapAlloc ( mWinNt->GetProcessHeap (),
 194                                 HEAP_ZERO_MEMORY,
 195                                 mPdbNameModHandleArraySize * sizeof (PDB_NAME_TO_MOD_HANDLE)
 196                                );
 197
 198   CopyMem ((VOID *) (UINTN) TempArray, (VOID *) (UINTN)mPdbNameModHandleArray, PreviousSize);
 199
 200   mWinNt->HeapFree (mWinNt->GetProcessHeap (), 0, mPdbNameModHandleArray);
 201
 202   mPdbNameModHandleArray = TempArray;
 203   if (mPdbNameModHandleArray == NULL) {
 204     ASSERT (FALSE);
 205     return EFI_OUT_OF_RESOURCES;
 206   }
 207
 208
 209   return AddModHandle (ImageContext, ModHandle);
 210 }
 211 /**
 212   Return the ModHandle and delete the entry in the array.
 213
 214
 215    @param  ImageContext - Input data returned from PE Laoder Library. Used to find the
 216                  .PDB file name of the PE Image.
 217
 218   @return
 219     ModHandle - ModHandle assoicated with ImageContext is returned
 220     NULL      - No ModHandle associated with ImageContext
 221
 222 **/
 223 VOID *
 224 RemoveModeHandle (
 225   IN  PE_COFF_LOADER_IMAGE_CONTEXT         *ImageContext
 226   )
 227 {
 228   UINTN                   Index;
 229   PDB_NAME_TO_MOD_HANDLE  *Array;
 230
 231   if (ImageContext->PdbPointer == NULL) {
 232     //
 233     // If no PDB pointer there is no ModHandle so return NULL
 234     //
 235     return NULL;
 236   }
 237
 238   Array = mPdbNameModHandleArray;
 239   for (Index = 0; Index < mPdbNameModHandleArraySize; Index++, Array++) {
 240     if ((Array->PdbPointer != NULL) && (AsciiStrCmp(Array->PdbPointer, ImageContext->PdbPointer) == 0)) {
 241       //
 242       // If you find a match return it and delete the entry
 243       //
 244       mWinNt->HeapFree (mWinNt->GetProcessHeap (), 0, Array->PdbPointer);
 245       Array->PdbPointer = NULL;
 246       return Array->ModHandle;
 247     }
 248   }
 249
 250   return NULL;
 251 }
 252
 253 /**
 254   Performs additional actions after a PE/COFF image has been loaded and relocated.
 255
 256   For NT32, this function load symbols to support source level debugging.
 257
 258   If ImageContext is NULL, then ASSERT().
 259
 260   @param  ImageContext  Pointer to the image context structure that describes the
 261                         PE/COFF image that has already been loaded and relocated.
 262
 263 **/
 264 VOID
 265 EFIAPI
 266 PeCoffLoaderRelocateImageExtraAction (
 267   IN OUT PE_COFF_LOADER_IMAGE_CONTEXT  *ImageContext
 268   )
 269 {
 270   VOID              *DllEntryPoint;
 271   CHAR16            *DllFileName;
 272   HMODULE           Library;
 273   UINTN             Index;
 274
 275   ASSERT (ImageContext != NULL);
 276
 277         //
 278   // If we load our own PE COFF images the Windows debugger can not source
 279   //  level debug our code. If a valid PDB pointer exists usw it to load
 280   //  the *.dll file as a library using Windows* APIs. This allows
 281   //  source level debug. The image is still loaded and reloaced
 282   //  in the Framework memory space like on a real system (by the code above),
 283   //  but the entry point points into the DLL loaded by the code bellow.
 284   //
 285
 286   DllEntryPoint = NULL;
 287
 288   //
 289   // Load the DLL if it's not an EBC image.
 290   //
 291   if ((ImageContext->PdbPointer != NULL) &&
 292       (ImageContext->Machine != EFI_IMAGE_MACHINE_EBC)) {
 293     //
 294     // Convert filename from ASCII to Unicode
 295     //
 296     DllFileName = AsciiToUnicode (ImageContext->PdbPointer, &Index);
 297
 298     //
 299     // Check that we have a valid filename
 300     //
 301     if (Index < 5 || DllFileName[Index - 4] != '.') {
 302       mWinNt->HeapFree (mWinNt->GetProcessHeap (), 0, DllFileName);
 303
 304       //
 305       // Never return an error if PeCoffLoaderRelocateImage() succeeded.
 306       // The image will run, but we just can't source level debug. If we
 307       // return an error the image will not run.
 308       //
 309       return;
 310     }
 311     //
 312     // Replace .PDB with .DLL on the filename
 313     //
 314     DllFileName[Index - 3]  = 'D';
 315     DllFileName[Index - 2]  = 'L';
 316     DllFileName[Index - 1]  = 'L';
 317
 318     //
 319     // Load the .DLL file into the user process's address space for source
 320     // level debug
 321     //
 322     Library = mWinNt->LoadLibraryEx  (DllFileName, NULL, DONT_RESOLVE_DLL_REFERENCES);
 323     if (Library != NULL) {
 324       //
 325       // InitializeDriver is the entry point we put in all our EFI DLL's. The
 326       // DONT_RESOLVE_DLL_REFERENCES argument to LoadLIbraryEx() supresses the
 327       // normal DLL entry point of DllMain, and prevents other modules that are
 328       // referenced in side the DllFileName from being loaded. There is no error
 329       // checking as the we can point to the PE32 image loaded by Tiano. This
 330       // step is only needed for source level debuging
 331       //
 332       DllEntryPoint = (VOID *) (UINTN) mWinNt->GetProcAddress (Library, "InitializeDriver");
 333
 334     }
 335
 336     if ((Library != NULL) && (DllEntryPoint != NULL)) {
 337       AddModHandle (ImageContext, Library);
 338       ImageContext->EntryPoint  = (EFI_PHYSICAL_ADDRESS) (UINTN) DllEntryPoint;
 339       DEBUG ((EFI_D_INFO, "LoadLibraryEx (%s,\n               NULL, DONT_RESOLVE_DLL_REFERENCES)\n", DllFileName));
 340     } else {
 341       DEBUG ((EFI_D_ERROR, "WARNING: No source level debug %s. \n", DllFileName));
 342     }
 343
 344     mWinNt->HeapFree (mWinNt->GetProcessHeap (), 0, DllFileName);
 345   }
 346
 347   //
 348   // Never return an error if PeCoffLoaderRelocateImage() succeeded.
 349   // The image will run, but we just can't source level debug. If we
 350   // return an error the image will not run.
 351   //
 352   return;
 353 }
 354
 355 /**
 356   Performs additional actions just before a PE/COFF image is unloaded.  Any resources
 357   that were allocated by PeCoffLoaderRelocateImageExtraAction() must be freed.
 358
 359   For NT32, this function unloads symbols for source level debugging.
 360
 361   If ImageContext is NULL, then ASSERT().
 362
 363   @param  ImageContext  Pointer to the image context structure that describes the
 364                         PE/COFF image that is being unloaded.
 365
 366 **/
 367 VOID
 368 EFIAPI
 369 PeCoffLoaderUnloadImageExtraAction (
 370   IN OUT PE_COFF_LOADER_IMAGE_CONTEXT  *ImageContext
 371   )
 372 {
 373         VOID *ModHandle;
 374
 375   ASSERT (ImageContext != NULL);
 376
 377   ModHandle = RemoveModeHandle (ImageContext);
 378   if (ModHandle != NULL) {
 379     mWinNt->FreeLibrary (ModHandle);
 380   }
 381   return;
 382 }