CryptoPkg/Library/BaseCryptLib/SysCall/RuntimeMemAllocation.c

   1 /** @file
   2   Light-weight Memory Management Routines for OpenSSL-based Crypto
   3   Library at Runtime Phase.
   4
   5 Copyright (c) 2009 - 2012, Intel Corporation. All rights reserved.<BR>
   6 This program and the accompanying materials
   7 are licensed and made available under the terms and conditions of the BSD License
   8 which accompanies this distribution.  The full text of the license may be found at
   9 http://opensource.org/licenses/bsd-license.php
  10
  11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 #include <OpenSslSupport.h>
  17 #include <Library/UefiBootServicesTableLib.h>
  18 #include <Library/UefiRuntimeLib.h>
  19 #include <Guid/EventGroup.h>
  20
  21 //----------------------------------------------------------------
  22 // Initial version. Needs further optimizations.
  23 //----------------------------------------------------------------
  24
  25 //
  26 // Definitions for Runtime Memory Operations
  27 //
  28 #define RT_PAGE_SIZE                0x200
  29 #define RT_PAGE_MASK                0x1FF
  30 #define RT_PAGE_SHIFT               9
  31
  32 #define RT_SIZE_TO_PAGES(a)         (((a) >> RT_PAGE_SHIFT) + (((a) & RT_PAGE_MASK) ? 1 : 0))
  33 #define RT_PAGES_TO_SIZE(a)         ((a) << RT_PAGE_SHIFT)
  34
  35 //
  36 // Page Flag Definitions
  37 //
  38 #define RT_PAGE_FREE                0x00000000
  39 #define RT_PAGE_USED                0x00000001
  40
  41 #define MIN_REQUIRED_BLOCKS         600
  42
  43 //
  44 // Memory Page Table
  45 //
  46 typedef struct {
  47   UINTN   StartPageOffset;      // Offset of the starting page allocated.
  48                                 // Only available for USED pages.
  49   UINT32  PageFlag;             // Page Attributes.
  50 } RT_MEMORY_PAGE_ENTRY;
  51
  52 typedef struct {
  53   UINTN                 PageCount;
  54   UINTN                 LastEmptyPageOffset;
  55   UINT8                 *DataAreaBase;         // Pointer to data Area.
  56   RT_MEMORY_PAGE_ENTRY  Pages[1];              // Page Table Entries.
  57 } RT_MEMORY_PAGE_TABLE;
  58
  59 //
  60 // Global Page Table for Runtime Cryptographic Provider.
  61 //
  62 RT_MEMORY_PAGE_TABLE  *mRTPageTable = NULL;
  63
  64 //
  65 // Event for Runtime Address Conversion.
  66 //
  67 STATIC EFI_EVENT      mVirtualAddressChangeEvent;
  68
  69
  70 /**
  71   Initializes pre-allocated memory pointed by ScratchBuffer for subsequent
  72   runtime use.
  73
  74   @param[in, out]  ScratchBuffer      Pointer to user-supplied memory buffer.
  75   @param[in]       ScratchBufferSize  Size of supplied buffer in bytes.
  76
  77   @retval EFI_SUCCESS  Successful initialization.
  78
  79 **/
  80 EFI_STATUS
  81 InitializeScratchMemory (
  82   IN OUT  UINT8  *ScratchBuffer,
  83   IN      UINTN  ScratchBufferSize
  84   )
  85 {
  86   UINTN  Index;
  87   UINTN  MemorySize;
  88
  89   //
  90   // Parameters Checking
  91   //
  92   if (ScratchBuffer == NULL) {
  93     return EFI_INVALID_PARAMETER;
  94   }
  95
  96   if (ScratchBufferSize < MIN_REQUIRED_BLOCKS * 1024) {
  97     return EFI_BUFFER_TOO_SMALL;
  98   }
  99
 100   mRTPageTable = (RT_MEMORY_PAGE_TABLE *)ScratchBuffer;
 101
 102   //
 103   // Initialize Internal Page Table for Memory Management
 104   //
 105   SetMem (mRTPageTable, ScratchBufferSize, 0xFF);
 106   MemorySize = ScratchBufferSize - sizeof (RT_MEMORY_PAGE_TABLE) + sizeof (RT_MEMORY_PAGE_ENTRY);
 107
 108   mRTPageTable->PageCount           = MemorySize / (RT_PAGE_SIZE + sizeof (RT_MEMORY_PAGE_ENTRY));
 109   mRTPageTable->LastEmptyPageOffset = 0x0;
 110
 111   for (Index = 0; Index < mRTPageTable->PageCount; Index++) {
 112     mRTPageTable->Pages[Index].PageFlag        = RT_PAGE_FREE;
 113     mRTPageTable->Pages[Index].StartPageOffset = 0;
 114   }
 115
 116   mRTPageTable->DataAreaBase = ScratchBuffer + sizeof (RT_MEMORY_PAGE_TABLE) +
 117                                (mRTPageTable->PageCount - 1) * sizeof (RT_MEMORY_PAGE_ENTRY);
 118
 119   return EFI_SUCCESS;
 120 }
 121
 122
 123 /**
 124   Look-up Free memory Region for object allocation.
 125
 126   @param[in]  AllocationSize  Bytes to be allocated.
 127
 128   @return  Return available page offset for object allocation.
 129
 130 **/
 131 UINTN
 132 LookupFreeMemRegion (
 133   IN  UINTN  AllocationSize
 134   )
 135 {
 136   UINTN  StartPageIndex;
 137   UINTN  Index;
 138   UINTN  SubIndex;
 139   UINTN  ReqPages;
 140
 141   StartPageIndex = RT_SIZE_TO_PAGES (mRTPageTable->LastEmptyPageOffset);
 142   ReqPages       = RT_SIZE_TO_PAGES (AllocationSize);
 143
 144   //
 145   // Look up the free memory region with in current memory map table.
 146   //
 147   for (Index = StartPageIndex; Index <= (mRTPageTable->PageCount - ReqPages); ) {
 148     //
 149     // Check consecutive ReqPages pages.
 150     //
 151     for (SubIndex = 0; SubIndex < ReqPages; SubIndex++) {
 152       if ((mRTPageTable->Pages[SubIndex + Index].PageFlag & RT_PAGE_USED) != 0) {
 153         break;
 154       }
 155     }
 156
 157     if (SubIndex == ReqPages) {
 158       //
 159       // Succeed! Return the Starting Offset.
 160       //
 161       return RT_PAGES_TO_SIZE (Index);
 162     }
 163
 164     //
 165     // Failed! Skip current free memory pages and adjacent Used pages
 166     //
 167     while ((mRTPageTable->Pages[SubIndex + Index].PageFlag & RT_PAGE_USED) != 0) {
 168       SubIndex++;
 169     }
 170
 171     Index += SubIndex;
 172   }
 173
 174   //
 175   // Look up the free memory region from the beginning of the memory table
 176   // until the StartCursorOffset
 177   //
 178   for (Index = 0; Index < (StartPageIndex - ReqPages); ) {
 179     //
 180     // Check Consecutive ReqPages Pages.
 181     //
 182     for (SubIndex = 0; SubIndex < ReqPages; SubIndex++) {
 183       if ((mRTPageTable->Pages[SubIndex + Index].PageFlag & RT_PAGE_USED) != 0) {
 184         break;
 185       }
 186     }
 187
 188     if (SubIndex == ReqPages) {
 189       //
 190       // Succeed! Return the Starting Offset.
 191       //
 192       return RT_PAGES_TO_SIZE (Index);
 193     }
 194
 195     //
 196     // Failed! Skip current adjacent Used pages
 197     //
 198     while ((SubIndex < (StartPageIndex - ReqPages)) &&
 199            ((mRTPageTable->Pages[SubIndex + Index].PageFlag & RT_PAGE_USED) != 0)) {
 200       SubIndex++;
 201     }
 202
 203     Index += SubIndex;
 204   }
 205
 206   //
 207   // No availabe region for object allocation!
 208   //
 209   return (UINTN)(-1);
 210 }
 211
 212
 213 /**
 214   Allocates a buffer at runtime phase.
 215
 216   @param[in]  AllocationSize    Bytes to be allocated.
 217
 218   @return  A pointer to the allocated buffer or NULL if allocation fails.
 219
 220 **/
 221 VOID *
 222 RuntimeAllocateMem (
 223   IN  UINTN  AllocationSize
 224   )
 225 {
 226   UINT8  *AllocPtr;
 227   UINTN  ReqPages;
 228   UINTN  Index;
 229   UINTN  StartPage;
 230   UINTN  AllocOffset;
 231
 232   AllocPtr = NULL;
 233   ReqPages = 0;
 234
 235   //
 236   // Look for available consecutive memory region starting from LastEmptyPageOffset.
 237   // If no proper memory region found, look up from the beginning.
 238   // If still not found, return NULL to indicate failed allocation.
 239   //
 240   AllocOffset = LookupFreeMemRegion (AllocationSize);
 241   if (AllocOffset == (UINTN)(-1)) {
 242     return NULL;
 243   }
 244
 245   //
 246   // Allocates consecutive memory pages with length of Size. Update the page
 247   // table status. Returns the starting address.
 248   //
 249   ReqPages  = RT_SIZE_TO_PAGES (AllocationSize);
 250   AllocPtr  = mRTPageTable->DataAreaBase + AllocOffset;
 251   StartPage = RT_SIZE_TO_PAGES (AllocOffset);
 252   Index     = 0;
 253   while (Index < ReqPages) {
 254     mRTPageTable->Pages[StartPage + Index].PageFlag       |= RT_PAGE_USED;
 255     mRTPageTable->Pages[StartPage + Index].StartPageOffset = AllocOffset;
 256
 257     Index++;
 258   }
 259
 260   mRTPageTable->LastEmptyPageOffset = AllocOffset + RT_PAGES_TO_SIZE (ReqPages);
 261
 262   ZeroMem (AllocPtr, AllocationSize);
 263
 264   //
 265   // Returns a void pointer to the allocated space
 266   //
 267   return AllocPtr;
 268 }
 269
 270
 271 /**
 272   Frees a buffer that was previously allocated at runtime phase.
 273
 274   @param[in]  Buffer  Pointer to the buffer to free.
 275
 276 **/
 277 VOID
 278 RuntimeFreeMem (
 279   IN  VOID  *Buffer
 280   )
 281 {
 282   UINTN  StartOffset;
 283   UINTN  StartPageIndex;
 284
 285   StartOffset    = (UINTN) ((UINT8 *)Buffer - mRTPageTable->DataAreaBase);
 286   StartPageIndex = RT_SIZE_TO_PAGES (mRTPageTable->Pages[RT_SIZE_TO_PAGES(StartOffset)].StartPageOffset);
 287
 288   while (StartPageIndex < mRTPageTable->PageCount) {
 289     if (((mRTPageTable->Pages[StartPageIndex].PageFlag & RT_PAGE_USED) != 0) &&
 290         (mRTPageTable->Pages[StartPageIndex].StartPageOffset == StartOffset)) {
 291         //
 292         // Free this page
 293         //
 294         mRTPageTable->Pages[StartPageIndex].PageFlag       &= ~RT_PAGE_USED;
 295         mRTPageTable->Pages[StartPageIndex].PageFlag       |= RT_PAGE_FREE;
 296         mRTPageTable->Pages[StartPageIndex].StartPageOffset = 0;
 297
 298         StartPageIndex++;
 299     } else {
 300       break;
 301     }
 302   }
 303
 304   return;
 305 }
 306
 307
 308 /**
 309   Notification function of EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE.
 310
 311   This is a notification function registered on EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE
 312   event. It converts a pointer to a new virtual address.
 313
 314   @param[in]  Event      The event whose notification function is being invoked.
 315   @param[in]  Context    The pointer to the notification function's context.
 316
 317 **/
 318 VOID
 319 EFIAPI
 320 RuntimeCryptLibAddressChangeEvent (
 321   IN  EFI_EVENT        Event,
 322   IN  VOID             *Context
 323   )
 324 {
 325   //
 326   // Converts a pointer for runtime memory management to a new virtual address.
 327   //
 328   EfiConvertPointer (0x0, (VOID **) &mRTPageTable->DataAreaBase);
 329   EfiConvertPointer (0x0, (VOID **) &mRTPageTable);
 330 }
 331
 332
 333 /**
 334   Constructor routine for runtime crypt library instance.
 335
 336   The constructor function pre-allocates space for runtime cryptographic operation.
 337
 338   @param  ImageHandle   The firmware allocated handle for the EFI image.
 339   @param  SystemTable   A pointer to the EFI System Table.
 340
 341   @retval EFI_SUCCESS          The construction succeeded.
 342   @retval EFI_OUT_OF_RESOURCE  Failed to allocate memory.
 343
 344 **/
 345 EFI_STATUS
 346 EFIAPI
 347 RuntimeCryptLibConstructor (
 348   IN EFI_HANDLE        ImageHandle,
 349   IN EFI_SYSTEM_TABLE  *SystemTable
 350   )
 351 {
 352   EFI_STATUS  Status;
 353   VOID        *Buffer;
 354
 355   //
 356   // Pre-allocates runtime space for possible cryptographic operations
 357   //
 358   Buffer = AllocateRuntimePool (MIN_REQUIRED_BLOCKS * 1024);
 359   Status = InitializeScratchMemory (Buffer, MIN_REQUIRED_BLOCKS * 1024);
 360   if (EFI_ERROR (Status)) {
 361     return Status;
 362   }
 363
 364   //
 365   // Create address change event
 366   //
 367   Status = gBS->CreateEventEx (
 368                   EVT_NOTIFY_SIGNAL,
 369                   TPL_NOTIFY,
 370                   RuntimeCryptLibAddressChangeEvent,
 371                   NULL,
 372                   &gEfiEventVirtualAddressChangeGuid,
 373                   &mVirtualAddressChangeEvent
 374                   );
 375   ASSERT_EFI_ERROR (Status);
 376
 377   return Status;
 378 }
 379
 380
 381 //
 382 // -- Memory-Allocation Routines Wrapper for UEFI-OpenSSL Library --
 383 //
 384
 385 /* Allocates memory blocks */
 386 void *malloc (size_t size)
 387 {
 388   return RuntimeAllocateMem ((UINTN) size);
 389 }
 390
 391 /* Reallocate memory blocks */
 392 void *realloc (void *ptr, size_t size)
 393 {
 394   VOID   *NewPtr;
 395   UINTN  StartOffset;
 396   UINTN  StartPageIndex;
 397   UINTN  PageCount;
 398
 399   //
 400   // Get Original Size of ptr
 401   //
 402   StartOffset    = (UINTN) ((UINT8 *)ptr - mRTPageTable->DataAreaBase);
 403   StartPageIndex = RT_SIZE_TO_PAGES (mRTPageTable->Pages[RT_SIZE_TO_PAGES (StartOffset)].StartPageOffset);
 404   PageCount      = 0;
 405   while (StartPageIndex < mRTPageTable->PageCount) {
 406     if (((mRTPageTable->Pages[StartPageIndex].PageFlag & RT_PAGE_USED) != 0) &&
 407         (mRTPageTable->Pages[StartPageIndex].StartPageOffset == StartOffset)) {
 408         StartPageIndex++;
 409         PageCount++;
 410     } else {
 411       break;
 412     }
 413   }
 414
 415   if (size <= RT_PAGES_TO_SIZE (PageCount)) {
 416     //
 417     // Return the original pointer, if Caller try to reduce region size;
 418     //
 419     return ptr;
 420   }
 421
 422   NewPtr = RuntimeAllocateMem ((UINTN) size);
 423   if (NewPtr == NULL) {
 424     return NULL;
 425   }
 426
 427   CopyMem (NewPtr, ptr, RT_PAGES_TO_SIZE (PageCount));
 428
 429   RuntimeFreeMem (ptr);
 430
 431   return NewPtr;
 432 }
 433
 434 /* Deallocates or frees a memory block */
 435 void free (void *ptr)
 436 {
 437   //
 438   // In Standard C, free() handles a null pointer argument transparently. This
 439   // is not true of RuntimeFreeMem() below, so protect it.
 440   //
 441   if (ptr != NULL) {
 442     RuntimeFreeMem (ptr);
 443   }
 444 }