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

   1 /*
   2  *  FreeLoader
   3  *  Copyright (C) 1998-2003  Brian Palmer  <brianp@sginet.com>
   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
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19
  20 #include <freeldr.h>
  21 #include <mm.h>
  22 #include "mem.h"
  23 #include <rtl.h>
  24 #include <debug.h>
  25 #include <ui.h>
  26 #include <machine.h>
  27
  28
  29 #ifdef DEBUG
  30 ULONG                   AllocationCount = 0;
  31
  32 VOID            VerifyHeap(VOID);
  33 VOID            DumpMemoryAllocMap(VOID);
  34 VOID            IncrementAllocationCount(VOID);
  35 VOID            DecrementAllocationCount(VOID);
  36 VOID            MemAllocTest(VOID);
  37 #endif // DEBUG
  38
  39 PVOID MmAllocateMemory(ULONG MemorySize)
  40 {
  41         ULONG           PagesNeeded;
  42         ULONG           FirstFreePageFromEnd;
  43         PVOID   MemPointer;
  44
  45         if (MemorySize == 0)
  46         {
  47                 DbgPrint((DPRINT_MEMORY, "MmAllocateMemory() called for 0 bytes. Returning NULL.\n"));
  48                 UiMessageBoxCritical("Memory allocation failed: MmAllocateMemory() called for 0 bytes.");
  49                 return NULL;
  50         }
  51
  52         // Find out how many blocks it will take to
  53         // satisfy this allocation
  54         PagesNeeded = ROUND_UP(MemorySize, MM_PAGE_SIZE) / MM_PAGE_SIZE;
  55
  56         // If we don't have enough available mem
  57         // then return NULL
  58         if (FreePagesInLookupTable < PagesNeeded)
  59         {
  60                 DbgPrint((DPRINT_MEMORY, "Memory allocation failed. Not enough free memory to allocate %d bytes. AllocationCount: %d\n", MemorySize, AllocationCount));
  61                 UiMessageBoxCritical("Memory allocation failed: out of memory.");
  62                 return NULL;
  63         }
  64
  65         FirstFreePageFromEnd = MmFindAvailablePagesFromEnd(PageLookupTableAddress, TotalPagesInLookupTable, PagesNeeded);
  66
  67         if (FirstFreePageFromEnd == 0)
  68         {
  69                 DbgPrint((DPRINT_MEMORY, "Memory allocation failed. Not enough free memory to allocate %d bytes. AllocationCount: %d\n", MemorySize, AllocationCount));
  70                 UiMessageBoxCritical("Memory allocation failed: out of memory.");
  71                 return NULL;
  72         }
  73
  74         MmAllocatePagesInLookupTable(PageLookupTableAddress, FirstFreePageFromEnd, PagesNeeded);
  75
  76         FreePagesInLookupTable -= PagesNeeded;
  77         MemPointer = (PVOID)(FirstFreePageFromEnd * MM_PAGE_SIZE);
  78
  79 #ifdef DEBUG
  80         IncrementAllocationCount();
  81         DbgPrint((DPRINT_MEMORY, "Allocated %d bytes (%d pages) of memory starting at page %d. AllocCount: %d\n", MemorySize, PagesNeeded, FirstFreePageFromEnd, AllocationCount));
  82         DbgPrint((DPRINT_MEMORY, "Memory allocation pointer: 0x%x\n", MemPointer));
  83         //VerifyHeap();
  84 #endif // DEBUG
  85
  86         // Now return the pointer
  87         return MemPointer;
  88 }
  89
  90 PVOID MmAllocateMemoryAtAddress(ULONG MemorySize, PVOID DesiredAddress)
  91 {
  92         ULONG           PagesNeeded;
  93         ULONG           StartPageNumber;
  94         PVOID   MemPointer;
  95
  96         if (MemorySize == 0)
  97         {
  98                 DbgPrint((DPRINT_MEMORY, "MmAllocateMemoryAtAddress() called for 0 bytes. Returning NULL.\n"));
  99                 UiMessageBoxCritical("Memory allocation failed: MmAllocateMemoryAtAddress() called for 0 bytes.");
 100                 return NULL;
 101         }
 102
 103         // Find out how many blocks it will take to
 104         // satisfy this allocation
 105         PagesNeeded = ROUND_UP(MemorySize, MM_PAGE_SIZE) / MM_PAGE_SIZE;
 106
 107         // Get the starting page number
 108         StartPageNumber = MmGetPageNumberFromAddress(DesiredAddress);
 109
 110         // If we don't have enough available mem
 111         // then return NULL
 112         if (FreePagesInLookupTable < PagesNeeded)
 113         {
 114                 DbgPrint((DPRINT_MEMORY, "Memory allocation failed. Not enough free memory to allocate %d bytes. AllocationCount: %d\n", MemorySize, AllocationCount));
 115                 UiMessageBoxCritical("Memory allocation failed: out of memory.");
 116                 return NULL;
 117         }
 118
 119         if (MmAreMemoryPagesAvailable(PageLookupTableAddress, TotalPagesInLookupTable, DesiredAddress, PagesNeeded) == FALSE)
 120         {
 121                 DbgPrint((DPRINT_MEMORY, "Memory allocation failed. Not enough free memory to allocate %d bytes. AllocationCount: %d\n", MemorySize, AllocationCount));
 122                 UiMessageBoxCritical("Memory allocation failed: out of memory.");
 123                 return NULL;
 124         }
 125
 126         MmAllocatePagesInLookupTable(PageLookupTableAddress, StartPageNumber, PagesNeeded);
 127
 128         FreePagesInLookupTable -= PagesNeeded;
 129         MemPointer = (PVOID)(StartPageNumber * MM_PAGE_SIZE);
 130
 131 #ifdef DEBUG
 132         IncrementAllocationCount();
 133         DbgPrint((DPRINT_MEMORY, "Allocated %d bytes (%d pages) of memory starting at page %d. AllocCount: %d\n", MemorySize, PagesNeeded, StartPageNumber, AllocationCount));
 134         DbgPrint((DPRINT_MEMORY, "Memory allocation pointer: 0x%x\n", MemPointer));
 135         //VerifyHeap();
 136 #endif // DEBUG
 137
 138         // Now return the pointer
 139         return MemPointer;
 140 }
 141
 142 PVOID MmAllocateHighestMemoryBelowAddress(ULONG MemorySize, PVOID DesiredAddress)
 143 {
 144         ULONG           PagesNeeded;
 145         ULONG           FirstFreePageFromEnd;
 146         ULONG           DesiredAddressPageNumber;
 147         PVOID   MemPointer;
 148
 149         if (MemorySize == 0)
 150         {
 151                 DbgPrint((DPRINT_MEMORY, "MmAllocateHighestMemoryBelowAddress() called for 0 bytes. Returning NULL.\n"));
 152                 UiMessageBoxCritical("Memory allocation failed: MmAllocateHighestMemoryBelowAddress() called for 0 bytes.");
 153                 return NULL;
 154         }
 155
 156         // Find out how many blocks it will take to
 157         // satisfy this allocation
 158         PagesNeeded = ROUND_UP(MemorySize, MM_PAGE_SIZE) / MM_PAGE_SIZE;
 159
 160         // Get the page number for their desired address
 161         DesiredAddressPageNumber = (ULONG)DesiredAddress / MM_PAGE_SIZE;
 162
 163         // If we don't have enough available mem
 164         // then return NULL
 165         if (FreePagesInLookupTable < PagesNeeded)
 166         {
 167                 DbgPrint((DPRINT_MEMORY, "Memory allocation failed. Not enough free memory to allocate %d bytes. AllocationCount: %d\n", MemorySize, AllocationCount));
 168                 UiMessageBoxCritical("Memory allocation failed: out of memory.");
 169                 return NULL;
 170         }
 171
 172         FirstFreePageFromEnd = MmFindAvailablePagesBeforePage(PageLookupTableAddress, TotalPagesInLookupTable, PagesNeeded, DesiredAddressPageNumber);
 173
 174         if (FirstFreePageFromEnd == 0)
 175         {
 176                 DbgPrint((DPRINT_MEMORY, "Memory allocation failed. Not enough free memory to allocate %d bytes. AllocationCount: %d\n", MemorySize, AllocationCount));
 177                 UiMessageBoxCritical("Memory allocation failed: out of memory.");
 178                 return NULL;
 179         }
 180
 181         MmAllocatePagesInLookupTable(PageLookupTableAddress, FirstFreePageFromEnd, PagesNeeded);
 182
 183         FreePagesInLookupTable -= PagesNeeded;
 184         MemPointer = (PVOID)(FirstFreePageFromEnd * MM_PAGE_SIZE);
 185
 186 #ifdef DEBUG
 187         IncrementAllocationCount();
 188         DbgPrint((DPRINT_MEMORY, "Allocated %d bytes (%d pages) of memory starting at page %d. AllocCount: %d\n", MemorySize, PagesNeeded, FirstFreePageFromEnd, AllocationCount));
 189         DbgPrint((DPRINT_MEMORY, "Memory allocation pointer: 0x%x\n", MemPointer));
 190         //VerifyHeap();
 191 #endif // DEBUG
 192
 193         // Now return the pointer
 194         return MemPointer;
 195 }
 196
 197 VOID MmFreeMemory(PVOID MemoryPointer)
 198 {
 199         ULONG                                                   PageNumber;
 200         ULONG                                                   PageCount;
 201         ULONG                                                   Idx;
 202         PPAGE_LOOKUP_TABLE_ITEM         RealPageLookupTable = (PPAGE_LOOKUP_TABLE_ITEM)PageLookupTableAddress;
 203
 204 #ifdef DEBUG
 205
 206         // Make sure we didn't get a bogus pointer
 207         if (MemoryPointer >= (PVOID)(TotalPagesInLookupTable * MM_PAGE_SIZE))
 208         {
 209                 BugCheck((DPRINT_MEMORY, "Bogus memory pointer (0x%x) passed to MmFreeMemory()\n", MemoryPointer));
 210         }
 211 #endif // DEBUG
 212
 213         // Find out the page number of the first
 214         // page of memory they allocated
 215         PageNumber = MmGetPageNumberFromAddress(MemoryPointer);
 216         PageCount = RealPageLookupTable[PageNumber].PageAllocationLength;
 217
 218 #ifdef DEBUG
 219         // Make sure we didn't get a bogus pointer
 220         if ((PageCount < 1) || (PageCount > (TotalPagesInLookupTable - PageNumber)))
 221         {
 222                 BugCheck((DPRINT_MEMORY, "Invalid page count in lookup table. PageLookupTable[%d].PageAllocationLength = %d\n", PageNumber, RealPageLookupTable[PageNumber].PageAllocationLength));
 223         }
 224
 225         // Loop through our array check all the pages
 226         // to make sure they are allocated with a length of 0
 227         for (Idx=PageNumber+1; Idx<(PageNumber + PageCount); Idx++)
 228         {
 229                 if ((RealPageLookupTable[Idx].PageAllocated != 1) ||
 230                         (RealPageLookupTable[Idx].PageAllocationLength != 0))
 231                 {
 232                         BugCheck((DPRINT_MEMORY, "Invalid page entry in lookup table, PageAllocated should = 1 and PageAllocationLength should = 0 because this is not the first block in the run. PageLookupTable[%d].PageAllocated = %d PageLookupTable[%d].PageAllocationLength = %d\n", PageNumber, RealPageLookupTable[PageNumber].PageAllocated, PageNumber, RealPageLookupTable[PageNumber].PageAllocationLength));
 233                 }
 234         }
 235
 236 #endif
 237
 238         // Loop through our array and mark all the
 239         // blocks as free
 240         for (Idx=PageNumber; Idx<(PageNumber + PageCount); Idx++)
 241         {
 242                 RealPageLookupTable[Idx].PageAllocated = 0;
 243                 RealPageLookupTable[Idx].PageAllocationLength = 0;
 244         }
 245
 246         FreePagesInLookupTable += PageCount;
 247
 248 #ifdef DEBUG
 249         DecrementAllocationCount();
 250         DbgPrint((DPRINT_MEMORY, "Freed %d pages of memory starting at page %d. AllocationCount: %d\n", PageCount, PageNumber, AllocationCount));
 251         //VerifyHeap();
 252 #endif // DEBUG
 253 }
 254
 255 #ifdef DEBUG
 256 VOID VerifyHeap(VOID)
 257 {
 258         ULONG                                                   Idx;
 259         ULONG                                                   Idx2;
 260         ULONG                                                   Count;
 261         PPAGE_LOOKUP_TABLE_ITEM         RealPageLookupTable = (PPAGE_LOOKUP_TABLE_ITEM)PageLookupTableAddress;
 262
 263         if (DUMP_MEM_MAP_ON_VERIFY)
 264         {
 265                 DumpMemoryAllocMap();
 266         }
 267
 268         // Loop through the array and verify that
 269         // everything is kosher
 270         for (Idx=0; Idx<TotalPagesInLookupTable; Idx++)
 271         {
 272                 // Check if this block is allocated
 273                 if (RealPageLookupTable[Idx].PageAllocated != 0)
 274                 {
 275                         // This is the first block in the run so it
 276                         // had better have a length that is within range
 277                         if ((RealPageLookupTable[Idx].PageAllocationLength < 1) || (RealPageLookupTable[Idx].PageAllocationLength > (TotalPagesInLookupTable - Idx)))
 278                         {
 279                                 BugCheck((DPRINT_MEMORY, "Allocation length out of range in heap table. PageLookupTable[Idx].PageAllocationLength = %d\n", RealPageLookupTable[Idx].PageAllocationLength));
 280                         }
 281
 282                         // Now go through and verify that the rest of
 283                         // this run has the blocks marked allocated
 284                         // with a length of zero but don't check the
 285                         // first one because we already did
 286                         Count = RealPageLookupTable[Idx].PageAllocationLength;
 287                         for (Idx2=1; Idx2<Count; Idx2++)
 288                         {
 289                                 // Make sure it's allocated
 290                                 if (RealPageLookupTable[Idx + Idx2].PageAllocated == 0)
 291                                 {
 292                                         BugCheck((DPRINT_MEMORY, "Lookup table indicates hole in memory allocation. RealPageLookupTable[Idx + Idx2].PageAllocated == 0\n"));
 293                                 }
 294
 295                                 // Make sure the length is zero
 296                                 if (RealPageLookupTable[Idx + Idx2].PageAllocationLength != 0)
 297                                 {
 298                                         BugCheck((DPRINT_MEMORY, "Allocation chain has non-zero value in non-first block in lookup table. RealPageLookupTable[Idx + Idx2].PageAllocationLength != 0\n"));
 299                                 }
 300                         }
 301
 302                         // Move on to the next run
 303                         Idx += (Count - 1);
 304                 }
 305                 else
 306                 {
 307                         // Nope, not allocated so make sure the length is zero
 308                         if (RealPageLookupTable[Idx].PageAllocationLength != 0)
 309                         {
 310                                 BugCheck((DPRINT_MEMORY, "Free block is start of memory allocation. RealPageLookupTable[Idx].PageAllocationLength != 0\n"));
 311                         }
 312                 }
 313         }
 314 }
 315
 316 VOID DumpMemoryAllocMap(VOID)
 317 {
 318         ULONG                                                   Idx;
 319         PPAGE_LOOKUP_TABLE_ITEM         RealPageLookupTable = (PPAGE_LOOKUP_TABLE_ITEM)PageLookupTableAddress;
 320
 321         DbgPrint((DPRINT_MEMORY, "----------- Memory Allocation Bitmap -----------\n"));
 322
 323         for (Idx=0; Idx<TotalPagesInLookupTable; Idx++)
 324         {
 325                 if ((Idx % 32) == 0)
 326                 {
 327                         DbgPrint((DPRINT_MEMORY, "\n"));
 328                         DbgPrint((DPRINT_MEMORY, "%x:\t", (Idx * MM_PAGE_SIZE)));
 329                 }
 330                 else if ((Idx % 4) == 0)
 331                 {
 332                         DbgPrint((DPRINT_MEMORY, " "));
 333                 }
 334
 335                 switch (RealPageLookupTable[Idx].PageAllocated)
 336                 {
 337                 case 0:
 338                         DbgPrint((DPRINT_MEMORY, "*"));
 339                         break;
 340                 case 1:
 341                         DbgPrint((DPRINT_MEMORY, "A"));
 342                         break;
 343                 case MEMTYPE_RESERVED:
 344                         DbgPrint((DPRINT_MEMORY, "R"));
 345                         break;
 346                 case MEMTYPE_ACPI_RECLAIM:
 347                         DbgPrint((DPRINT_MEMORY, "M"));
 348                         break;
 349                 case MEMTYPE_ACPI_NVS:
 350                         DbgPrint((DPRINT_MEMORY, "N"));
 351                         break;
 352                 default:
 353                         DbgPrint((DPRINT_MEMORY, "X"));
 354                         break;
 355                 }
 356         }
 357
 358         DbgPrint((DPRINT_MEMORY, "\n"));
 359 }
 360
 361 VOID IncrementAllocationCount(VOID)
 362 {
 363         AllocationCount++;
 364 }
 365
 366 VOID DecrementAllocationCount(VOID)
 367 {
 368         AllocationCount--;
 369 }
 370
 371 VOID MemAllocTest(VOID)
 372 {
 373         PVOID   MemPtr1;
 374         PVOID   MemPtr2;
 375         PVOID   MemPtr3;
 376         PVOID   MemPtr4;
 377         PVOID   MemPtr5;
 378
 379         MemPtr1 = MmAllocateMemory(4096);
 380         printf("MemPtr1: 0x%x\n", (int)MemPtr1);
 381         MachConsGetCh();
 382         MemPtr2 = MmAllocateMemory(4096);
 383         printf("MemPtr2: 0x%x\n", (int)MemPtr2);
 384         MachConsGetCh();
 385         MemPtr3 = MmAllocateMemory(4096);
 386         printf("MemPtr3: 0x%x\n", (int)MemPtr3);
 387         DumpMemoryAllocMap();
 388         VerifyHeap();
 389         MachConsGetCh();
 390
 391         MmFreeMemory(MemPtr2);
 392         MachConsGetCh();
 393
 394         MemPtr4 = MmAllocateMemory(2048);
 395         printf("MemPtr4: 0x%x\n", (int)MemPtr4);
 396         MachConsGetCh();
 397         MemPtr5 = MmAllocateMemory(4096);
 398         printf("MemPtr5: 0x%x\n", (int)MemPtr5);
 399         MachConsGetCh();
 400 }
 401 #endif // DEBUG
 402
 403 ULONG GetSystemMemorySize(VOID)
 404 {
 405         return (TotalPagesInLookupTable * MM_PAGE_SIZE);
 406 }