vaseboot/VasEBoot-core/mmap/efi/mmap.c

/* Mmap management. */
/*
 *  VAS_EBOOT  --  GRand Unified Bootloader
 *  Copyright (C) 2009  Free Software Foundation, Inc.
 *
 *  VAS_EBOOT is free software: you can redistribute it and/or modify
 *  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.
 *
 *  VAS_EBOOT 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 VAS_EBOOT.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <VasEBoot/machine/memory.h>
#include <VasEBoot/memory.h>
#include <VasEBoot/err.h>
#include <VasEBoot/efi/api.h>
#include <VasEBoot/efi/efi.h>
#include <VasEBoot/mm.h>
#include <VasEBoot/misc.h>

#define NEXT_MEMORY_DESCRIPTOR(desc, size)      \
  ((VasEBoot_efi_memory_descriptor_t *) ((char *) (desc) + (size)))

VasEBoot_err_t
VasEBoot_efi_mmap_iterate (VasEBoot_memory_hook_t hook, void *hook_data,
		       int avoid_efi_boot_services)
{
  VasEBoot_efi_uintn_t mmap_size = 0;
  VasEBoot_efi_memory_descriptor_t *map_buf = 0;
  VasEBoot_efi_uintn_t map_key = 0;
  VasEBoot_efi_uintn_t desc_size = 0;
  VasEBoot_efi_uint32_t desc_version = 0;
  VasEBoot_efi_memory_descriptor_t *desc;

  if (VasEBoot_efi_get_memory_map (&mmap_size, map_buf,
			       &map_key, &desc_size,
			       &desc_version) < 0)
    return VasEBoot_errno;

  map_buf = VasEBoot_malloc (mmap_size);
  if (! map_buf)
    return VasEBoot_errno;

  if (VasEBoot_efi_get_memory_map (&mmap_size, map_buf,
			       &map_key, &desc_size,
			       &desc_version) <= 0)
    {
      VasEBoot_free (map_buf);
      return VasEBoot_errno;
    }

  for (desc = map_buf;
       desc < NEXT_MEMORY_DESCRIPTOR (map_buf, mmap_size);
       desc = NEXT_MEMORY_DESCRIPTOR (desc, desc_size))
    {
      VasEBoot_dprintf ("mmap", "EFI memory region 0x%llx-0x%llx: %d\n",
		    (unsigned long long) desc->physical_start,
		    (unsigned long long) desc->physical_start
		    + desc->num_pages * 4096, desc->type);
      switch (desc->type)
	{
	case VAS_EBOOT_EFI_BOOT_SERVICES_CODE:
	  if (!avoid_efi_boot_services)
	    {
	      hook (desc->physical_start, desc->num_pages * 4096,
		    VAS_EBOOT_MEMORY_AVAILABLE, hook_data);
	      break;
	    }
	  /* FALLTHROUGH */
	case VAS_EBOOT_EFI_RUNTIME_SERVICES_CODE:
	  hook (desc->physical_start, desc->num_pages * 4096,
		VAS_EBOOT_MEMORY_CODE, hook_data);
	  break;

	case VAS_EBOOT_EFI_UNUSABLE_MEMORY:
	  hook (desc->physical_start, desc->num_pages * 4096,
		VAS_EBOOT_MEMORY_BADRAM, hook_data);
	  break;

	case VAS_EBOOT_EFI_BOOT_SERVICES_DATA:
	  if (!avoid_efi_boot_services)
	    {
	      hook (desc->physical_start, desc->num_pages * 4096,
		    VAS_EBOOT_MEMORY_AVAILABLE, hook_data);
	      break;
	    }
	  /* FALLTHROUGH */
	case VAS_EBOOT_EFI_RESERVED_MEMORY_TYPE:
	case VAS_EBOOT_EFI_RUNTIME_SERVICES_DATA:
	case VAS_EBOOT_EFI_MEMORY_MAPPED_IO:
	case VAS_EBOOT_EFI_MEMORY_MAPPED_IO_PORT_SPACE:
	case VAS_EBOOT_EFI_PAL_CODE:
	  hook (desc->physical_start, desc->num_pages * 4096,
		VAS_EBOOT_MEMORY_RESERVED, hook_data);
	  break;

	case VAS_EBOOT_EFI_LOADER_CODE:
	case VAS_EBOOT_EFI_LOADER_DATA:
	case VAS_EBOOT_EFI_CONVENTIONAL_MEMORY:
	  hook (desc->physical_start, desc->num_pages * 4096,
		VAS_EBOOT_MEMORY_AVAILABLE, hook_data);
	  break;

	case VAS_EBOOT_EFI_ACPI_RECLAIM_MEMORY:
	  hook (desc->physical_start, desc->num_pages * 4096,
		VAS_EBOOT_MEMORY_ACPI, hook_data);
	  break;

	case VAS_EBOOT_EFI_ACPI_MEMORY_NVS:
	  hook (desc->physical_start, desc->num_pages * 4096,
		VAS_EBOOT_MEMORY_NVS, hook_data);
	  break;

	case VAS_EBOOT_EFI_PERSISTENT_MEMORY:
	  hook (desc->physical_start, desc->num_pages * 4096,
		VAS_EBOOT_MEMORY_PERSISTENT, hook_data);
	break;

	default:
	  VasEBoot_printf ("Unknown memory type %d, considering reserved\n",
		       desc->type);
	  hook (desc->physical_start, desc->num_pages * 4096,
		VAS_EBOOT_MEMORY_RESERVED, hook_data);
	  break;
	}
    }

  return VAS_EBOOT_ERR_NONE;
}

VasEBoot_err_t
VasEBoot_machine_mmap_iterate (VasEBoot_memory_hook_t hook, void *hook_data)
{
  return VasEBoot_efi_mmap_iterate (hook, hook_data, 0);
}

static inline VasEBoot_efi_memory_type_t
make_efi_memtype (int type)
{
  switch (type)
    {
    case VAS_EBOOT_MEMORY_CODE:
      return VAS_EBOOT_EFI_RUNTIME_SERVICES_CODE;

      /* No way to remove a chunk of memory from EFI mmap.
	 So mark it as unusable. */
    case VAS_EBOOT_MEMORY_HOLE:
    /*
     * AllocatePages() does not support VAS_EBOOT_EFI_PERSISTENT_MEMORY,
     * so no translation for VAS_EBOOT_MEMORY_PERSISTENT or
     * VAS_EBOOT_MEMORY_PERSISTENT_LEGACY.
     */
    case VAS_EBOOT_MEMORY_PERSISTENT:
    case VAS_EBOOT_MEMORY_PERSISTENT_LEGACY:
    case VAS_EBOOT_MEMORY_RESERVED:
      return VAS_EBOOT_EFI_UNUSABLE_MEMORY;

    case VAS_EBOOT_MEMORY_AVAILABLE:
      return VAS_EBOOT_EFI_CONVENTIONAL_MEMORY;

    case VAS_EBOOT_MEMORY_ACPI:
      return VAS_EBOOT_EFI_ACPI_RECLAIM_MEMORY;

    case VAS_EBOOT_MEMORY_NVS:
      return VAS_EBOOT_EFI_ACPI_MEMORY_NVS;
    }

  return VAS_EBOOT_EFI_UNUSABLE_MEMORY;
}

struct overlay
{
  struct overlay *next;
  VasEBoot_efi_physical_address_t address;
  VasEBoot_efi_uintn_t pages;
  int handle;
};

static struct overlay *overlays = 0;
static int curhandle = 1;

int
VasEBoot_mmap_register (VasEBoot_uint64_t start, VasEBoot_uint64_t size, int type)
{
  VasEBoot_uint64_t end = start + size;
  VasEBoot_efi_physical_address_t address;
  VasEBoot_efi_boot_services_t *b;
  VasEBoot_efi_uintn_t pages;
  VasEBoot_efi_status_t status;
  struct overlay *curover;

  curover = (struct overlay *) VasEBoot_malloc (sizeof (struct overlay));
  if (! curover)
    return 0;

  b = VasEBoot_efi_system_table->boot_services;
  address = start & (~0xfffULL);
  pages = (end - address + 0xfff) >> 12;
  status = b->free_pages (address, pages);
  if (status != VAS_EBOOT_EFI_SUCCESS && status != VAS_EBOOT_EFI_NOT_FOUND)
    {
      VasEBoot_free (curover);
      return 0;
    }
  status = b->allocate_pages (VAS_EBOOT_EFI_ALLOCATE_ADDRESS,
			      make_efi_memtype (type), pages, &address);
  if (status != VAS_EBOOT_EFI_SUCCESS)
    {
      VasEBoot_free (curover);
      return 0;
    }
  curover->next = overlays;
  curover->handle = curhandle++;
  curover->address = address;
  curover->pages = pages;
  overlays = curover;

  return curover->handle;
}

VasEBoot_err_t
VasEBoot_mmap_unregister (int handle)
{
  struct overlay *curover, *prevover;
  VasEBoot_efi_boot_services_t *b;

  b = VasEBoot_efi_system_table->boot_services;


  for (curover = overlays, prevover = 0; curover;
       prevover = curover, curover = curover->next)
    {
      if (curover->handle == handle)
	{
	  b->free_pages (curover->address, curover->pages);
	  if (prevover != 0)
	    prevover->next = curover->next;
	  else
	    overlays = curover->next;
	  VasEBoot_free (curover);
	  return VAS_EBOOT_ERR_NONE;
	}
    }
  return VasEBoot_error (VAS_EBOOT_ERR_BUG, "handle %d not found", handle);
}

/* Result is always page-aligned. */
void *
VasEBoot_mmap_malign_and_register (VasEBoot_uint64_t align __attribute__ ((unused)),
			       VasEBoot_uint64_t size,
			       int *handle, int type,
			       int flags __attribute__ ((unused)))
{
  VasEBoot_efi_physical_address_t address;
  VasEBoot_efi_boot_services_t *b;
  VasEBoot_efi_uintn_t pages;
  VasEBoot_efi_status_t status;
  struct overlay *curover;
  VasEBoot_efi_allocate_type_t atype;

  curover = (struct overlay *) VasEBoot_malloc (sizeof (struct overlay));
  if (! curover)
    return 0;

  b = VasEBoot_efi_system_table->boot_services;

  address = 0xffffffff;

#if VAS_EBOOT_TARGET_SIZEOF_VOID_P < 8
  /* Limit the memory access to less than 4GB for 32-bit platforms.  */
  atype = VAS_EBOOT_EFI_ALLOCATE_MAX_ADDRESS;
#else
  atype = VAS_EBOOT_EFI_ALLOCATE_ANY_PAGES;
#endif

  pages = (size + 0xfff) >> 12;
  status = b->allocate_pages (atype,
			      make_efi_memtype (type), pages, &address);
  if (status != VAS_EBOOT_EFI_SUCCESS)
    {
      VasEBoot_free (curover);
      return 0;
    }

  if (address == 0)
    {
      /* Uggh, the address 0 was allocated... This is too annoying,
	 so reallocate another one.  */
      address = 0xffffffff;
      status = b->allocate_pages (atype,
				  make_efi_memtype (type), pages, &address);
      VasEBoot_efi_free_pages (0, pages);
      if (status != VAS_EBOOT_EFI_SUCCESS)
	return 0;
    }

  curover->next = overlays;
  curover->handle = curhandle++;
  curover->address = address;
  curover->pages = pages;
  overlays = curover;
  *handle = curover->handle;

  return (void *) (VasEBoot_addr_t) curover->address;
}

void
VasEBoot_mmap_free_and_unregister (int handle)
{
  VasEBoot_mmap_unregister (handle);
}