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 /* Allocate pages. Return the pointer to the first of allocated pages.  */
  53 void *
  54 grub_efi_allocate_pages_real (grub_efi_physical_address_t address,
  55                               grub_efi_uintn_t pages,
  56                               grub_efi_allocate_type_t alloctype,
  57                               grub_efi_memory_type_t memtype)
  58 {
  59   grub_efi_status_t status;
  60   grub_efi_boot_services_t *b;
  61
  62   /* Limit the memory access to less than 4GB for 32-bit platforms.  */
  63   if (address > GRUB_EFI_MAX_USABLE_ADDRESS)
  64     return 0;
  65
  66   b = grub_efi_system_table->boot_services;
  67   status = efi_call_4 (b->allocate_pages, alloctype, memtype, pages, &address);
  68   if (status != GRUB_EFI_SUCCESS)
  69     return 0;
  70
  71   if (address == 0)
  72     {
  73       /* Uggh, the address 0 was allocated... This is too annoying,
  74          so reallocate another one.  */
  75       address = GRUB_EFI_MAX_USABLE_ADDRESS;
  76       status = efi_call_4 (b->allocate_pages, alloctype, memtype, pages, &address);
  77       grub_efi_free_pages (0, pages);
  78       if (status != GRUB_EFI_SUCCESS)
  79         return 0;
  80     }
  81
  82   return (void *) ((grub_addr_t) address);
  83 }
  84
  85 void *
  86 grub_efi_allocate_any_pages (grub_efi_uintn_t pages)
  87 {
  88   return grub_efi_allocate_pages_real (GRUB_EFI_MAX_USABLE_ADDRESS,
  89                                        pages, GRUB_EFI_ALLOCATE_MAX_ADDRESS,
  90                                        GRUB_EFI_LOADER_DATA);
  91 }
  92
  93 void *
  94 grub_efi_allocate_fixed (grub_efi_physical_address_t address,
  95                          grub_efi_uintn_t pages)
  96 {
  97   return grub_efi_allocate_pages_real (address, pages,
  98                                        GRUB_EFI_ALLOCATE_ADDRESS,
  99                                        GRUB_EFI_LOADER_DATA);
 100 }
 101
 102 /* Free pages starting from ADDRESS.  */
 103 void
 104 grub_efi_free_pages (grub_efi_physical_address_t address,
 105                      grub_efi_uintn_t pages)
 106 {
 107   grub_efi_boot_services_t *b;
 108
 109   b = grub_efi_system_table->boot_services;
 110   efi_call_2 (b->free_pages, address, pages);
 111 }
 112
 113 #if defined (__i386__) || defined (__x86_64__)
 114
 115 /* Helper for stop_broadcom.  */
 116 static int
 117 find_card (grub_pci_device_t dev, grub_pci_id_t pciid,
 118            void *data __attribute__ ((unused)))
 119 {
 120   grub_pci_address_t addr;
 121   grub_uint8_t cap;
 122   grub_uint16_t pm_state;
 123
 124   if ((pciid & 0xffff) != GRUB_PCI_VENDOR_BROADCOM)
 125     return 0;
 126
 127   addr = grub_pci_make_address (dev, GRUB_PCI_REG_CLASS);
 128   if (grub_pci_read (addr) >> 24 != GRUB_PCI_CLASS_NETWORK)
 129     return 0;
 130   cap = grub_pci_find_capability (dev, GRUB_PCI_CAP_POWER_MANAGEMENT);
 131   if (!cap)
 132     return 0;
 133   addr = grub_pci_make_address (dev, cap + 4);
 134   pm_state = grub_pci_read_word (addr);
 135   pm_state = pm_state | 0x03;
 136   grub_pci_write_word (addr, pm_state);
 137   grub_pci_read_word (addr);
 138   return 0;
 139 }
 140
 141 static void
 142 stop_broadcom (void)
 143 {
 144   grub_pci_iterate (find_card, NULL);
 145 }
 146
 147 #endif
 148
 149 grub_err_t
 150 grub_efi_finish_boot_services (grub_efi_uintn_t *outbuf_size, void *outbuf,
 151                                grub_efi_uintn_t *map_key,
 152                                grub_efi_uintn_t *efi_desc_size,
 153                                grub_efi_uint32_t *efi_desc_version)
 154 {
 155   grub_efi_boot_services_t *b;
 156   grub_efi_status_t status;
 157
 158 #if defined (__i386__) || defined (__x86_64__)
 159   const grub_uint16_t apple[] = { 'A', 'p', 'p', 'l', 'e' };
 160   int is_apple;
 161
 162   is_apple = (grub_memcmp (grub_efi_system_table->firmware_vendor,
 163                            apple, sizeof (apple)) == 0);
 164 #endif
 165
 166   while (1)
 167     {
 168       if (grub_efi_get_memory_map (&finish_mmap_size, finish_mmap_buf, &finish_key,
 169                                    &finish_desc_size, &finish_desc_version) < 0)
 170         return grub_error (GRUB_ERR_IO, "couldn't retrieve memory map");
 171
 172       if (outbuf && *outbuf_size < finish_mmap_size)
 173         return grub_error (GRUB_ERR_IO, "memory map buffer is too small");
 174
 175       finish_mmap_buf = grub_malloc (finish_mmap_size);
 176       if (!finish_mmap_buf)
 177         return grub_errno;
 178
 179       if (grub_efi_get_memory_map (&finish_mmap_size, finish_mmap_buf, &finish_key,
 180                                    &finish_desc_size, &finish_desc_version) <= 0)
 181         {
 182           grub_free (finish_mmap_buf);
 183           return grub_error (GRUB_ERR_IO, "couldn't retrieve memory map");
 184         }
 185
 186       b = grub_efi_system_table->boot_services;
 187       status = efi_call_2 (b->exit_boot_services, grub_efi_image_handle,
 188                            finish_key);
 189       if (status == GRUB_EFI_SUCCESS)
 190         break;
 191
 192       if (status != GRUB_EFI_INVALID_PARAMETER)
 193         {
 194           grub_free (finish_mmap_buf);
 195           return grub_error (GRUB_ERR_IO, "couldn't terminate EFI services");
 196         }
 197
 198       grub_free (finish_mmap_buf);
 199       grub_printf ("Trying to terminate EFI services again\n");
 200     }
 201   grub_efi_is_finished = 1;
 202   if (outbuf_size)
 203     *outbuf_size = finish_mmap_size;
 204   if (outbuf)
 205     grub_memcpy (outbuf, finish_mmap_buf, finish_mmap_size);
 206   if (map_key)
 207     *map_key = finish_key;
 208   if (efi_desc_size)
 209     *efi_desc_size = finish_desc_size;
 210   if (efi_desc_version)
 211     *efi_desc_version = finish_desc_version;
 212
 213 #if defined (__i386__) || defined (__x86_64__)
 214   if (is_apple)
 215     stop_broadcom ();
 216 #endif
 217
 218   return GRUB_ERR_NONE;
 219 }
 220
 221 /* Get the memory map as defined in the EFI spec. Return 1 if successful,
 222    return 0 if partial, or return -1 if an error occurs.  */
 223 int
 224 grub_efi_get_memory_map (grub_efi_uintn_t *memory_map_size,
 225                          grub_efi_memory_descriptor_t *memory_map,
 226                          grub_efi_uintn_t *map_key,
 227                          grub_efi_uintn_t *descriptor_size,
 228                          grub_efi_uint32_t *descriptor_version)
 229 {
 230   grub_efi_status_t status;
 231   grub_efi_boot_services_t *b;
 232   grub_efi_uintn_t key;
 233   grub_efi_uint32_t version;
 234   grub_efi_uintn_t size;
 235
 236   if (grub_efi_is_finished)
 237     {
 238       int ret = 1;
 239       if (*memory_map_size < finish_mmap_size)
 240         {
 241           grub_memcpy (memory_map, finish_mmap_buf, *memory_map_size);
 242           ret = 0;
 243         }
 244       else
 245         {
 246           grub_memcpy (memory_map, finish_mmap_buf, finish_mmap_size);
 247           ret = 1;
 248         }
 249       *memory_map_size = finish_mmap_size;
 250       if (map_key)
 251         *map_key = finish_key;
 252       if (descriptor_size)
 253         *descriptor_size = finish_desc_size;
 254       if (descriptor_version)
 255         *descriptor_version = finish_desc_version;
 256       return ret;
 257     }
 258
 259   /* Allow some parameters to be missing.  */
 260   if (! map_key)
 261     map_key = &key;
 262   if (! descriptor_version)
 263     descriptor_version = &version;
 264   if (! descriptor_size)
 265     descriptor_size = &size;
 266
 267   b = grub_efi_system_table->boot_services;
 268   status = efi_call_5 (b->get_memory_map, memory_map_size, memory_map, map_key,
 269                               descriptor_size, descriptor_version);
 270   if (*descriptor_size == 0)
 271     *descriptor_size = sizeof (grub_efi_memory_descriptor_t);
 272   if (status == GRUB_EFI_SUCCESS)
 273     return 1;
 274   else if (status == GRUB_EFI_BUFFER_TOO_SMALL)
 275     return 0;
 276   else
 277     return -1;
 278 }
 279
 280 /* Sort the memory map in place.  */
 281 static void
 282 sort_memory_map (grub_efi_memory_descriptor_t *memory_map,
 283                  grub_efi_uintn_t desc_size,
 284                  grub_efi_memory_descriptor_t *memory_map_end)
 285 {
 286   grub_efi_memory_descriptor_t *d1;
 287   grub_efi_memory_descriptor_t *d2;
 288
 289   for (d1 = memory_map;
 290        d1 < memory_map_end;
 291        d1 = NEXT_MEMORY_DESCRIPTOR (d1, desc_size))
 292     {
 293       grub_efi_memory_descriptor_t *max_desc = d1;
 294
 295       for (d2 = NEXT_MEMORY_DESCRIPTOR (d1, desc_size);
 296            d2 < memory_map_end;
 297            d2 = NEXT_MEMORY_DESCRIPTOR (d2, desc_size))
 298         {
 299           if (max_desc->num_pages < d2->num_pages)
 300             max_desc = d2;
 301         }
 302
 303       if (max_desc != d1)
 304         {
 305           grub_efi_memory_descriptor_t tmp;
 306
 307           tmp = *d1;
 308           *d1 = *max_desc;
 309           *max_desc = tmp;
 310         }
 311     }
 312 }
 313
 314 /* Filter the descriptors. GRUB needs only available memory.  */
 315 static grub_efi_memory_descriptor_t *
 316 filter_memory_map (grub_efi_memory_descriptor_t *memory_map,
 317                    grub_efi_memory_descriptor_t *filtered_memory_map,
 318                    grub_efi_uintn_t desc_size,
 319                    grub_efi_memory_descriptor_t *memory_map_end)
 320 {
 321   grub_efi_memory_descriptor_t *desc;
 322   grub_efi_memory_descriptor_t *filtered_desc;
 323
 324   for (desc = memory_map, filtered_desc = filtered_memory_map;
 325        desc < memory_map_end;
 326        desc = NEXT_MEMORY_DESCRIPTOR (desc, desc_size))
 327     {
 328       if (desc->type == GRUB_EFI_CONVENTIONAL_MEMORY
 329 #if 1
 330           && desc->physical_start <= GRUB_EFI_MAX_USABLE_ADDRESS
 331 #endif
 332           && desc->physical_start + PAGES_TO_BYTES (desc->num_pages) > 0x100000
 333           && desc->num_pages != 0)
 334         {
 335           grub_memcpy (filtered_desc, desc, desc_size);
 336
 337           /* Avoid less than 1MB, because some loaders seem to be confused.  */
 338           if (desc->physical_start < 0x100000)
 339             {
 340               desc->num_pages -= BYTES_TO_PAGES (0x100000
 341                                                  - desc->physical_start);
 342               desc->physical_start = 0x100000;
 343             }
 344
 345 #if 1
 346           if (BYTES_TO_PAGES (filtered_desc->physical_start)
 347               + filtered_desc->num_pages
 348               > BYTES_TO_PAGES_DOWN (GRUB_EFI_MAX_USABLE_ADDRESS))
 349             filtered_desc->num_pages
 350               = (BYTES_TO_PAGES_DOWN (GRUB_EFI_MAX_USABLE_ADDRESS)
 351                  - BYTES_TO_PAGES (filtered_desc->physical_start));
 352 #endif
 353
 354           if (filtered_desc->num_pages == 0)
 355             continue;
 356
 357           filtered_desc = NEXT_MEMORY_DESCRIPTOR (filtered_desc, desc_size);
 358         }
 359     }
 360
 361   return filtered_desc;
 362 }
 363
 364 /* Return the total number of pages.  */
 365 static grub_efi_uint64_t
 366 get_total_pages (grub_efi_memory_descriptor_t *memory_map,
 367                  grub_efi_uintn_t desc_size,
 368                  grub_efi_memory_descriptor_t *memory_map_end)
 369 {
 370   grub_efi_memory_descriptor_t *desc;
 371   grub_efi_uint64_t total = 0;
 372
 373   for (desc = memory_map;
 374        desc < memory_map_end;
 375        desc = NEXT_MEMORY_DESCRIPTOR (desc, desc_size))
 376     total += desc->num_pages;
 377
 378   return total;
 379 }
 380
 381 /* Add memory regions.  */
 382 static void
 383 add_memory_regions (grub_efi_memory_descriptor_t *memory_map,
 384                     grub_efi_uintn_t desc_size,
 385                     grub_efi_memory_descriptor_t *memory_map_end,
 386                     grub_efi_uint64_t required_pages)
 387 {
 388   grub_efi_memory_descriptor_t *desc;
 389
 390   for (desc = memory_map;
 391        desc < memory_map_end;
 392        desc = NEXT_MEMORY_DESCRIPTOR (desc, desc_size))
 393     {
 394       grub_efi_uint64_t pages;
 395       grub_efi_physical_address_t start;
 396       void *addr;
 397
 398       start = desc->physical_start;
 399       pages = desc->num_pages;
 400       if (pages > required_pages)
 401         {
 402           start += PAGES_TO_BYTES (pages - required_pages);
 403           pages = required_pages;
 404         }
 405
 406       addr = grub_efi_allocate_fixed (start, pages);
 407       if (! addr)
 408         grub_fatal ("cannot allocate conventional memory %p with %u pages",
 409                     (void *) ((grub_addr_t) start),
 410                     (unsigned) pages);
 411
 412       grub_mm_init_region (addr, PAGES_TO_BYTES (pages));
 413
 414       required_pages -= pages;
 415       if (required_pages == 0)
 416         break;
 417     }
 418
 419   if (required_pages > 0)
 420     grub_fatal ("too little memory");
 421 }
 422
 423 #if 0
 424 /* Print the memory map.  */
 425 static void
 426 print_memory_map (grub_efi_memory_descriptor_t *memory_map,
 427                   grub_efi_uintn_t desc_size,
 428                   grub_efi_memory_descriptor_t *memory_map_end)
 429 {
 430   grub_efi_memory_descriptor_t *desc;
 431   int i;
 432
 433   for (desc = memory_map, i = 0;
 434        desc < memory_map_end;
 435        desc = NEXT_MEMORY_DESCRIPTOR (desc, desc_size), i++)
 436     {
 437       grub_printf ("MD: t=%x, p=%llx, v=%llx, n=%llx, a=%llx\n",
 438                    desc->type, desc->physical_start, desc->virtual_start,
 439                    desc->num_pages, desc->attribute);
 440     }
 441 }
 442 #endif
 443
 444 void
 445 grub_efi_mm_init (void)
 446 {
 447   grub_efi_memory_descriptor_t *memory_map;
 448   grub_efi_memory_descriptor_t *memory_map_end;
 449   grub_efi_memory_descriptor_t *filtered_memory_map;
 450   grub_efi_memory_descriptor_t *filtered_memory_map_end;
 451   grub_efi_uintn_t map_size;
 452   grub_efi_uintn_t desc_size;
 453   grub_efi_uint64_t total_pages;
 454   grub_efi_uint64_t required_pages;
 455   int mm_status;
 456
 457   /* Prepare a memory region to store two memory maps.  */
 458   memory_map = grub_efi_allocate_any_pages (2 * BYTES_TO_PAGES (MEMORY_MAP_SIZE));
 459   if (! memory_map)
 460     grub_fatal ("cannot allocate memory");
 461
 462   /* Obtain descriptors for available memory.  */
 463   map_size = MEMORY_MAP_SIZE;
 464
 465   mm_status = grub_efi_get_memory_map (&map_size, memory_map, 0, &desc_size, 0);
 466
 467   if (mm_status == 0)
 468     {
 469       grub_efi_free_pages
 470         ((grub_efi_physical_address_t) ((grub_addr_t) memory_map),
 471          2 * BYTES_TO_PAGES (MEMORY_MAP_SIZE));
 472
 473       /* Freeing/allocating operations may increase memory map size.  */
 474       map_size += desc_size * 32;
 475
 476       memory_map = grub_efi_allocate_any_pages (2 * BYTES_TO_PAGES (map_size));
 477       if (! memory_map)
 478         grub_fatal ("cannot allocate memory");
 479
 480       mm_status = grub_efi_get_memory_map (&map_size, memory_map, 0,
 481                                            &desc_size, 0);
 482     }
 483
 484   if (mm_status < 0)
 485     grub_fatal ("cannot get memory map");
 486
 487   memory_map_end = NEXT_MEMORY_DESCRIPTOR (memory_map, map_size);
 488
 489   filtered_memory_map = memory_map_end;
 490
 491   filtered_memory_map_end = filter_memory_map (memory_map, filtered_memory_map,
 492                                                desc_size, memory_map_end);
 493
 494   /* By default, request a quarter of the available memory.  */
 495   total_pages = get_total_pages (filtered_memory_map, desc_size,
 496                                  filtered_memory_map_end);
 497   required_pages = (total_pages >> 2);
 498   if (required_pages < BYTES_TO_PAGES (MIN_HEAP_SIZE))
 499     required_pages = BYTES_TO_PAGES (MIN_HEAP_SIZE);
 500   else if (required_pages > BYTES_TO_PAGES (MAX_HEAP_SIZE))
 501     required_pages = BYTES_TO_PAGES (MAX_HEAP_SIZE);
 502
 503   /* Sort the filtered descriptors, so that GRUB can allocate pages
 504      from smaller regions.  */
 505   sort_memory_map (filtered_memory_map, desc_size, filtered_memory_map_end);
 506
 507   /* Allocate memory regions for GRUB's memory management.  */
 508   add_memory_regions (filtered_memory_map, desc_size,
 509                       filtered_memory_map_end, required_pages);
 510
 511 #if 0
 512   /* For debug.  */
 513   map_size = MEMORY_MAP_SIZE;
 514
 515   if (grub_efi_get_memory_map (&map_size, memory_map, 0, &desc_size, 0) < 0)
 516     grub_fatal ("cannot get memory map");
 517
 518   grub_printf ("printing memory map\n");
 519   print_memory_map (memory_map, desc_size,
 520                     NEXT_MEMORY_DESCRIPTOR (memory_map, map_size));
 521   grub_fatal ("Debug. ");
 522 #endif
 523
 524   /* Release the memory maps.  */
 525   grub_efi_free_pages ((grub_addr_t) memory_map,
 526                        2 * BYTES_TO_PAGES (MEMORY_MAP_SIZE));
 527 }