CryptoPkg/Library/BaseCryptLib/SysCall/BaseMemAllocation.c

   1 /** @file
   2   Base Memory Allocation Routines Wrapper for Crypto library over OpenSSL
   3   during PEI & DXE phases.
   4
   5 Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
   6 SPDX-License-Identifier: BSD-2-Clause-Patent
   7
   8 **/
   9
  10 #include <CrtLibSupport.h>
  11 #include <Library/MemoryAllocationLib.h>
  12
  13 //
  14 // Extra header to record the memory buffer size from malloc routine.
  15 //
  16 #define CRYPTMEM_HEAD_SIGNATURE    SIGNATURE_32('c','m','h','d')
  17 typedef struct {
  18   UINT32    Signature;
  19   UINT32    Reserved;
  20   UINTN     Size;
  21 } CRYPTMEM_HEAD;
  22
  23 #define CRYPTMEM_OVERHEAD      sizeof(CRYPTMEM_HEAD)
  24
  25 //
  26 // -- Memory-Allocation Routines --
  27 //
  28
  29 /* Allocates memory blocks */
  30 void *malloc (size_t size)
  31 {
  32   CRYPTMEM_HEAD  *PoolHdr;
  33   UINTN          NewSize;
  34   VOID           *Data;
  35
  36   //
  37   // Adjust the size by the buffer header overhead
  38   //
  39   NewSize = (UINTN)(size) + CRYPTMEM_OVERHEAD;
  40
  41   Data  = AllocatePool (NewSize);
  42   if (Data != NULL) {
  43     PoolHdr = (CRYPTMEM_HEAD *)Data;
  44     //
  45     // Record the memory brief information
  46     //
  47     PoolHdr->Signature = CRYPTMEM_HEAD_SIGNATURE;
  48     PoolHdr->Size      = size;
  49
  50     return (VOID *)(PoolHdr + 1);
  51   } else {
  52     //
  53     // The buffer allocation failed.
  54     //
  55     return NULL;
  56   }
  57 }
  58
  59 /* Reallocate memory blocks */
  60 void *realloc (void *ptr, size_t size)
  61 {
  62   CRYPTMEM_HEAD  *OldPoolHdr;
  63   CRYPTMEM_HEAD  *NewPoolHdr;
  64   UINTN          OldSize;
  65   UINTN          NewSize;
  66   VOID           *Data;
  67
  68   NewSize = (UINTN)size + CRYPTMEM_OVERHEAD;
  69   Data = AllocatePool (NewSize);
  70   if (Data != NULL) {
  71     NewPoolHdr = (CRYPTMEM_HEAD *)Data;
  72     NewPoolHdr->Signature = CRYPTMEM_HEAD_SIGNATURE;
  73     NewPoolHdr->Size      = size;
  74     if (ptr != NULL) {
  75       //
  76       // Retrieve the original size from the buffer header.
  77       //
  78       OldPoolHdr = (CRYPTMEM_HEAD *)ptr - 1;
  79       ASSERT (OldPoolHdr->Signature == CRYPTMEM_HEAD_SIGNATURE);
  80       OldSize = OldPoolHdr->Size;
  81
  82       //
  83       // Duplicate the buffer content.
  84       //
  85       CopyMem ((VOID *)(NewPoolHdr + 1), ptr, MIN (OldSize, size));
  86       FreePool ((VOID *)OldPoolHdr);
  87     }
  88
  89     return (VOID *)(NewPoolHdr + 1);
  90   } else {
  91     //
  92     // The buffer allocation failed.
  93     //
  94     return NULL;
  95   }
  96 }
  97
  98 /* De-allocates or frees a memory block */
  99 void free (void *ptr)
 100 {
 101   CRYPTMEM_HEAD  *PoolHdr;
 102
 103   //
 104   // In Standard C, free() handles a null pointer argument transparently. This
 105   // is not true of FreePool() below, so protect it.
 106   //
 107   if (ptr != NULL) {
 108     PoolHdr = (CRYPTMEM_HEAD *)ptr - 1;
 109     ASSERT (PoolHdr->Signature == CRYPTMEM_HEAD_SIGNATURE);
 110     FreePool (PoolHdr);
 111   }
 112 }