BaseMemAllocation.c 2.6 KB

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