/*      $NetBSD: efimemory.c,v 1.10 2023/05/14 09:07:54 riastradh Exp $ */

/*-
* Copyright (c) 2016 Kimihiro Nonaka <[email protected]>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

#include "efiboot.h"

#include <bootinfo.h>

static const char *efi_memory_type[] = {
       [EfiReservedMemoryType]         = "Reserved Memory Type",
       [EfiLoaderCode]                 = "Loader Code",
       [EfiLoaderData]                 = "Loader Data",
       [EfiBootServicesCode]           = "Boot Services Code",
       [EfiBootServicesData]           = "Boot Services Data",
       [EfiRuntimeServicesCode]        = "Runtime Services Code",
       [EfiRuntimeServicesData]        = "Runtime Services Data",
       [EfiConventionalMemory]         = "Conventional Memory",
       [EfiUnusableMemory]             = "Unusable Memory",
       [EfiACPIReclaimMemory]          = "ACPI Reclaim Memory",
       [EfiACPIMemoryNVS]              = "ACPI Memory NVS",
       [EfiMemoryMappedIO]             = "MMIO",
       [EfiMemoryMappedIOPortSpace]    = "MMIO (Port Space)",
       [EfiPalCode]                    = "Pal Code",
       [EfiPersistentMemory]           = "Persistent Memory",
};

#ifndef KERN_LOADSPACE_SIZE
#define KERN_LOADSPACE_SIZE     (128 * 1024 * 1024)     /* 128MiB */
#endif

static int
getmemtype(EFI_MEMORY_DESCRIPTOR *md)
{

       switch (md->Type) {
       case EfiLoaderCode:
       case EfiLoaderData:
       case EfiBootServicesCode:
       case EfiBootServicesData:
       case EfiConventionalMemory:
               return (md->Attribute & EFI_MEMORY_WB) ?
                   BIM_Memory : BIM_Reserved;

       case EfiACPIReclaimMemory:
               return BIM_ACPI;

       case EfiACPIMemoryNVS:
               return BIM_NVS;

       case EfiPersistentMemory:
               return BIM_PMEM;

       case EfiReservedMemoryType:
       case EfiRuntimeServicesCode:
       case EfiRuntimeServicesData:
       case EfiUnusableMemory:
       case EfiMemoryMappedIO:
       case EfiMemoryMappedIOPortSpace:
       case EfiPalCode:
       case EfiMaxMemoryType:
       default:
               return BIM_Reserved;
       }
}

EFI_MEMORY_DESCRIPTOR *
efi_memory_get_map(UINTN *NoEntries, UINTN *MapKey, UINTN *DescriptorSize,
   UINT32 *DescriptorVersion, bool sorted)
{
       EFI_MEMORY_DESCRIPTOR *desc, *md, *next, *target, *tmp;
       UINTN i, j;

       *NoEntries = 0;
       desc = LibMemoryMap(NoEntries, MapKey, DescriptorSize,
           DescriptorVersion);
       if (desc == NULL)
               panic("efi_memory_get_map failed");

       if (!sorted)
               return desc;

       tmp = alloc(*DescriptorSize);
       if (tmp == NULL)
               return desc;

       for (i = 0, md = desc; i < *NoEntries - 1; i++, md = next) {
               target = next = NextMemoryDescriptor(md, *DescriptorSize);
               for (j = i + 1; j < *NoEntries; j++) {
                       if (md->PhysicalStart > target->PhysicalStart) {
                               CopyMem(tmp, md, *DescriptorSize);
                               CopyMem(md, target, *DescriptorSize);
                               CopyMem(target, tmp, *DescriptorSize);
                       }
                       target = NextMemoryDescriptor(target, *DescriptorSize);
               }
       }
       dealloc(tmp, *DescriptorSize);

       return desc;
}

EFI_MEMORY_DESCRIPTOR *
efi_memory_compact_map(EFI_MEMORY_DESCRIPTOR *desc, UINTN *NoEntries,
   UINTN DescriptorSize)
{
       EFI_MEMORY_DESCRIPTOR *md, *next, *target, *tmp;
       UINTN i, j;
       UINT32 type;
       bool first = true, do_compact;

       for (i = 0, md = target = desc; i < *NoEntries; i++, md = next) {
               type = md->Type;
               switch (type) {
               case EfiLoaderCode:
               case EfiLoaderData:
               case EfiBootServicesCode:
               case EfiBootServicesData:
               case EfiConventionalMemory:
                       if ((md->Attribute & EFI_MEMORY_WB) != 0)
                               type = EfiConventionalMemory;
                       if (md->Attribute == target->Attribute) {
                               do_compact = true;
                               break;
                       }
                       /* FALLTHROUGH */
               case EfiACPIReclaimMemory:
               case EfiACPIMemoryNVS:
               case EfiPersistentMemory:
               case EfiReservedMemoryType:
               case EfiRuntimeServicesCode:
               case EfiRuntimeServicesData:
               case EfiUnusableMemory:
               case EfiMemoryMappedIO:
               case EfiMemoryMappedIOPortSpace:
               case EfiPalCode:
               default:
                       do_compact = false;
                       break;
               }

               if (first) {
                       first = false;
               } else if (do_compact &&
                   type == target->Type &&
                   md->Attribute == target->Attribute &&
                   md->PhysicalStart == target->PhysicalStart + target->NumberOfPages * EFI_PAGE_SIZE) {
                       /* continuous region */
                       target->NumberOfPages += md->NumberOfPages;

                       tmp = md;
                       for (j = i + 1; j < *NoEntries; j++) {
                               next = NextMemoryDescriptor(md, DescriptorSize);
                               CopyMem(md, next, DescriptorSize);
                               md = next;
                       }
                       next = tmp;

                       i--;
                       (*NoEntries)--;
                       continue;
               } else {
                       target = md;
               }

               target->Type = type;
               next = NextMemoryDescriptor(md, DescriptorSize);
       }

       return desc;
}

int
efi_memory_get_memmap(struct bi_memmap_entry **memmapp, size_t *num)
{
       EFI_STATUS status;
       EFI_MEMORY_DESCRIPTOR *mdtop, *md, *next;
       UINTN i, NoEntries, MapKey, DescriptorSize;
       UINT32 DescriptorVersion;
       UINTN cols, rows;
       struct bi_memmap_entry *memmap;

       status = uefi_call_wrapper(ST->ConOut->QueryMode, 4, ST->ConOut,
           ST->ConOut->Mode->Mode, &cols, &rows);
       if (EFI_ERROR(status) || rows <= 2)
               return -1;

       mdtop = efi_memory_get_map(&NoEntries, &MapKey, &DescriptorSize,
           &DescriptorVersion, true);
       efi_memory_compact_map(mdtop, &NoEntries, DescriptorSize);

       memmap = alloc(sizeof(*memmap) * NoEntries);

       for (i = 0, md = mdtop; i < NoEntries; i++, md = next) {
               memmap[i].addr = md->PhysicalStart;
               memmap[i].size = md->NumberOfPages * EFI_PAGE_SIZE;
               memmap[i].type = getmemtype(md);

               next = NextMemoryDescriptor(md, DescriptorSize);
       }

       *memmapp = memmap;
       *num = NoEntries;
       return 0;
}

/*
* get memory size below 1MB
*/
int
getbasemem(void)
{
       EFI_MEMORY_DESCRIPTOR *mdtop, *md, *next;
       UINTN i, NoEntries, MapKey, DescriptorSize, MappingSize;
       UINT32 DescriptorVersion;
       EFI_PHYSICAL_ADDRESS basemem = 0, epa;

       mdtop = efi_memory_get_map(&NoEntries, &MapKey, &DescriptorSize,
           &DescriptorVersion, true);

       for (i = 0, md = mdtop; i < NoEntries; i++, md = next) {
               next = NextMemoryDescriptor(md, DescriptorSize);
               if (getmemtype(md) != BIM_Memory)
                       continue;
               if (md->PhysicalStart >= 1 * 1024 * 1024)
                       continue;
               if (basemem != md->PhysicalStart)
                       continue;

               MappingSize = md->NumberOfPages * EFI_PAGE_SIZE;
               epa = md->PhysicalStart + MappingSize;
               if (epa == 0 || epa > 1 * 1024 * 1024)
                       epa = 1 * 1024 * 1024;
               basemem = epa;
       }

       FreePool(mdtop);

       return basemem / 1024;  /* KiB */
}

/*
* get memory size above 1MB below 4GB
*/
int
getextmemx(void)
{
       EFI_MEMORY_DESCRIPTOR *mdtop, *md, *next;
       UINTN i, NoEntries, MapKey, DescriptorSize, MappingSize;
       UINT32 DescriptorVersion;
       EFI_PHYSICAL_ADDRESS extmem16m = 0;     /* 0-16MB */
       EFI_PHYSICAL_ADDRESS extmem4g = 0;      /* 16MB-4GB */
       EFI_PHYSICAL_ADDRESS pa, epa;
       bool first16m = true, first4g = true;
       int extmem;

       mdtop = efi_memory_get_map(&NoEntries, &MapKey, &DescriptorSize,
           &DescriptorVersion, true);

       for (i = 0, md = mdtop; i < NoEntries; i++, md = next) {
               next = NextMemoryDescriptor(md, DescriptorSize);
               if (getmemtype(md) == BIM_Reserved)
                       continue;
               if (md->PhysicalStart >= 4 * 1024 * 1024 * 1024ULL)
                       continue;

               MappingSize = md->NumberOfPages * EFI_PAGE_SIZE;
               epa = md->PhysicalStart + MappingSize;
               if (epa == 0 || epa > 4 * 1024 * 1024 * 1024LL)
                       epa = 4 * 1024 * 1024 * 1024LL;

               if (epa <= 1 * 1024 * 1024)
                       continue;

               pa = md->PhysicalStart;
               if (pa < 16 * 1024 * 1024) {
                       if (first16m || extmem16m == pa) {
                               first16m = false;
                               if (epa >= 16 * 1024 * 1024) {
                                       extmem16m = 16 * 1024 * 1024;
                                       pa = 16 * 1024 * 1024;
                               } else
                                       extmem16m = epa;
                       }
               }
               if (pa >= 16 * 1024 * 1024) {
                       if (first4g || extmem4g == pa) {
                               first4g = false;
                               extmem4g = epa;
                       }
               }
       }

       FreePool(mdtop);

       if (extmem16m > 1 * 1024 * 1024)
               extmem16m -= 1 * 1024 * 1024;   /* below 1MB */

       extmem = extmem16m / 1024;
       if (extmem == 15 * 1024)
               extmem += extmem4g / 1024;
       return extmem;
}

void
efi_memory_probe(void)
{
       EFI_MEMORY_DESCRIPTOR *mdtop, *md, *next;
       EFI_STATUS status;
       EFI_PHYSICAL_ADDRESS bouncebuf;
       UINTN i, n, NoEntries, MapKey, DescriptorSize, MappingSize;
       UINT32 DescriptorVersion;
       int memtype;

       bouncebuf = EFI_ALLOCATE_MAX_ADDRESS;
       status = uefi_call_wrapper(BS->AllocatePages, 4, AllocateMaxAddress,
           EfiLoaderData, EFI_SIZE_TO_PAGES(KERN_LOADSPACE_SIZE), &bouncebuf);
       if (EFI_ERROR(status))
               panic("couldn't allocate kernel space.");
       efi_loadaddr = bouncebuf;

       mdtop = efi_memory_get_map(&NoEntries, &MapKey, &DescriptorSize,
           &DescriptorVersion, false);
       printf(" mem[");
       for (i = 0, n = 0, md = mdtop; i < NoEntries; i++, md = next) {
               next = NextMemoryDescriptor(md, DescriptorSize);

               memtype = getmemtype(md);
               if (memtype != BIM_Memory)
                       continue;

               MappingSize = md->NumberOfPages * EFI_PAGE_SIZE;
               if (MappingSize < 12 * 1024)    /* XXX Why? from OpenBSD */
                       continue;

               if (n++ > 0)
                       printf(" ");
               printf("0x%" PRIxMAX "-0x%" PRIxMAX, (uintmax_t)md->PhysicalStart,
                   (uintmax_t)(md->PhysicalStart + MappingSize - 1));
       }
       printf("]\n");

       FreePool(mdtop);
}

void
efi_memory_show_map(bool sorted, bool compact)
{
       EFI_STATUS status;
       EFI_MEMORY_DESCRIPTOR *mdtop, *md, *next;
       UINTN i, NoEntries, MapKey, DescriptorSize;
       UINT32 DescriptorVersion;
       char efimemstr[32];
       UINTN cols, rows, row;

       status = uefi_call_wrapper(ST->ConOut->QueryMode, 4, ST->ConOut,
           ST->ConOut->Mode->Mode, &cols, &rows);
       if (EFI_ERROR(status) || rows <= 2)
               rows = 0;
       else
               rows -= 2;

       mdtop = efi_memory_get_map(&NoEntries, &MapKey, &DescriptorSize,
           &DescriptorVersion, sorted);
       if (compact)
               efi_memory_compact_map(mdtop, &NoEntries, DescriptorSize);

       printf("%-22s  %-16s  %-16s  %-16s\n", "Type", "Start", "End", "Attributes");
       printf("----------------------  ----------------  ----------------  ----------------\n");
       row = 2;

       for (i = 0, md = mdtop; i < NoEntries; i++, md = next) {
               next = NextMemoryDescriptor(md, DescriptorSize);

               if (md->Type >= __arraycount(efi_memory_type))
                       snprintf(efimemstr, sizeof(efimemstr), "unknown (%d)",
                           md->Type);
               printf("%-22s  %016" PRIxMAX "  %016" PRIxMAX "  %016" PRIxMAX "\n",
                   md->Type >= __arraycount(efi_memory_type) ?
                     efimemstr : efi_memory_type[md->Type],
                   (uintmax_t)md->PhysicalStart,
                   (uintmax_t)md->PhysicalStart +
                     md->NumberOfPages * EFI_PAGE_SIZE - 1,
                   (uintmax_t)md->Attribute);

               if (++row >= rows) {
                       row = 0;
                       printf("Press Any Key to continue :");
                       (void) awaitkey(-1, 0);
                       printf("\n");
               }
       }

       FreePool(mdtop);
}

void
vpbcopy(const void *va, void *pa, size_t n)
{
       memmove(pa, va, n);
}

void
pvbcopy(const void *pa, void *va, size_t n)
{
       memmove(va, pa, n);
}

void
pbzero(void *pa, size_t n)
{
       memset(pa, 0, n);
}

physaddr_t
vtophys(void *va)
{
       return (physaddr_t)va;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.