grub-core/kern/efi/mm.c

   1 /* mm.c - generic EFI memory management */
   2 /*
   3  *  GRUB  --  GRand Unified Bootloader
   4  *  Copyright (C) 2006,2007,2008,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 #include <grub/misc.h>
  21 #include <grub/mm.h>
  22 #include <grub/efi/api.h>
  23 #include <grub/efi/efi.h>
  24 #include <grub/cpu/efi/memory.h>
  25
  26 #if defined (__i386__) || defined (__x86_64__)
  27 #include <grub/pci.h>
  28 #endif
  29
  30 #define NEXT_MEMORY_DESCRIPTOR(desc, size)      \
  31   ((grub_efi_memory_descriptor_t *) ((char *) (desc) + (size)))
  32
  33 #define BYTES_TO_PAGES(bytes)   (((bytes) + 0xfff) >> 12)
  34 #define BYTES_TO_PAGES_DOWN(bytes)      ((bytes) >> 12)
  35 #define PAGES_TO_BYTES(pages)   ((pages) << 12)
  36
  37 /* The size of a memory map obtained from the firmware. This must be
  38    a multiplier of 4KB.  */
  39 #define MEMORY_MAP_SIZE 0x3000
  40
  41 /* The minimum and maximum heap size for GRUB itself.  */
  42 #define MIN_HEAP_SIZE   0x100000
  43 #define MAX_HEAP_SIZE   (1600 * 0x100000)
  44
  45 static void *finish_mmap_buf = 0;
  46 static grub_efi_uintn_t finish_mmap_size = 0;
  47 static grub_efi_uintn_t finish_key = 0;
  48 static grub_efi_uintn_t finish_desc_size;
  49 static grub_efi_uint32_t finish_desc_version;
  50 int grub_efi_is_finished = 0;
  51
  52 /*
  53  * We need to roll back EFI allocations on exit. Remember allocations that
  54  * we'll free on exit.
  55  */
  56 struct efi_allocation;
  57 struct efi_allocation {
  58         grub_efi_physical_address_t address;
  59         grub_efi_uint64_t pages;
  60         struct efi_allocation *next;
  61 };
  62 static struct efi_allocation *efi_allocated_memory;
  63
  64 static void
  65 grub_efi_store_alloc (grub_efi_physical_address_t address,
  66                          grub_efi_uintn_t pages)
  67 {
  68   grub_efi_boot_services_t *b;
  69   struct efi_allocation *alloc;
  70   grub_efi_status_t status;
  71
  72   b = grub_efi_system_table->boot_services;
  73   status = efi_call_3 (b->allocate_pool, GRUB_EFI_LOADER_DATA,
  74                            sizeof(*alloc), (void**)&alloc);
  75
  76   if (status == GRUB_EFI_SUCCESS)
  77     {
  78       alloc->next = efi_allocated_memory;
  79       alloc->address = address;
  80       alloc->pages = pages;
  81       efi_allocated_memory = alloc;
  82     }
  83   else
  84       grub_printf ("Could not malloc memory to remember EFI allocation. "
  85                    "Exiting GRUB won't free all memory.\n");
  86 }
  87
  88 static void
  89 grub_efi_drop_alloc (grub_efi_physical_address_t address,
  90                            grub_efi_uintn_t pages)
  91 {
  92   struct efi_allocation *ea, *eap;
  93   grub_efi_boot_services_t *b;
  94
  95   b = grub_efi_system_table->boot_services;
  96
  97   for (eap = NULL, ea = efi_allocated_memory; ea; eap = ea, ea = ea->next)
  98     {
  99       if (ea->address != address || ea->pages != pages)
 100          continue;
 101
 102       /* Remove the current entry from the list. */
 103       if (eap)
 104         eap->next = ea->next;
 105       else
 106         efi_allocated_memory = ea->next;
 107
 108       /* Then free the memory backing it. */
 109       efi_call_1 (b->free_pool, ea);
 110
 111       /* And leave, we're done. */
 112       break;
 113     }
 114 }
 115
 116 /* Allocate pages. Return the pointer to the first of allocated pages.  */
 117 void *
 118 grub_efi_allocate_pages_real (grub_efi_physical_address_t address,
 119                               grub_efi_uintn_t pages,
 120                               grub_efi_allocate_type_t alloctype,
 121                               grub_efi_memory_type_t memtype)
 122 {
 123   grub_efi_status_t status;
 124   grub_efi_boot_services_t *b;
 125
 126   /* Limit the memory access to less than 4GB for 32-bit platforms.  */
 127   if (address > GRUB_EFI_MAX_USABLE_ADDRESS)
 128     return 0;
 129
 130   b = grub_efi_system_table->boot_services;
 131   status = efi_call_4 (b->allocate_pages, alloctype, memtype, pages, &address);
 132   if (status != GRUB_EFI_SUCCESS)
 133     return 0;
 134
 135   if (address == 0)
 136     {
 137       /* Uggh, the address 0 was allocated... This is too annoying,
 138          so reallocate another one.  */
 139       address = GRUB_EFI_MAX_USABLE_ADDRESS;
 140       status = efi_call_4 (b->allocate_pages, alloctype, memtype, pages, &address);
 141       grub_efi_free_pages (0, pages);
 142       if (status != GRUB_EFI_SUCCESS)
 143         return 0;
 144     }
 145
 146   grub_efi_store_alloc (address, pages);
 147
 148   return (void *) ((grub_addr_t) address);
 149 }
 150
 151 void *
 152 grub_efi_allocate_any_pages (grub_efi_uintn_t pages)
 153 {
 154   return grub_efi_allocate_pages_real (GRUB_EFI_MAX_USABLE_ADDRESS,
 155                                        pages, GRUB_EFI_ALLOCATE_MAX_ADDRESS,
 156                                        GRUB_EFI_LOADER_DATA);
 157 }
 158
 159 void *
 160 grub_efi_allocate_fixed (grub_efi_physical_address_t address,
 161                          grub_efi_uintn_t pages)
 162 {
 163   return grub_efi_allocate_pages_real (address, pages,
 164                                        GRUB_EFI_ALLOCATE_ADDRESS,
 165                                        GRUB_EFI_LOADER_DATA);
 166 }
 167
 168 /* Free pages starting from ADDRESS.  */
 169 void
 170 grub_efi_free_pages (grub_efi_physical_address_t address,
 171                      grub_efi_uintn_t pages)
 172 {
 173   grub_efi_boot_services_t *b;
 174
 175   b = grub_efi_system_table->boot_services;
 176   efi_call_2 (b->free_pages, address, pages);
 177
 178   grub_efi_drop_alloc (address, pages);
 179 }
 180
 181 #if defined (__i386__) || defined (__x86_64__)
 182
 183 /* Helper for stop_broadcom.  */
 184 static int
 185 find_card (grub_pci_device_t dev, grub_pci_id_t pciid,
 186            void *data __attribute__ ((unused)))
 187 {
 188   grub_pci_address_t addr;
 189   grub_uint8_t cap;
 190   grub_uint16_t pm_state;
 191
 192   if ((pciid & 0xffff) != GRUB_PCI_VENDOR_BROADCOM)
 193     return 0;
 194
 195   addr = grub_pci_make_address (dev, GRUB_PCI_REG_CLASS);
 196   if (grub_pci_read (addr) >> 24 != GRUB_PCI_CLASS_NETWORK)
 197     return 0;
 198   cap = grub_pci_find_capability (dev, GRUB_PCI_CAP_POWER_MANAGEMENT);
 199   if (!cap)
 200     return 0;
 201   addr = grub_pci_make_address (dev, cap + 4);
 202   pm_state = grub_pci_read_word (addr);
 203   pm_state = pm_state | 0x03;
 204   grub_pci_write_word (addr, pm_state);
 205   grub_pci_read_word (addr);
 206   return 0;
 207 }
 208
 209 static void
 210 stop_broadcom (void)
 211 {
 212   grub_pci_iterate (find_card, NULL);
 213 }
 214
 215 #endif
 216
 217 grub_err_t
 218 grub_efi_finish_boot_services (grub_efi_uintn_t *outbuf_size, void *outbuf,
 219                                grub_efi_uintn_t *map_key,
 220                                grub_efi_uintn_t *efi_desc_size,
 221                                grub_efi_uint32_t *efi_desc_version)
 222 {
 223   grub_efi_boot_services_t *b;
 224   grub_efi_status_t status;
 225
 226 #if defined (__i386__) || defined (__x86_64__)
 227   const grub_uint16_t apple[] = { 'A', 'p', 'p', 'l', 'e' };
 228   int is_apple;
 229
 230   is_apple = (grub_memcmp (grub_efi_system_table->firmware_vendor,
 231                            apple, sizeof (apple)) == 0);
 232 #endif
 233
 234   while (1)
 235     {
 236       if (grub_efi_get_memory_map (&finish_mmap_size, finish_mmap_buf, &finish_key,
 237                                    &finish_desc_size, &finish_desc_version) < 0)
 238         return grub_error (GRUB_ERR_IO, "couldn't retrieve memory map");
 239
 240       if (outbuf && *outbuf_size < finish_mmap_size)
 241         return grub_error (GRUB_ERR_IO, "memory map buffer is too small");
 242
 243       finish_mmap_buf = grub_malloc (finish_mmap_size);
 244       if (!finish_mmap_buf)
 245         return grub_errno;
 246
 247       if (grub_efi_get_memory_map (&finish_mmap_size, finish_mmap_buf, &finish_key,
 248                                    &finish_desc_size, &finish_desc_version) <= 0)
 249         {
 250           grub_free (finish_mmap_buf);
 251           return grub_error (GRUB_ERR_IO, "couldn't retrieve memory map");
 252         }
 253
 254       b = grub_efi_system_table->boot_services;
 255       status = efi_call_2 (b->exit_boot_services, grub_efi_image_handle,
 256                            finish_key);
 257       if (status == GRUB_EFI_SUCCESS)
 258         break;
 259
 260       if (status != GRUB_EFI_INVALID_PARAMETER)
 261         {
 262           grub_free (finish_mmap_buf);
 263           return grub_error (GRUB_ERR_IO, "couldn't terminate EFI services");
 264         }
 265
 266       grub_free (finish_mmap_buf);
 267       grub_printf ("Trying to terminate EFI services again\n");
 268     }
 269   grub_efi_is_finished = 1;
 270   if (outbuf_size)
 271     *outbuf_size = finish_mmap_size;
 272   if (outbuf)
 273     grub_memcpy (outbuf, finish_mmap_buf, finish_mmap_size);
 274   if (map_key)
 275     *map_key = finish_key;
 276   if (efi_desc_size)
 277     *efi_desc_size = finish_desc_size;
 278   if (efi_desc_version)
 279     *efi_desc_version = finish_desc_version;
 280
 281 #if defined (__i386__) || defined (__x86_64__)
 282   if (is_apple)
 283     stop_broadcom ();
 284 #endif
 285
 286   return GRUB_ERR_NONE;
 287 }
 288
 289 /* Get the memory map as defined in the EFI spec. Return 1 if successful,
 290    return 0 if partial, or return -1 if an error occurs.  */
 291 int
 292 grub_efi_get_memory_map (grub_efi_uintn_t *memory_map_size,
 293                          grub_efi_memory_descriptor_t *memory_map,
 294                          grub_efi_uintn_t *map_key,
 295                          grub_efi_uintn_t *descriptor_size,
 296                          grub_efi_uint32_t *descriptor_version)
 297 {
 298   grub_efi_status_t status;
 299   grub_efi_boot_services_t *b;
 300   grub_efi_uintn_t key;
 301   grub_efi_uint32_t version;
 302   grub_efi_uintn_t size;
 303
 304   if (grub_efi_is_finished)
 305     {
 306       int ret = 1;
 307       if (*memory_map_size < finish_mmap_size)
 308         {
 309           grub_memcpy (memory_map, finish_mmap_buf, *memory_map_size);
 310           ret = 0;
 311         }
 312       else
 313         {
 314           grub_memcpy (memory_map, finish_mmap_buf, finish_mmap_size);
 315           ret = 1;
 316         }
 317       *memory_map_size = finish_mmap_size;
 318       if (map_key)
 319         *map_key = finish_key;
 320       if (descriptor_size)
 321         *descriptor_size = finish_desc_size;
 322       if (descriptor_version)
 323         *descriptor_version = finish_desc_version;
 324       return ret;
 325     }
 326
 327   /* Allow some parameters to be missing.  */
 328   if (! map_key)
 329     map_key = &key;
 330   if (! descriptor_version)
 331     descriptor_version = &version;
 332   if (! descriptor_size)
 333     descriptor_size = &size;
 334
 335   b = grub_efi_system_table->boot_services;
 336   status = efi_call_5 (b->get_memory_map, memory_map_size, memory_map, map_key,
 337                               descriptor_size, descriptor_version);
 338   if (*descriptor_size == 0)
 339     *descriptor_size = sizeof (grub_efi_memory_descriptor_t);
 340   if (status == GRUB_EFI_SUCCESS)
 341     return 1;
 342   else if (status == GRUB_EFI_BUFFER_TOO_SMALL)
 343     return 0;
 344   else
 345     return -1;
 346 }
 347
 348 /* Sort the memory map in place.  */
 349 static void
 350 sort_memory_map (grub_efi_memory_descriptor_t *memory_map,
 351                  grub_efi_uintn_t desc_size,
 352                  grub_efi_memory_descriptor_t *memory_map_end)
 353 {
 354   grub_efi_memory_descriptor_t *d1;
 355   grub_efi_memory_descriptor_t *d2;
 356
 357   for (d1 = memory_map;
 358        d1 < memory_map_end;
 359        d1 = NEXT_MEMORY_DESCRIPTOR (d1, desc_size))
 360     {
 361       grub_efi_memory_descriptor_t *max_desc = d1;
 362
 363       for (d2 = NEXT_MEMORY_DESCRIPTOR (d1, desc_size);
 364            d2 < memory_map_end;
 365            d2 = NEXT_MEMORY_DESCRIPTOR (d2, desc_size))
 366         {
 367           if (max_desc->num_pages < d2->num_pages)
 368             max_desc = d2;
 369         }
 370
 371       if (max_desc != d1)
 372         {
 373           grub_efi_memory_descriptor_t tmp;
 374
 375           tmp = *d1;
 376           *d1 = *max_desc;
 377           *max_desc = tmp;
 378         }
 379     }
 380 }
 381
 382 /* Filter the descriptors. GRUB needs only available memory.  */
 383 static grub_efi_memory_descriptor_t *
 384 filter_memory_map (grub_efi_memory_descriptor_t *memory_map,
 385                    grub_efi_memory_descriptor_t *filtered_memory_map,
 386                    grub_efi_uintn_t desc_size,
 387                    grub_efi_memory_descriptor_t *memory_map_end)
 388 {
 389   grub_efi_memory_descriptor_t *desc;
 390   grub_efi_memory_descriptor_t *filtered_desc;
 391
 392   for (desc = memory_map, filtered_desc = filtered_memory_map;
 393        desc < memory_map_end;
 394        desc = NEXT_MEMORY_DESCRIPTOR (desc, desc_size))
 395     {
 396       if (desc->type == GRUB_EFI_CONVENTIONAL_MEMORY
 397 #if 1
 398           && desc->physical_start <= GRUB_EFI_MAX_USABLE_ADDRESS
 399 #endif
 400           && desc->physical_start + PAGES_TO_BYTES (desc->num_pages) > 0x100000
 401           && desc->num_pages != 0)
 402         {
 403           grub_memcpy (filtered_desc, desc, desc_size);
 404
 405           /* Avoid less than 1MB, because some loaders seem to be confused.  */
 406           if (desc->physical_start < 0x100000)
 407             {
 408               desc->num_pages -= BYTES_TO_PAGES (0x100000
 409                                                  - desc->physical_start);
 410               desc->physical_start = 0x100000;
 411             }
 412
 413 #if 1
 414           if (BYTES_TO_PAGES (filtered_desc->physical_start)
 415               + filtered_desc->num_pages
 416               > BYTES_TO_PAGES_DOWN (GRUB_EFI_MAX_USABLE_ADDRESS))
 417             filtered_desc->num_pages
 418               = (BYTES_TO_PAGES_DOWN (GRUB_EFI_MAX_USABLE_ADDRESS)
 419                  - BYTES_TO_PAGES (filtered_desc->physical_start));
 420 #endif
 421
 422           if (filtered_desc->num_pages == 0)
 423             continue;
 424
 425           filtered_desc = NEXT_MEMORY_DESCRIPTOR (filtered_desc, desc_size);
 426         }
 427     }
 428
 429   return filtered_desc;
 430 }
 431
 432 /* Return the total number of pages.  */
 433 static grub_efi_uint64_t
 434 get_total_pages (grub_efi_memory_descriptor_t *memory_map,
 435                  grub_efi_uintn_t desc_size,
 436                  grub_efi_memory_descriptor_t *memory_map_end)
 437 {
 438   grub_efi_memory_descriptor_t *desc;
 439   grub_efi_uint64_t total = 0;
 440
 441   for (desc = memory_map;
 442        desc < memory_map_end;
 443        desc = NEXT_MEMORY_DESCRIPTOR (desc, desc_size))
 444     total += desc->num_pages;
 445
 446   return total;
 447 }
 448
 449 /* Add memory regions.  */
 450 static void
 451 add_memory_regions (grub_efi_memory_descriptor_t *memory_map,
 452                     grub_efi_uintn_t desc_size,
 453                     grub_efi_memory_descriptor_t *memory_map_end,
 454                     grub_efi_uint64_t required_pages)
 455 {
 456   grub_efi_memory_descriptor_t *desc;
 457
 458   for (desc = memory_map;
 459        desc < memory_map_end;
 460        desc = NEXT_MEMORY_DESCRIPTOR (desc, desc_size))
 461     {
 462       grub_efi_uint64_t pages;
 463       grub_efi_physical_address_t start;
 464       void *addr;
 465
 466       start = desc->physical_start;
 467       pages = desc->num_pages;
 468       if (pages > required_pages)
 469         {
 470           start += PAGES_TO_BYTES (pages - required_pages);
 471           pages = required_pages;
 472         }
 473
 474       addr = grub_efi_allocate_pages_real (start, pages,
 475                                            GRUB_EFI_ALLOCATE_ADDRESS,
 476                                            GRUB_EFI_LOADER_CODE);
 477       if (! addr)
 478         grub_fatal ("cannot allocate conventional memory %p with %u pages",
 479                     (void *) ((grub_addr_t) start),
 480                     (unsigned) pages);
 481
 482       grub_mm_init_region (addr, PAGES_TO_BYTES (pages));
 483
 484       required_pages -= pages;
 485       if (required_pages == 0)
 486         break;
 487     }
 488
 489   if (required_pages > 0)
 490     grub_fatal ("too little memory");
 491 }
 492
 493 void
 494 grub_efi_memory_fini (void)
 495 {
 496   /*
 497    * Free all stale allocations. grub_efi_free_pages() will remove
 498    * the found entry from the list and it will always find the first
 499    * list entry (efi_allocated_memory is the list start). Hence we
 500    * remove all entries from the list until none is left altogether.
 501    */
 502   while (efi_allocated_memory)
 503       grub_efi_free_pages (efi_allocated_memory->address,
 504                            efi_allocated_memory->pages);
 505 }
 506
 507 #if 0
 508 /* Print the memory map.  */
 509 static void
 510 print_memory_map (grub_efi_memory_descriptor_t *memory_map,
 511                   grub_efi_uintn_t desc_size,
 512                   grub_efi_memory_descriptor_t *memory_map_end)
 513 {
 514   grub_efi_memory_descriptor_t *desc;
 515   int i;
 516
 517   for (desc = memory_map, i = 0;
 518        desc < memory_map_end;
 519        desc = NEXT_MEMORY_DESCRIPTOR (desc, desc_size), i++)
 520     {
 521       grub_printf ("MD: t=%x, p=%llx, v=%llx, n=%llx, a=%llx\n",
 522                    desc->type, desc->physical_start, desc->virtual_start,
 523                    desc->num_pages, desc->attribute);
 524     }
 525 }
 526 #endif
 527
 528 void
 529 grub_efi_mm_init (void)
 530 {
 531   grub_efi_memory_descriptor_t *memory_map;
 532   grub_efi_memory_descriptor_t *memory_map_end;
 533   grub_efi_memory_descriptor_t *filtered_memory_map;
 534   grub_efi_memory_descriptor_t *filtered_memory_map_end;
 535   grub_efi_uintn_t map_size;
 536   grub_efi_uintn_t desc_size;
 537   grub_efi_uint64_t total_pages;
 538   grub_efi_uint64_t required_pages;
 539   int mm_status;
 540
 541   /* Prepare a memory region to store two memory maps.  */
 542   memory_map = grub_efi_allocate_any_pages (2 * BYTES_TO_PAGES (MEMORY_MAP_SIZE));
 543   if (! memory_map)
 544     grub_fatal ("cannot allocate memory");
 545
 546   /* Obtain descriptors for available memory.  */
 547   map_size = MEMORY_MAP_SIZE;
 548
 549   mm_status = grub_efi_get_memory_map (&map_size, memory_map, 0, &desc_size, 0);
 550
 551   if (mm_status == 0)
 552     {
 553       grub_efi_free_pages
 554         ((grub_efi_physical_address_t) ((grub_addr_t) memory_map),
 555          2 * BYTES_TO_PAGES (MEMORY_MAP_SIZE));
 556
 557       /* Freeing/allocating operations may increase memory map size.  */
 558       map_size += desc_size * 32;
 559
 560       memory_map = grub_efi_allocate_any_pages (2 * BYTES_TO_PAGES (map_size));
 561       if (! memory_map)
 562         grub_fatal ("cannot allocate memory");
 563
 564       mm_status = grub_efi_get_memory_map (&map_size, memory_map, 0,
 565                                            &desc_size, 0);
 566     }
 567
 568   if (mm_status < 0)
 569     grub_fatal ("cannot get memory map");
 570
 571   memory_map_end = NEXT_MEMORY_DESCRIPTOR (memory_map, map_size);
 572
 573   filtered_memory_map = memory_map_end;
 574
 575   filtered_memory_map_end = filter_memory_map (memory_map, filtered_memory_map,
 576                                                desc_size, memory_map_end);
 577
 578   /* By default, request a quarter of the available memory.  */
 579   total_pages = get_total_pages (filtered_memory_map, desc_size,
 580                                  filtered_memory_map_end);
 581   required_pages = (total_pages >> 2);
 582   if (required_pages < BYTES_TO_PAGES (MIN_HEAP_SIZE))
 583     required_pages = BYTES_TO_PAGES (MIN_HEAP_SIZE);
 584   else if (required_pages > BYTES_TO_PAGES (MAX_HEAP_SIZE))
 585     required_pages = BYTES_TO_PAGES (MAX_HEAP_SIZE);
 586
 587   /* Sort the filtered descriptors, so that GRUB can allocate pages
 588      from smaller regions.  */
 589   sort_memory_map (filtered_memory_map, desc_size, filtered_memory_map_end);
 590
 591   /* Allocate memory regions for GRUB's memory management.  */
 592   add_memory_regions (filtered_memory_map, desc_size,
 593                       filtered_memory_map_end, required_pages);
 594
 595 #if 0
 596   /* For debug.  */
 597   map_size = MEMORY_MAP_SIZE;
 598
 599   if (grub_efi_get_memory_map (&map_size, memory_map, 0, &desc_size, 0) < 0)
 600     grub_fatal ("cannot get memory map");
 601
 602   grub_printf ("printing memory map\n");
 603   print_memory_map (memory_map, desc_size,
 604                     NEXT_MEMORY_DESCRIPTOR (memory_map, map_size));
 605   grub_fatal ("Debug. ");
 606 #endif
 607
 608   /* Release the memory maps.  */
 609   grub_efi_free_pages ((grub_addr_t) memory_map,
 610                        2 * BYTES_TO_PAGES (MEMORY_MAP_SIZE));
 611 }