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