reactos/boot/freeldr/freeldr/mm/mm.c

   1 /*
   2  *  FreeLoader
   3  *  Copyright (C) 2006-2008     Aleksey Bragin  <aleksey@reactos.org>
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License along
  16  *  with this program; if not, write to the Free Software Foundation, Inc.,
  17  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  */
  19
  20 #include <freeldr.h>
  21 #include <debug.h>
  22
  23 #if DBG
  24 VOID    DumpMemoryAllocMap(VOID);
  25 #endif // DBG
  26
  27 DBG_DEFAULT_CHANNEL(MEMORY);
  28
  29 PFN_NUMBER LoaderPagesSpanned = 0;
  30
  31 PVOID MmAllocateMemoryWithType(SIZE_T MemorySize, TYPE_OF_MEMORY MemoryType)
  32 {
  33     PFN_NUMBER    PagesNeeded;
  34     PFN_NUMBER    FirstFreePageFromEnd;
  35     PVOID    MemPointer;
  36
  37     if (MemorySize == 0)
  38     {
  39         WARN("MmAllocateMemory() called for 0 bytes. Returning NULL.\n");
  40         UiMessageBoxCritical("Memory allocation failed: MmAllocateMemory() called for 0 bytes.");
  41         return NULL;
  42     }
  43
  44     MemorySize = ROUND_UP(MemorySize, 4);
  45
  46     // Find out how many blocks it will take to
  47     // satisfy this allocation
  48     PagesNeeded = ROUND_UP(MemorySize, MM_PAGE_SIZE) / MM_PAGE_SIZE;
  49
  50     // If we don't have enough available mem
  51     // then return NULL
  52     if (FreePagesInLookupTable < PagesNeeded)
  53     {
  54         ERR("Memory allocation failed in MmAllocateMemory(). Not enough free memory to allocate %d bytes.\n", MemorySize);
  55         UiMessageBoxCritical("Memory allocation failed: out of memory.");
  56         return NULL;
  57     }
  58
  59     FirstFreePageFromEnd = MmFindAvailablePages(PageLookupTableAddress, TotalPagesInLookupTable, PagesNeeded, FALSE);
  60
  61     if (FirstFreePageFromEnd == 0)
  62     {
  63         ERR("Memory allocation failed in MmAllocateMemory(). Not enough free memory to allocate %d bytes.\n", MemorySize);
  64         UiMessageBoxCritical("Memory allocation failed: out of memory.");
  65         return NULL;
  66     }
  67
  68     MmAllocatePagesInLookupTable(PageLookupTableAddress, FirstFreePageFromEnd, PagesNeeded, MemoryType);
  69
  70     FreePagesInLookupTable -= PagesNeeded;
  71     MemPointer = (PVOID)((ULONG_PTR)FirstFreePageFromEnd * MM_PAGE_SIZE);
  72
  73     TRACE("Allocated %d bytes (%d pages) of memory (type %ld) starting at page 0x%lx.\n",
  74           MemorySize, PagesNeeded, MemoryType, FirstFreePageFromEnd);
  75     TRACE("Memory allocation pointer: 0x%x\n", MemPointer);
  76
  77     // Update LoaderPagesSpanned count
  78     if ((((ULONG_PTR)MemPointer + MemorySize + PAGE_SIZE - 1) >> PAGE_SHIFT) > LoaderPagesSpanned)
  79         LoaderPagesSpanned = (((ULONG_PTR)MemPointer + MemorySize + PAGE_SIZE - 1) >> PAGE_SHIFT);
  80
  81     // Now return the pointer
  82     return MemPointer;
  83 }
  84
  85 PVOID MmAllocateMemoryAtAddress(SIZE_T MemorySize, PVOID DesiredAddress, TYPE_OF_MEMORY MemoryType)
  86 {
  87     PFN_NUMBER        PagesNeeded;
  88     PFN_NUMBER        StartPageNumber;
  89     PVOID    MemPointer;
  90
  91     if (MemorySize == 0)
  92     {
  93         WARN("MmAllocateMemoryAtAddress() called for 0 bytes. Returning NULL.\n");
  94         UiMessageBoxCritical("Memory allocation failed: MmAllocateMemoryAtAddress() called for 0 bytes.");
  95         return NULL;
  96     }
  97
  98     // Find out how many blocks it will take to
  99     // satisfy this allocation
 100     PagesNeeded = ROUND_UP(MemorySize, MM_PAGE_SIZE) / MM_PAGE_SIZE;
 101
 102     // Get the starting page number
 103     StartPageNumber = MmGetPageNumberFromAddress(DesiredAddress);
 104
 105     // If we don't have enough available mem
 106     // then return NULL
 107     if (FreePagesInLookupTable < PagesNeeded)
 108     {
 109         ERR("Memory allocation failed in MmAllocateMemoryAtAddress(). "
 110             "Not enough free memory to allocate %d bytes (requesting %d pages but have only %d). "
 111             "\n", MemorySize, PagesNeeded, FreePagesInLookupTable);
 112         UiMessageBoxCritical("Memory allocation failed: out of memory.");
 113         return NULL;
 114     }
 115
 116     if (MmAreMemoryPagesAvailable(PageLookupTableAddress, TotalPagesInLookupTable, DesiredAddress, PagesNeeded) == FALSE)
 117     {
 118         WARN("Memory allocation failed in MmAllocateMemoryAtAddress(). "
 119              "Not enough free memory to allocate %d bytes at address %p.\n",
 120              MemorySize, DesiredAddress);
 121
 122         // Don't tell this to user since caller should try to alloc this memory
 123         // at a different address
 124         //UiMessageBoxCritical("Memory allocation failed: out of memory.");
 125         return NULL;
 126     }
 127
 128     MmAllocatePagesInLookupTable(PageLookupTableAddress, StartPageNumber, PagesNeeded, MemoryType);
 129
 130     FreePagesInLookupTable -= PagesNeeded;
 131     MemPointer = (PVOID)((ULONG_PTR)StartPageNumber * MM_PAGE_SIZE);
 132
 133     TRACE("Allocated %d bytes (%d pages) of memory starting at page %d.\n", MemorySize, PagesNeeded, StartPageNumber);
 134     TRACE("Memory allocation pointer: 0x%x\n", MemPointer);
 135
 136     // Update LoaderPagesSpanned count
 137     if ((((ULONG_PTR)MemPointer + MemorySize + PAGE_SIZE - 1) >> PAGE_SHIFT) > LoaderPagesSpanned)
 138         LoaderPagesSpanned = (((ULONG_PTR)MemPointer + MemorySize + PAGE_SIZE - 1) >> PAGE_SHIFT);
 139
 140     // Now return the pointer
 141     return MemPointer;
 142 }
 143
 144 VOID MmSetMemoryType(PVOID MemoryAddress, SIZE_T MemorySize, TYPE_OF_MEMORY NewType)
 145 {
 146     PFN_NUMBER        PagesNeeded;
 147     PFN_NUMBER        StartPageNumber;
 148
 149     // Find out how many blocks it will take to
 150     // satisfy this allocation
 151     PagesNeeded = ROUND_UP(MemorySize, MM_PAGE_SIZE) / MM_PAGE_SIZE;
 152
 153     // Get the starting page number
 154     StartPageNumber = MmGetPageNumberFromAddress(MemoryAddress);
 155
 156     // Set new type for these pages
 157     MmAllocatePagesInLookupTable(PageLookupTableAddress, StartPageNumber, PagesNeeded, NewType);
 158 }
 159
 160 PVOID MmAllocateHighestMemoryBelowAddress(SIZE_T MemorySize, PVOID DesiredAddress, TYPE_OF_MEMORY MemoryType)
 161 {
 162     PFN_NUMBER        PagesNeeded;
 163     PFN_NUMBER        FirstFreePageFromEnd;
 164     PFN_NUMBER        DesiredAddressPageNumber;
 165     PVOID    MemPointer;
 166
 167     if (MemorySize == 0)
 168     {
 169         WARN("MmAllocateHighestMemoryBelowAddress() called for 0 bytes. Returning NULL.\n");
 170         UiMessageBoxCritical("Memory allocation failed: MmAllocateHighestMemoryBelowAddress() called for 0 bytes.");
 171         return NULL;
 172     }
 173
 174     // Find out how many blocks it will take to
 175     // satisfy this allocation
 176     PagesNeeded = ROUND_UP(MemorySize, MM_PAGE_SIZE) / MM_PAGE_SIZE;
 177
 178     // Get the page number for their desired address
 179     DesiredAddressPageNumber = (ULONG_PTR)DesiredAddress / MM_PAGE_SIZE;
 180
 181     // If we don't have enough available mem
 182     // then return NULL
 183     if (FreePagesInLookupTable < PagesNeeded)
 184     {
 185         ERR("Memory allocation failed in MmAllocateHighestMemoryBelowAddress(). Not enough free memory to allocate %d bytes.\n", MemorySize);
 186         UiMessageBoxCritical("Memory allocation failed: out of memory.");
 187         return NULL;
 188     }
 189
 190     FirstFreePageFromEnd = MmFindAvailablePagesBeforePage(PageLookupTableAddress, TotalPagesInLookupTable, PagesNeeded, DesiredAddressPageNumber);
 191
 192     if (FirstFreePageFromEnd == 0)
 193     {
 194         ERR("Memory allocation failed in MmAllocateHighestMemoryBelowAddress(). Not enough free memory to allocate %d bytes.\n", MemorySize);
 195         UiMessageBoxCritical("Memory allocation failed: out of memory.");
 196         return NULL;
 197     }
 198
 199     MmAllocatePagesInLookupTable(PageLookupTableAddress, FirstFreePageFromEnd, PagesNeeded, MemoryType);
 200
 201     FreePagesInLookupTable -= PagesNeeded;
 202     MemPointer = (PVOID)((ULONG_PTR)FirstFreePageFromEnd * MM_PAGE_SIZE);
 203
 204     TRACE("Allocated %d bytes (%d pages) of memory starting at page %d.\n", MemorySize, PagesNeeded, FirstFreePageFromEnd);
 205     TRACE("Memory allocation pointer: 0x%x\n", MemPointer);
 206
 207     // Update LoaderPagesSpanned count
 208     if ((((ULONG_PTR)MemPointer + MemorySize) >> PAGE_SHIFT) > LoaderPagesSpanned)
 209         LoaderPagesSpanned = (((ULONG_PTR)MemPointer + MemorySize) >> PAGE_SHIFT);
 210
 211     // Now return the pointer
 212     return MemPointer;
 213 }
 214
 215 VOID MmFreeMemory(PVOID MemoryPointer)
 216 {
 217 }
 218
 219 #if DBG
 220
 221 VOID DumpMemoryAllocMap(VOID)
 222 {
 223     PFN_NUMBER    Idx;
 224     PPAGE_LOOKUP_TABLE_ITEM        RealPageLookupTable = (PPAGE_LOOKUP_TABLE_ITEM)PageLookupTableAddress;
 225
 226     DbgPrint("----------- Memory Allocation Bitmap -----------\n");
 227
 228     for (Idx=0; Idx<TotalPagesInLookupTable; Idx++)
 229     {
 230         if ((Idx % 32) == 0)
 231         {
 232             DbgPrint("\n");
 233             DbgPrint("%08x:\t", (Idx * MM_PAGE_SIZE));
 234         }
 235         else if ((Idx % 4) == 0)
 236         {
 237             DbgPrint(" ");
 238         }
 239
 240         switch (RealPageLookupTable[Idx].PageAllocated)
 241         {
 242         case LoaderFree:
 243             DbgPrint("*");
 244             break;
 245         case LoaderBad:
 246             DbgPrint( "-");
 247             break;
 248         case LoaderLoadedProgram:
 249             DbgPrint("O");
 250             break;
 251         case LoaderFirmwareTemporary:
 252             DbgPrint("T");
 253             break;
 254         case LoaderFirmwarePermanent:
 255             DbgPrint( "P");
 256             break;
 257         case LoaderOsloaderHeap:
 258             DbgPrint("H");
 259             break;
 260         case LoaderOsloaderStack:
 261             DbgPrint("S");
 262             break;
 263         case LoaderSystemCode:
 264             DbgPrint("K");
 265             break;
 266         case LoaderHalCode:
 267             DbgPrint("L");
 268             break;
 269         case LoaderBootDriver:
 270             DbgPrint("B");
 271             break;
 272         case LoaderStartupPcrPage:
 273             DbgPrint("G");
 274             break;
 275         case LoaderRegistryData:
 276             DbgPrint("R");
 277             break;
 278         case LoaderMemoryData:
 279             DbgPrint("M");
 280             break;
 281         case LoaderNlsData:
 282             DbgPrint("N");
 283             break;
 284         case LoaderSpecialMemory:
 285             DbgPrint("C");
 286             break;
 287         default:
 288             DbgPrint("?");
 289             break;
 290         }
 291     }
 292
 293     DbgPrint("\n");
 294 }
 295 #endif // DBG
 296
 297 PPAGE_LOOKUP_TABLE_ITEM MmGetMemoryMap(PFN_NUMBER *NoEntries)
 298 {
 299     PPAGE_LOOKUP_TABLE_ITEM        RealPageLookupTable = (PPAGE_LOOKUP_TABLE_ITEM)PageLookupTableAddress;
 300
 301     *NoEntries = TotalPagesInLookupTable;
 302
 303     return RealPageLookupTable;
 304 }
 305