/* mm.c - generic EFI memory management */
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2006,2007,2008,2009 Free Software Foundation, Inc.
*
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
/* The size of a memory map obtained from the firmware. This must be
a multiplier of 4KB. */
/* The minimum and maximum heap size for GRUB itself. */
static void *finish_mmap_buf = 0;
int grub_efi_is_finished = 0;
/* Allocate pages. Return the pointer to the first of allocated pages. */
void *
{
#if 1
/* Limit the memory access to less than 4GB for 32-bit platforms. */
if (address > 0xffffffff)
return 0;
#endif
#if 1
if (address == 0)
{
address = 0xffffffff;
}
else
#else
if (address == 0)
else
#endif
if (status != GRUB_EFI_SUCCESS)
return 0;
if (address == 0)
{
/* Uggh, the address 0 was allocated... This is too annoying,
so reallocate another one. */
address = 0xffffffff;
grub_efi_free_pages (0, pages);
if (status != GRUB_EFI_SUCCESS)
return 0;
}
return (void *) ((grub_addr_t) address);
}
/* Free pages starting from ADDRESS. */
void
{
}
{
&finish_desc_size, &finish_desc_version) < 0)
if (!finish_mmap_buf)
return grub_errno;
&finish_desc_size, &finish_desc_version) <= 0)
if (status != GRUB_EFI_SUCCESS)
grub_efi_is_finished = 1;
if (outbuf_size)
if (outbuf)
if (map_key)
*map_key = finish_key;
if (efi_desc_size)
if (efi_desc_version)
return GRUB_ERR_NONE;
}
/* Get the memory map as defined in the EFI spec. Return 1 if successful,
return 0 if partial, or return -1 if an error occurs. */
int
{
if (grub_efi_is_finished)
{
if (*memory_map_size < finish_mmap_size)
{
ret = 0;
}
else
{
ret = 1;
}
if (map_key)
*map_key = finish_key;
if (descriptor_size)
if (descriptor_version)
return ret;
}
/* Allow some parameters to be missing. */
if (! map_key)
if (! descriptor_version)
if (status == GRUB_EFI_SUCCESS)
return 1;
else if (status == GRUB_EFI_BUFFER_TOO_SMALL)
return 0;
else
return -1;
}
/* Sort the memory map in place. */
static void
{
for (d1 = memory_map;
d1 < memory_map_end;
{
d2 < memory_map_end;
{
}
{
}
}
}
/* Filter the descriptors. GRUB needs only available memory. */
static grub_efi_memory_descriptor_t *
{
{
#if 1
#endif
{
/* Avoid less than 1MB, because some loaders seem to be confused. */
{
- desc->physical_start);
}
#if 1
> BYTES_TO_PAGES (0x100000000LL))
= (BYTES_TO_PAGES (0x100000000LL)
#endif
if (filtered_desc->num_pages == 0)
continue;
}
}
return filtered_desc;
}
/* Return the total number of pages. */
static grub_efi_uint64_t
{
for (desc = memory_map;
return total;
}
/* Add memory regions. */
static void
{
for (desc = memory_map;
{
void *addr;
if (pages > required_pages)
{
}
if (! addr)
grub_fatal ("cannot allocate conventional memory %p with %u pages",
(void *) ((grub_addr_t) start),
(unsigned) pages);
required_pages -= pages;
if (required_pages == 0)
break;
}
if (required_pages > 0)
grub_fatal ("too little memory");
}
#if 0
/* Print the memory map. */
static void
{
int i;
for (desc = memory_map, i = 0;
{
grub_printf ("MD: t=%x, p=%llx, v=%llx, n=%llx, a=%llx\n",
}
}
#endif
void
grub_efi_mm_init (void)
{
int mm_status;
/* Prepare a memory region to store two memory maps. */
if (! memory_map)
grub_fatal ("cannot allocate memory");
/* Obtain descriptors for available memory. */
if (mm_status == 0)
{
/* Freeing/allocating operations may increase memory map size. */
if (! memory_map)
grub_fatal ("cannot allocate memory");
&desc_size, 0);
}
if (mm_status < 0)
grub_fatal ("cannot get memory map");
/* By default, request a quarter of the available memory. */
/* Sort the filtered descriptors, so that GRUB can allocate pages
from smaller regions. */
/* Allocate memory regions for GRUB's memory management. */
#if 0
/* For debug. */
grub_fatal ("cannot get memory map");
grub_printf ("printing memory map\n");
grub_abort ();
#endif
/* Release the memory maps. */
}
#ifdef GRUB_MACHINE_EFI
/* Find the optimal number of pages for the memory map. */
grub_efi_find_mmap_size (void)
{
if (mmap_size != 0)
return mmap_size;
while (1)
{
int ret;
if (! mmap)
return 0;
if (ret < 0)
{
return 0;
}
else if (ret > 0)
break;
}
/* Increase the size a bit for safety, because GRUB allocates more on
later, and EFI itself may allocate more. */
return mmap_size;
}
#endif