StdLib/LibC/StdLib/Malloc.c

   1 /** @file
   2   Definitions for memory allocation routines: calloc, malloc, realloc, free.
   3
   4   The order and contiguity of storage allocated by successive calls to the
   5   calloc, malloc, and realloc functions is unspecified.  The pointer returned
   6   if the allocation succeeds is suitably aligned so that it may be assigned to
   7   a pointer of any type of object and then used to access such an object or an
   8   array of such objects in the space allocated (until the space is explicitly
   9   freed or reallocated).  Each such allocation shall yield a pointer to an
  10   object disjoint from any other object.  The pointer returned points to the
  11   start (lowest byte address) of the allocated space.  If the space can not be
  12   allocated, a null pointer is returned.  If the size of the space requested
  13   is zero, the behavior is implementation-defined; the value returned shall be
  14   either a null pointer or a unique pointer.  The value of a pointer that
  15   refers to freed space is indeterminate.
  16
  17   Copyright (c) 2010 - 2014, Intel Corporation. All rights reserved.<BR>
  18   This program and the accompanying materials
  19   are licensed and made available under the terms and conditions of the BSD License
  20   which accompanies this distribution.  The full text of the license may be found at
  21   http://opensource.org/licenses/bsd-license.php
  22
  23   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  24   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  25  */
  26 #include  <Uefi.h>
  27 #include  <Library/MemoryAllocationLib.h>
  28 #include  <Library/UefiBootServicesTableLib.h>
  29 #include  <Library/BaseLib.h>
  30 #include  <Library/BaseMemoryLib.h>
  31 #include  <Library/DebugLib.h>
  32
  33 #include  <LibConfig.h>
  34
  35 #include  <assert.h>
  36 #include  <stdlib.h>
  37 #include  <errno.h>
  38
  39 #define CPOOL_HEAD_SIGNATURE   SIGNATURE_32('C','p','h','d')
  40
  41 /** The UEFI functions do not provide a way to determine the size of an
  42     allocated region of memory given just a pointer to the start of that
  43     region.  Since this is required for the implementation of realloc,
  44     the memory head structure, CPOOL_HEAD, containing the necessary
  45     information is prepended to the requested space.
  46
  47     The order of members is important.  This structure is 8-byte aligned,
  48     as per the UEFI specification for memory allocation functions.  By
  49     specifying Size as a 64-bit value and placing it immediately before
  50     Data, it ensures that Data will always be 8-byte aligned.
  51
  52     On IA32 systems, this structure is 24 bytes long, excluding Data.
  53     On X64  systems, this structure is 32 bytes long, excluding Data.
  54 **/
  55 typedef struct {
  56   LIST_ENTRY      List;
  57   UINT32          Signature;
  58   UINT64          Size;
  59   CHAR8           Data[1];
  60 } CPOOL_HEAD;
  61
  62 // List of memory allocated by malloc/calloc/etc.
  63 static  LIST_ENTRY      MemPoolHead = INITIALIZE_LIST_HEAD_VARIABLE(MemPoolHead);
  64
  65 /****************************/
  66
  67 /** The malloc function allocates space for an object whose size is specified
  68     by size and whose value is indeterminate.
  69
  70     This implementation uses the UEFI memory allocation boot services to get a
  71     region of memory that is 8-byte aligned and of the specified size.  The
  72     region is allocated with type EfiLoaderData.
  73
  74     @param  size    Size, in bytes, of the region to allocate.
  75
  76     @return   NULL is returned if the space could not be allocated and errno
  77               contains the cause.  Otherwise, a pointer to an 8-byte aligned
  78               region of the requested size is returned.<BR>
  79               If NULL is returned, errno may contain:
  80               - EINVAL: Requested Size is zero.
  81               - ENOMEM: Memory could not be allocated.
  82 **/
  83 void *
  84 malloc(size_t Size)
  85 {
  86   CPOOL_HEAD   *Head;
  87   void         *RetVal;
  88   EFI_STATUS    Status;
  89   UINTN         NodeSize;
  90
  91   if( Size == 0) {
  92     errno = EINVAL;   // Make errno diffenent, just in case of a lingering ENOMEM.
  93     DEBUG((DEBUG_ERROR, "ERROR malloc: Zero Size\n"));
  94     return NULL;
  95   }
  96
  97   NodeSize = (UINTN)(Size + sizeof(CPOOL_HEAD));
  98
  99   DEBUG((DEBUG_POOL, "malloc(%d): NodeSz: %d", Size, NodeSize));
 100
 101   Status = gBS->AllocatePool( EfiLoaderData, NodeSize, (void**)&Head);
 102   if( Status != EFI_SUCCESS) {
 103     RetVal  = NULL;
 104     errno   = ENOMEM;
 105     DEBUG((DEBUG_ERROR, "\nERROR malloc: AllocatePool returned %r\n", Status));
 106   }
 107   else {
 108     assert(Head != NULL);
 109     // Fill out the pool header
 110     Head->Signature = CPOOL_HEAD_SIGNATURE;
 111     Head->Size      = NodeSize;
 112
 113     // Add this node to the list
 114     (void)InsertTailList(&MemPoolHead, (LIST_ENTRY *)Head);
 115
 116     // Return a pointer to the data
 117     RetVal          = (void*)Head->Data;
 118     DEBUG((DEBUG_POOL, " Head: %p, Returns %p\n", Head, RetVal));
 119   }
 120
 121   return RetVal;
 122 }
 123
 124 /** The calloc function allocates space for an array of Num objects, each of
 125     whose size is Size.  The space is initialized to all bits zero.
 126
 127     This implementation uses the UEFI memory allocation boot services to get a
 128     region of memory that is 8-byte aligned and of the specified size.  The
 129     region is allocated with type EfiLoaderData.
 130
 131     @param  Num     Number of objects to allocate.
 132     @param  Size    Size, in bytes, of the objects to allocate space for.
 133
 134     @return   NULL is returned if the space could not be allocated and errno
 135               contains the cause.  Otherwise, a pointer to an 8-byte aligned
 136               region of the requested size is returned.
 137 **/
 138 void *
 139 calloc(size_t Num, size_t Size)
 140 {
 141   void       *RetVal;
 142   size_t      NumSize;
 143
 144   NumSize = Num * Size;
 145   RetVal  = NULL;
 146   if (NumSize != 0) {
 147   RetVal = malloc(NumSize);
 148   if( RetVal != NULL) {
 149     (VOID)ZeroMem( RetVal, NumSize);
 150   }
 151   }
 152   DEBUG((DEBUG_POOL, "0x%p = calloc(%d, %d)\n", RetVal, Num, Size));
 153
 154   return RetVal;
 155 }
 156
 157 /** The free function causes the space pointed to by Ptr to be deallocated,
 158     that is, made available for further allocation.
 159
 160     If Ptr is a null pointer, no action occurs.  Otherwise, if the argument
 161     does not match a pointer earlier returned by the calloc, malloc, or realloc
 162     function, or if the space has been deallocated by a call to free or
 163     realloc, the behavior is undefined.
 164
 165     @param  Ptr     Pointer to a previously allocated region of memory to be freed.
 166
 167 **/
 168 void
 169 free(void *Ptr)
 170 {
 171   CPOOL_HEAD   *Head;
 172
 173   Head = BASE_CR(Ptr, CPOOL_HEAD, Data);
 174   assert(Head != NULL);
 175   DEBUG((DEBUG_POOL, "free(%p): Head: %p\n", Ptr, Head));
 176
 177   if(Ptr != NULL) {
 178     if (Head->Signature == CPOOL_HEAD_SIGNATURE) {
 179       (void) RemoveEntryList((LIST_ENTRY *)Head);   // Remove this node from the malloc pool
 180       (void) gBS->FreePool (Head);                  // Now free the associated memory
 181     }
 182     else {
 183       errno = EFAULT;
 184       DEBUG((DEBUG_ERROR, "ERROR free(0x%p): Signature is 0x%8X, expected 0x%8X\n",
 185              Ptr, Head->Signature, CPOOL_HEAD_SIGNATURE));
 186     }
 187   }
 188   DEBUG((DEBUG_POOL, "free Done\n"));
 189 }
 190
 191 /** The realloc function changes the size of the object pointed to by Ptr to
 192     the size specified by NewSize.
 193
 194     The contents of the object are unchanged up to the lesser of the new and
 195     old sizes.  If the new size is larger, the value of the newly allocated
 196     portion of the object is indeterminate.
 197
 198     If Ptr is a null pointer, the realloc function behaves like the malloc
 199     function for the specified size.
 200
 201     If Ptr does not match a pointer earlier returned by the calloc, malloc, or
 202     realloc function, or if the space has been deallocated by a call to the free
 203     or realloc function, the behavior is undefined.
 204
 205     If the space cannot be allocated, the object pointed to by Ptr is unchanged.
 206
 207     If NewSize is zero and Ptr is not a null pointer, the object it points to
 208     is freed.
 209
 210     This implementation uses the UEFI memory allocation boot services to get a
 211     region of memory that is 8-byte aligned and of the specified size.  The
 212     region is allocated with type EfiLoaderData.
 213
 214     The following combinations of Ptr and NewSize can occur:<BR>
 215       Ptr     NewSize<BR>
 216     --------  -------------------<BR>
 217     - NULL        0                 Returns NULL;
 218     - NULL      > 0                 Same as malloc(NewSize)
 219     - invalid     X                 Returns NULL;
 220     - valid   NewSize >= OldSize    Returns malloc(NewSize) with Oldsize bytes copied from Ptr
 221     - valid   NewSize <  OldSize    Returns new buffer with Oldsize bytes copied from Ptr
 222     - valid       0                 Return NULL.  Frees Ptr.
 223
 224
 225     @param  Ptr     Pointer to a previously allocated region of memory to be resized.
 226     @param  NewSize Size, in bytes, of the new object to allocate space for.
 227
 228     @return   NULL is returned if the space could not be allocated and errno
 229               contains the cause.  Otherwise, a pointer to an 8-byte aligned
 230               region of the requested size is returned.  If NewSize is zero,
 231               NULL is returned and errno will be unchanged.
 232 **/
 233 void *
 234 realloc(void *Ptr, size_t ReqSize)
 235 {
 236   void       *RetVal = NULL;
 237   CPOOL_HEAD *Head    = NULL;
 238   size_t      OldSize = 0;
 239   size_t      NewSize;
 240   size_t      NumCpy;
 241
 242   // Find out the size of the OLD memory region
 243   if( Ptr != NULL) {
 244     Head = BASE_CR (Ptr, CPOOL_HEAD, Data);
 245     assert(Head != NULL);
 246     if (Head->Signature != CPOOL_HEAD_SIGNATURE) {
 247       errno = EFAULT;
 248       DEBUG((DEBUG_ERROR, "ERROR realloc(0x%p): Signature is 0x%8X, expected 0x%8X\n",
 249              Ptr, Head->Signature, CPOOL_HEAD_SIGNATURE));
 250       return NULL;
 251     }
 252     OldSize = (size_t)Head->Size;
 253   }
 254
 255   // At this point, Ptr is either NULL or a valid pointer to an allocated space
 256   NewSize = (size_t)(ReqSize + (sizeof(CPOOL_HEAD)));
 257
 258   if( ReqSize > 0) {
 259     RetVal = malloc(NewSize); // Get the NEW memory region
 260     if( Ptr != NULL) {          // If there is an OLD region...
 261       if( RetVal != NULL) {     // and the NEW region was successfully allocated
 262         NumCpy = OldSize;
 263         if( OldSize > NewSize) {
 264           NumCpy = NewSize;
 265         }
 266         (VOID)CopyMem( RetVal, Ptr, NumCpy);  // Copy old data to the new region.
 267         free( Ptr);                           // and reclaim the old region.
 268       }
 269       else {
 270         errno = ENOMEM;
 271       }
 272     }
 273   }
 274   else {
 275     free( Ptr);                           // Reclaim the old region.
 276   }
 277   DEBUG((DEBUG_POOL, "0x%p = realloc(%p, %d): Head: %p NewSz: %d\n",
 278          RetVal, Ptr, ReqSize, Head, NewSize));
 279
 280   return RetVal;
 281 }