grub-core/efiemu/mm.c

   1 /* Memory management for efiemu */
   2 /*
   3  *  GRUB  --  GRand Unified Bootloader
   4  *  Copyright (C) 2009  Free Software Foundation, Inc.
   5  *
   6  *  GRUB is free software: you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation, either version 3 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  GRUB is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19 /*
  20   To keep efiemu runtime contiguous this mm is special.
  21   It uses deferred allocation.
  22   In the first stage you may request memory with grub_efiemu_request_memalign
  23   It will give you a handle with which in the second phase you can access your
  24   memory with grub_efiemu_mm_obtain_request (handle). It's guaranteed that
  25   subsequent calls with the same handle return the same result. You can't request any additional memory once you're in the second phase
  26 */
  27
  28 #include <grub/err.h>
  29 #include <grub/normal.h>
  30 #include <grub/mm.h>
  31 #include <grub/misc.h>
  32 #include <grub/efiemu/efiemu.h>
  33 #include <grub/memory.h>
  34
  35 struct grub_efiemu_memrequest
  36 {
  37   struct grub_efiemu_memrequest *next;
  38   grub_efi_memory_type_t type;
  39   grub_size_t size;
  40   grub_size_t align_overhead;
  41   int handle;
  42   void *val;
  43 };
  44 /* Linked list of requested memory. */
  45 static struct grub_efiemu_memrequest *memrequests = 0;
  46 /* Memory map. */
  47 static grub_efi_memory_descriptor_t *efiemu_mmap = 0;
  48 /* Pointer to allocated memory */
  49 static void *resident_memory = 0;
  50 /* Size of requested memory per type */
  51 static grub_size_t requested_memory[GRUB_EFI_MAX_MEMORY_TYPE];
  52 /* How many slots is allocated for memory_map and how many are already used */
  53 static int mmap_reserved_size = 0, mmap_num = 0;
  54
  55 /* Add a memory region to map*/
  56 static grub_err_t
  57 grub_efiemu_add_to_mmap (grub_uint64_t start, grub_uint64_t size,
  58                          grub_efi_memory_type_t type)
  59 {
  60   grub_uint64_t page_start, npages;
  61
  62   /* Extend map if necessary*/
  63   if (mmap_num >= mmap_reserved_size)
  64     {
  65       void *old;
  66       mmap_reserved_size = 2 * (mmap_reserved_size + 1);
  67       old = efiemu_mmap;
  68       efiemu_mmap = (grub_efi_memory_descriptor_t *)
  69         grub_realloc (efiemu_mmap, mmap_reserved_size
  70                       * sizeof (grub_efi_memory_descriptor_t));
  71       if (!efiemu_mmap)
  72         {
  73           grub_free (old);
  74           return grub_errno;
  75         }
  76     }
  77
  78   /* Fill slot*/
  79   page_start = start - (start % GRUB_EFIEMU_PAGESIZE);
  80   npages = (size + (start % GRUB_EFIEMU_PAGESIZE) + GRUB_EFIEMU_PAGESIZE - 1)
  81     / GRUB_EFIEMU_PAGESIZE;
  82   efiemu_mmap[mmap_num].physical_start = page_start;
  83   efiemu_mmap[mmap_num].virtual_start = page_start;
  84   efiemu_mmap[mmap_num].num_pages = npages;
  85   efiemu_mmap[mmap_num].type = type;
  86   mmap_num++;
  87
  88   return GRUB_ERR_NONE;
  89 }
  90
  91 /* Request a resident memory of type TYPE of size SIZE aligned at ALIGN
  92    ALIGN must be a divisor of page size (if it's a divisor of 4096
  93    it should be ok on all platforms)
  94  */
  95 int
  96 grub_efiemu_request_memalign (grub_size_t align, grub_size_t size,
  97                               grub_efi_memory_type_t type)
  98 {
  99   grub_size_t align_overhead;
 100   struct grub_efiemu_memrequest *ret, *cur, *prev;
 101   /* Check that the request is correct */
 102   if (type <= GRUB_EFI_LOADER_CODE || type == GRUB_EFI_PERSISTENT_MEMORY ||
 103         type >= GRUB_EFI_MAX_MEMORY_TYPE)
 104     return -2;
 105
 106   /* Add new size to requested size */
 107   align_overhead = align - (requested_memory[type]%align);
 108   if (align_overhead == align)
 109     align_overhead = 0;
 110   requested_memory[type] += align_overhead + size;
 111
 112   /* Remember the request */
 113   ret = grub_zalloc (sizeof (*ret));
 114   if (!ret)
 115     return -1;
 116   ret->type = type;
 117   ret->size = size;
 118   ret->align_overhead = align_overhead;
 119   prev = 0;
 120
 121   /* Add request to the end of the chain.
 122      It should be at the end because otherwise alignment isn't guaranteed */
 123   for (cur = memrequests; cur; prev = cur, cur = cur->next);
 124   if (prev)
 125     {
 126       ret->handle = prev->handle + 1;
 127       prev->next = ret;
 128     }
 129   else
 130     {
 131       ret->handle = 1; /* Avoid 0 handle*/
 132       memrequests = ret;
 133     }
 134   return ret->handle;
 135 }
 136
 137 /* Really allocate the memory */
 138 static grub_err_t
 139 efiemu_alloc_requests (void)
 140 {
 141   grub_size_t align_overhead = 0;
 142   grub_uint8_t *curptr, *typestart;
 143   struct grub_efiemu_memrequest *cur;
 144   grub_size_t total_alloc = 0;
 145   unsigned i;
 146   /* Order of memory regions */
 147   grub_efi_memory_type_t reqorder[] =
 148     {
 149       /* First come regions usable by OS*/
 150       GRUB_EFI_LOADER_CODE,
 151       GRUB_EFI_LOADER_DATA,
 152       GRUB_EFI_BOOT_SERVICES_CODE,
 153       GRUB_EFI_BOOT_SERVICES_DATA,
 154       GRUB_EFI_CONVENTIONAL_MEMORY,
 155       GRUB_EFI_ACPI_RECLAIM_MEMORY,
 156
 157       /* Then memory used by runtime */
 158       /* This way all our regions are in a single block */
 159       GRUB_EFI_RUNTIME_SERVICES_CODE,
 160       GRUB_EFI_RUNTIME_SERVICES_DATA,
 161       GRUB_EFI_ACPI_MEMORY_NVS,
 162
 163       /* And then unavailable memory types. This is more for a completeness.
 164          You should double think before allocating memory of any of these types
 165        */
 166       GRUB_EFI_UNUSABLE_MEMORY,
 167       GRUB_EFI_MEMORY_MAPPED_IO,
 168       GRUB_EFI_MEMORY_MAPPED_IO_PORT_SPACE,
 169       GRUB_EFI_PAL_CODE
 170
 171       /*
 172        * These are not allocatable:
 173        * GRUB_EFI_RESERVED_MEMORY_TYPE
 174        * GRUB_EFI_PERSISTENT_MEMORY
 175        * >= GRUB_EFI_MAX_MEMORY_TYPE
 176        */
 177     };
 178
 179   /* Compute total memory needed */
 180   for (i = 0; i < sizeof (reqorder) / sizeof (reqorder[0]); i++)
 181     {
 182       align_overhead = GRUB_EFIEMU_PAGESIZE
 183         - (requested_memory[reqorder[i]] % GRUB_EFIEMU_PAGESIZE);
 184       if (align_overhead == GRUB_EFIEMU_PAGESIZE)
 185         align_overhead = 0;
 186       total_alloc += requested_memory[reqorder[i]] + align_overhead;
 187     }
 188
 189   /* Allocate the whole memory in one block */
 190   resident_memory = grub_memalign (GRUB_EFIEMU_PAGESIZE, total_alloc);
 191   if (!resident_memory)
 192     return grub_errno;
 193
 194   /* Split the memory into blocks by type */
 195   curptr = resident_memory;
 196   for (i = 0; i < sizeof (reqorder) / sizeof (reqorder[0]); i++)
 197     {
 198       if (!requested_memory[reqorder[i]])
 199         continue;
 200       typestart = curptr;
 201
 202       /* Write pointers to requests */
 203       for (cur = memrequests; cur; cur = cur->next)
 204         if (cur->type == reqorder[i])
 205           {
 206             curptr = ((grub_uint8_t *)curptr) + cur->align_overhead;
 207             cur->val = curptr;
 208             curptr = ((grub_uint8_t *)curptr) + cur->size;
 209           }
 210
 211       /* Ensure that the regions are page-aligned */
 212       align_overhead = GRUB_EFIEMU_PAGESIZE
 213         - (requested_memory[reqorder[i]] % GRUB_EFIEMU_PAGESIZE);
 214       if (align_overhead == GRUB_EFIEMU_PAGESIZE)
 215         align_overhead = 0;
 216       curptr = ((grub_uint8_t *) curptr) + align_overhead;
 217
 218       /* Add the region to memory map */
 219       grub_efiemu_add_to_mmap ((grub_addr_t) typestart,
 220                                curptr - typestart, reqorder[i]);
 221     }
 222
 223   return GRUB_ERR_NONE;
 224 }
 225
 226 /* Get a pointer to requested memory from handle */
 227 void *
 228 grub_efiemu_mm_obtain_request (int handle)
 229 {
 230   struct grub_efiemu_memrequest *cur;
 231   for (cur = memrequests; cur; cur = cur->next)
 232     if (cur->handle == handle)
 233       return cur->val;
 234   return 0;
 235 }
 236
 237 /* Get type of requested memory by handle */
 238 grub_efi_memory_type_t
 239 grub_efiemu_mm_get_type (int handle)
 240 {
 241   struct grub_efiemu_memrequest *cur;
 242   for (cur = memrequests; cur; cur = cur->next)
 243     if (cur->handle == handle)
 244       return cur->type;
 245   return 0;
 246 }
 247
 248 /* Free a request */
 249 void
 250 grub_efiemu_mm_return_request (int handle)
 251 {
 252   struct grub_efiemu_memrequest *cur, *prev;
 253
 254   /* Remove head if necessary */
 255   while (memrequests && memrequests->handle == handle)
 256     {
 257       cur = memrequests->next;
 258       grub_free (memrequests);
 259       memrequests = cur;
 260     }
 261   if (!memrequests)
 262     return;
 263
 264   /* Remove request from a middle of chain*/
 265   for (prev = memrequests, cur = prev->next; cur;)
 266     if (cur->handle == handle)
 267       {
 268         prev->next = cur->next;
 269         grub_free (cur);
 270         cur = prev->next;
 271       }
 272     else
 273       {
 274         prev = cur;
 275         cur = prev->next;
 276       }
 277 }
 278
 279 /* Helper for grub_efiemu_mmap_init.  */
 280 static int
 281 bounds_hook (grub_uint64_t addr __attribute__ ((unused)),
 282              grub_uint64_t size __attribute__ ((unused)),
 283              grub_memory_type_t type __attribute__ ((unused)),
 284              void *data __attribute__ ((unused)))
 285 {
 286   mmap_reserved_size++;
 287   return 0;
 288 }
 289
 290 /* Reserve space for memory map */
 291 static grub_err_t
 292 grub_efiemu_mmap_init (void)
 293 {
 294   // the place for memory used by efiemu itself
 295   mmap_reserved_size = GRUB_EFI_MAX_MEMORY_TYPE + 1;
 296
 297 #ifndef GRUB_MACHINE_EMU
 298   grub_machine_mmap_iterate (bounds_hook, NULL);
 299 #endif
 300
 301   return GRUB_ERR_NONE;
 302 }
 303
 304 /* This is a drop-in replacement of grub_efi_get_memory_map */
 305 /* Get the memory map as defined in the EFI spec. Return 1 if successful,
 306    return 0 if partial, or return -1 if an error occurs.  */
 307 int
 308 grub_efiemu_get_memory_map (grub_efi_uintn_t *memory_map_size,
 309                             grub_efi_memory_descriptor_t *memory_map,
 310                             grub_efi_uintn_t *map_key,
 311                             grub_efi_uintn_t *descriptor_size,
 312                             grub_efi_uint32_t *descriptor_version)
 313 {
 314   if (!efiemu_mmap)
 315     {
 316       grub_error (GRUB_ERR_INVALID_COMMAND,
 317                   "you need to first launch efiemu_prepare");
 318       return -1;
 319     }
 320
 321   if (*memory_map_size < mmap_num * sizeof (grub_efi_memory_descriptor_t))
 322     {
 323       *memory_map_size = mmap_num * sizeof (grub_efi_memory_descriptor_t);
 324       return 0;
 325     }
 326
 327   *memory_map_size = mmap_num * sizeof (grub_efi_memory_descriptor_t);
 328   grub_memcpy (memory_map, efiemu_mmap, *memory_map_size);
 329   if (descriptor_size)
 330     *descriptor_size = sizeof (grub_efi_memory_descriptor_t);
 331   if (descriptor_version)
 332     *descriptor_version = 1;
 333   if (map_key)
 334     *map_key = 0;
 335
 336   return 1;
 337 }
 338
 339 grub_err_t
 340 grub_efiemu_finish_boot_services (grub_efi_uintn_t *memory_map_size,
 341                                   grub_efi_memory_descriptor_t *memory_map,
 342                                   grub_efi_uintn_t *map_key,
 343                                   grub_efi_uintn_t *descriptor_size,
 344                                   grub_efi_uint32_t *descriptor_version)
 345 {
 346   int val = grub_efiemu_get_memory_map (memory_map_size,
 347                                         memory_map, map_key,
 348                                         descriptor_size,
 349                                         descriptor_version);
 350   if (val == 1)
 351     return GRUB_ERR_NONE;
 352   if (val == -1)
 353     return grub_errno;
 354   return grub_error (GRUB_ERR_IO, "memory map buffer is too small");
 355 }
 356
 357
 358 /* Free everything */
 359 grub_err_t
 360 grub_efiemu_mm_unload (void)
 361 {
 362   struct grub_efiemu_memrequest *cur, *d;
 363   for (cur = memrequests; cur;)
 364     {
 365       d = cur->next;
 366       grub_free (cur);
 367       cur = d;
 368     }
 369   memrequests = 0;
 370   grub_memset (&requested_memory, 0, sizeof (requested_memory));
 371   grub_free (resident_memory);
 372   resident_memory = 0;
 373   grub_free (efiemu_mmap);
 374   efiemu_mmap = 0;
 375   mmap_reserved_size = mmap_num = 0;
 376   return GRUB_ERR_NONE;
 377 }
 378
 379 /* This function should be called before doing any requests */
 380 grub_err_t
 381 grub_efiemu_mm_init (void)
 382 {
 383   grub_err_t err;
 384
 385   err = grub_efiemu_mm_unload ();
 386   if (err)
 387     return err;
 388
 389   grub_efiemu_mmap_init ();
 390
 391   return GRUB_ERR_NONE;
 392 }
 393
 394 /* Helper for grub_efiemu_mmap_fill.  */
 395 static int
 396 fill_hook (grub_uint64_t addr, grub_uint64_t size, grub_memory_type_t type,
 397            void *data __attribute__ ((unused)))
 398   {
 399     switch (type)
 400       {
 401       case GRUB_MEMORY_AVAILABLE:
 402         return grub_efiemu_add_to_mmap (addr, size,
 403                                         GRUB_EFI_CONVENTIONAL_MEMORY);
 404
 405       case GRUB_MEMORY_ACPI:
 406         return grub_efiemu_add_to_mmap (addr, size,
 407                                         GRUB_EFI_ACPI_RECLAIM_MEMORY);
 408
 409       case GRUB_MEMORY_NVS:
 410         return grub_efiemu_add_to_mmap (addr, size,
 411                                         GRUB_EFI_ACPI_MEMORY_NVS);
 412
 413       case GRUB_MEMORY_PERSISTENT:
 414       case GRUB_MEMORY_PERSISTENT_LEGACY:
 415         return grub_efiemu_add_to_mmap (addr, size,
 416                                         GRUB_EFI_PERSISTENT_MEMORY);
 417       default:
 418         grub_dprintf ("efiemu",
 419                       "Unknown memory type %d. Assuming unusable\n", type);
 420         /* FALLTHROUGH */
 421       case GRUB_MEMORY_RESERVED:
 422         return grub_efiemu_add_to_mmap (addr, size,
 423                                         GRUB_EFI_UNUSABLE_MEMORY);
 424       }
 425   }
 426
 427 /* Copy host memory map */
 428 static grub_err_t
 429 grub_efiemu_mmap_fill (void)
 430 {
 431 #ifndef GRUB_MACHINE_EMU
 432   grub_machine_mmap_iterate (fill_hook, NULL);
 433 #endif
 434
 435   return GRUB_ERR_NONE;
 436 }
 437
 438 grub_err_t
 439 grub_efiemu_mmap_iterate (grub_memory_hook_t hook, void *hook_data)
 440 {
 441   unsigned i;
 442
 443   for (i = 0; i < (unsigned) mmap_num; i++)
 444     switch (efiemu_mmap[i].type)
 445       {
 446       case GRUB_EFI_RUNTIME_SERVICES_CODE:
 447         hook (efiemu_mmap[i].physical_start, efiemu_mmap[i].num_pages * 4096,
 448               GRUB_MEMORY_CODE, hook_data);
 449         break;
 450
 451       case GRUB_EFI_UNUSABLE_MEMORY:
 452         hook (efiemu_mmap[i].physical_start, efiemu_mmap[i].num_pages * 4096,
 453               GRUB_MEMORY_BADRAM, hook_data);
 454         break;
 455
 456       case GRUB_EFI_RESERVED_MEMORY_TYPE:
 457       case GRUB_EFI_RUNTIME_SERVICES_DATA:
 458       case GRUB_EFI_MEMORY_MAPPED_IO:
 459       case GRUB_EFI_MEMORY_MAPPED_IO_PORT_SPACE:
 460       case GRUB_EFI_PAL_CODE:
 461       default:
 462         hook (efiemu_mmap[i].physical_start, efiemu_mmap[i].num_pages * 4096,
 463               GRUB_MEMORY_RESERVED, hook_data);
 464         break;
 465
 466       case GRUB_EFI_LOADER_CODE:
 467       case GRUB_EFI_LOADER_DATA:
 468       case GRUB_EFI_BOOT_SERVICES_CODE:
 469       case GRUB_EFI_BOOT_SERVICES_DATA:
 470       case GRUB_EFI_CONVENTIONAL_MEMORY:
 471         hook (efiemu_mmap[i].physical_start, efiemu_mmap[i].num_pages * 4096,
 472               GRUB_MEMORY_AVAILABLE, hook_data);
 473         break;
 474
 475       case GRUB_EFI_ACPI_RECLAIM_MEMORY:
 476         hook (efiemu_mmap[i].physical_start, efiemu_mmap[i].num_pages * 4096,
 477               GRUB_MEMORY_ACPI, hook_data);
 478         break;
 479
 480       case GRUB_EFI_ACPI_MEMORY_NVS:
 481         hook (efiemu_mmap[i].physical_start, efiemu_mmap[i].num_pages * 4096,
 482               GRUB_MEMORY_NVS, hook_data);
 483         break;
 484
 485       case GRUB_EFI_PERSISTENT_MEMORY:
 486         hook (efiemu_mmap[i].physical_start, efiemu_mmap[i].num_pages * 4096,
 487               GRUB_MEMORY_PERSISTENT, hook_data);
 488         break;
 489
 490       }
 491
 492   return 0;
 493 }
 494
 495
 496 /* This function resolves overlapping regions and sorts the memory map
 497    It uses scanline (sweeping) algorithm
 498  */
 499 static grub_err_t
 500 grub_efiemu_mmap_sort_and_uniq (void)
 501 {
 502   /* If same page is used by multiple types it's resolved
 503      according to priority
 504      0 - free memory
 505      1 - memory immediately usable after ExitBootServices
 506      2 - memory usable after loading ACPI tables
 507      3 - efiemu memory
 508      4 - unusable memory
 509   */
 510   int priority[GRUB_EFI_MAX_MEMORY_TYPE] =
 511     {
 512       [GRUB_EFI_RESERVED_MEMORY_TYPE] = 4,
 513       [GRUB_EFI_LOADER_CODE] = 1,
 514       [GRUB_EFI_LOADER_DATA] = 1,
 515       [GRUB_EFI_BOOT_SERVICES_CODE] = 1,
 516       [GRUB_EFI_BOOT_SERVICES_DATA] = 1,
 517       [GRUB_EFI_RUNTIME_SERVICES_CODE] = 3,
 518       [GRUB_EFI_RUNTIME_SERVICES_DATA] = 3,
 519       [GRUB_EFI_CONVENTIONAL_MEMORY] = 0,
 520       [GRUB_EFI_UNUSABLE_MEMORY] = 4,
 521       [GRUB_EFI_ACPI_RECLAIM_MEMORY] = 2,
 522       [GRUB_EFI_ACPI_MEMORY_NVS] = 3,
 523       [GRUB_EFI_MEMORY_MAPPED_IO] = 4,
 524       [GRUB_EFI_MEMORY_MAPPED_IO_PORT_SPACE] = 4,
 525       [GRUB_EFI_PAL_CODE] = 4,
 526       [GRUB_EFI_PERSISTENT_MEMORY] = 4
 527     };
 528
 529   int i, j, k, done;
 530
 531   /* Scanline events */
 532   struct grub_efiemu_mmap_scan
 533   {
 534     /* At which memory address*/
 535     grub_uint64_t pos;
 536     /* 0 = region starts, 1 = region ends */
 537     int type;
 538     /* Which type of memory region */
 539     grub_efi_memory_type_t memtype;
 540   };
 541   struct grub_efiemu_mmap_scan *scanline_events;
 542   struct grub_efiemu_mmap_scan t;
 543
 544   /* Previous scanline event */
 545   grub_uint64_t lastaddr;
 546   int lasttype;
 547   /* Current scanline event */
 548   int curtype;
 549   /* how many regions of given type overlap at current location */
 550   int present[GRUB_EFI_MAX_MEMORY_TYPE];
 551   /* Here is stored the resulting memory map*/
 552   grub_efi_memory_descriptor_t *result;
 553
 554   /* Initialize variables*/
 555   grub_memset (present, 0, sizeof (int) * GRUB_EFI_MAX_MEMORY_TYPE);
 556   scanline_events = (struct grub_efiemu_mmap_scan *)
 557     grub_malloc (sizeof (struct grub_efiemu_mmap_scan) * 2 * mmap_num);
 558
 559   /* Number of chunks can't increase more than by factor of 2 */
 560   result = (grub_efi_memory_descriptor_t *)
 561     grub_malloc (sizeof (grub_efi_memory_descriptor_t) * 2 * mmap_num);
 562   if (!result || !scanline_events)
 563     {
 564       grub_free (result);
 565       grub_free (scanline_events);
 566       return grub_errno;
 567     }
 568
 569   /* Register scanline events */
 570   for (i = 0; i < mmap_num; i++)
 571     {
 572       scanline_events[2 * i].pos = efiemu_mmap[i].physical_start;
 573       scanline_events[2 * i].type = 0;
 574       scanline_events[2 * i].memtype = efiemu_mmap[i].type;
 575       scanline_events[2 * i + 1].pos = efiemu_mmap[i].physical_start
 576         + efiemu_mmap[i].num_pages * GRUB_EFIEMU_PAGESIZE;
 577       scanline_events[2 * i + 1].type = 1;
 578       scanline_events[2 * i + 1].memtype = efiemu_mmap[i].type;
 579     }
 580
 581   /* Primitive bubble sort. It has complexity O(n^2) but since we're
 582      unlikely to have more than 100 chunks it's probably one of the
 583      fastest for one purpose */
 584   done = 1;
 585   while (done)
 586     {
 587       done = 0;
 588       for (i = 0; i < 2 * mmap_num - 1; i++)
 589         if (scanline_events[i + 1].pos < scanline_events[i].pos)
 590           {
 591             t = scanline_events[i + 1];
 592             scanline_events[i + 1] = scanline_events[i];
 593             scanline_events[i] = t;
 594             done = 1;
 595           }
 596     }
 597
 598   /* Pointer in resulting memory map */
 599   j = 0;
 600   lastaddr = scanline_events[0].pos;
 601   lasttype = scanline_events[0].memtype;
 602   for (i = 0; i < 2 * mmap_num; i++)
 603     {
 604       /* Process event */
 605       if (scanline_events[i].type)
 606         present[scanline_events[i].memtype]--;
 607       else
 608         present[scanline_events[i].memtype]++;
 609
 610       /* Determine current region type */
 611       curtype = -1;
 612       for (k = 0; k < GRUB_EFI_MAX_MEMORY_TYPE; k++)
 613         if (present[k] && (curtype == -1 || priority[k] > priority[curtype]))
 614           curtype = k;
 615
 616       /* Add memory region to resulting map if necessary */
 617       if ((curtype == -1 || curtype != lasttype)
 618           && lastaddr != scanline_events[i].pos
 619           && lasttype != -1)
 620         {
 621           result[j].virtual_start = result[j].physical_start = lastaddr;
 622           result[j].num_pages = (scanline_events[i].pos - lastaddr)
 623             / GRUB_EFIEMU_PAGESIZE;
 624           result[j].type = lasttype;
 625
 626           /* We set runtime attribute on pages we need to be mapped */
 627           result[j].attribute
 628             = (lasttype == GRUB_EFI_RUNTIME_SERVICES_CODE
 629                    || lasttype == GRUB_EFI_RUNTIME_SERVICES_DATA)
 630             ? GRUB_EFI_MEMORY_RUNTIME : 0;
 631           grub_dprintf ("efiemu",
 632                         "mmap entry: type %d start 0x%llx 0x%llx pages\n",
 633                         result[j].type,
 634                         result[j].physical_start, result[j].num_pages);
 635           j++;
 636         }
 637
 638       /* Update last values if necessary */
 639       if (curtype == -1 || curtype != lasttype)
 640         {
 641           lasttype = curtype;
 642           lastaddr = scanline_events[i].pos;
 643         }
 644     }
 645
 646   grub_free (scanline_events);
 647
 648   /* Shrink resulting memory map to really used size and replace efiemu_mmap
 649      by new value */
 650   grub_free (efiemu_mmap);
 651   efiemu_mmap = grub_realloc (result, j * sizeof (*result));
 652   return GRUB_ERR_NONE;
 653 }
 654
 655 /* This function is called to switch from first to second phase */
 656 grub_err_t
 657 grub_efiemu_mm_do_alloc (void)
 658 {
 659   grub_err_t err;
 660
 661   /* Preallocate mmap */
 662   efiemu_mmap = (grub_efi_memory_descriptor_t *)
 663     grub_malloc (mmap_reserved_size * sizeof (grub_efi_memory_descriptor_t));
 664   if (!efiemu_mmap)
 665     {
 666       grub_efiemu_unload ();
 667       return grub_errno;
 668     }
 669
 670   err = efiemu_alloc_requests ();
 671   if (err)
 672     return err;
 673   err = grub_efiemu_mmap_fill ();
 674   if (err)
 675     return err;
 676   return grub_efiemu_mmap_sort_and_uniq ();
 677 }