mirror of
https://gitlab.os-k.eu/os-k-team/os-k.git
synced 2023-08-25 14:03:10 +02:00
204 lines
7.1 KiB
C
204 lines
7.1 KiB
C
//----------------------------------------------------------------------------//
|
|
// GNU GPL OS/K //
|
|
// //
|
|
// Desc: Mapping and checking memory related functions //
|
|
// //
|
|
// //
|
|
// Copyright © 2018-2019 The OS/K Team //
|
|
// //
|
|
// This file is part of OS/K. //
|
|
// //
|
|
// OS/K 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 //
|
|
// any later version. //
|
|
// //
|
|
// OS/K 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 OS/K. If not, see <https://www.gnu.org/licenses/>. //
|
|
//----------------------------------------------------------------------------//
|
|
|
|
#include <kernel/mm.h>
|
|
#include <kernel/boot.h>
|
|
#include <kernel/mboot.h>
|
|
|
|
// Initializes globally the memory map
|
|
MemoryMap_t memoryMap = { 0 };
|
|
|
|
|
|
static error_t InitMemoryMap(void);
|
|
|
|
//
|
|
// Initilization of the memory map, and computation of the available ram size
|
|
//
|
|
void MmInitMemoryMap(void)
|
|
{
|
|
error_t rc;
|
|
|
|
if ((rc = InitMemoryMap()))
|
|
KeStartPanic("[Init] The memory map failed to initialize. Error : %d",
|
|
rc
|
|
);
|
|
}
|
|
|
|
static error_t InitMemoryMap(void)
|
|
{
|
|
multiboot_memory_map_t *currentEntry;
|
|
multiboot_memory_map_t *mapEnd;
|
|
uint i = 0;
|
|
|
|
// sanity checks
|
|
if (!BtMemoryInfo.memValid && BtMemoryInfo.mapValid)
|
|
return ENXIO;
|
|
|
|
if ((BtMemoryInfo.upMemory / (MB/KB)) <= MINIMUM_RAM_SIZE)
|
|
return ENOMEM;
|
|
|
|
// Ok then we can work
|
|
|
|
// the memory map provided by GRUB via the BIOS
|
|
currentEntry = (multiboot_memory_map_t*)BtMemoryInfo.mapAddr;
|
|
// End address of the map
|
|
mapEnd = (multiboot_memory_map_t*)
|
|
((ulong)currentEntry + (ulong)BtMemoryInfo.mapLength);
|
|
|
|
// fill the map
|
|
while (currentEntry < mapEnd) {
|
|
|
|
// memory zone address
|
|
memoryMap.entry[i].addr = (void*)((ullong)currentEntry->addr_low +
|
|
(((ullong)currentEntry->addr_high) << 32 ));
|
|
// memory zone size in bytes
|
|
memoryMap.entry[i].length = (ulong)currentEntry->len_low +
|
|
(((ulong)currentEntry->len_high) << 32);
|
|
// memory availability
|
|
memoryMap.entry[i].type = (uint)currentEntry->type;
|
|
// Adding the size to the size (yup)
|
|
memoryMap.length++;
|
|
// moving up !
|
|
currentEntry = (multiboot_memory_map_t*) ((ulong)currentEntry +
|
|
currentEntry->size + sizeof(currentEntry->size));
|
|
i++;
|
|
}
|
|
|
|
DebugLog("[InitMemoryMap] %d entries detected in the memory map\n",
|
|
memoryMap.length);
|
|
|
|
// compute the free ram size
|
|
for (i = 0; i < memoryMap.length; i++) {
|
|
if (memoryMap.entry[i].type == AVAILABLE_ZONE) {
|
|
memoryMap.freeRamSize += memoryMap.entry[i].length;
|
|
} else {
|
|
memoryMap.nonfreeRamSize += memoryMap.entry[i].length;
|
|
}
|
|
}
|
|
|
|
// Trully strange if it happens...
|
|
if (memoryMap.freeRamSize < MINIMUM_RAM_SIZE)
|
|
return ENOMEM;
|
|
|
|
DebugLog("[InitMemoryMap] Available Ram Size : %u Mio, Used Ram Size : %u Kio\n\n",
|
|
memoryMap.freeRamSize / MB, memoryMap.nonfreeRamSize / KB);
|
|
/*DebugLog("[InitMemoryMap] Physical Ram Size : %d Mio\n\n",
|
|
(memoryMap.freeRamSize + memoryMap.nonfreeRamSize) / MB);*/
|
|
|
|
return EOK;
|
|
}
|
|
|
|
size_t MmGetAvailZoneSize(void *start) {
|
|
uint i;
|
|
|
|
// Because the kernel is the kernel
|
|
if (start < BtLoaderInfo.kernelEndAddr)
|
|
return 0;
|
|
|
|
// Search the zone where the start address is
|
|
for (i = 0; i < memoryMap.length; i++) {
|
|
// if the address is in an available zone, we can return the length
|
|
if (
|
|
memoryMap.entry[i].type == AVAILABLE_ZONE &&
|
|
(ulong)start >= (ulong)memoryMap.entry[i].addr &&
|
|
(ulong)start < ((ulong)memoryMap.entry[i].addr +
|
|
(ulong)memoryMap.entry[i].length)
|
|
) {
|
|
return (size_t)((ulong)memoryMap.entry[i].length - (ulong)start);
|
|
}
|
|
}
|
|
|
|
// If there is no zone, we return a 0 size
|
|
return 0;
|
|
}
|
|
|
|
void *MmGetFirstAvailZone(void *start) {
|
|
uint i;
|
|
void *current = 0;
|
|
|
|
// Because the kernel is the kernel
|
|
if ((ulong)start < (ulong)BtLoaderInfo.kernelEndAddr) {
|
|
return MmGetFirstAvailZone(BtLoaderInfo.kernelEndAddr);
|
|
}
|
|
|
|
// Search the zone where the start address is
|
|
for (i = 0; i < memoryMap.length; i++) {
|
|
// if the address is in an available zone, we can return the start address
|
|
if (
|
|
memoryMap.entry[i].type == AVAILABLE_ZONE &&
|
|
(ulong)start >= (ulong)memoryMap.entry[i].addr &&
|
|
(ulong)start < ((ulong)memoryMap.entry[i].addr +
|
|
(ulong)memoryMap.entry[i].length)
|
|
) {
|
|
current = start;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (current)
|
|
return current;
|
|
|
|
// Search the first zone from start
|
|
for (i = 0; i < memoryMap.length; i++) {
|
|
// Return the first zone that is after start
|
|
if (
|
|
memoryMap.entry[i].type == AVAILABLE_ZONE &&
|
|
(ulong)start <= (ulong)memoryMap.entry[i].addr
|
|
) {
|
|
current = memoryMap.entry[i].addr;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return current;
|
|
}
|
|
|
|
void MmPrintMemoryMap(void) {
|
|
char *avStr = "";
|
|
|
|
for (uint i=0; i < memoryMap.length; i++) {
|
|
|
|
switch (memoryMap.entry[i].type) {
|
|
case AVAILABLE_ZONE: avStr="Available";
|
|
break;
|
|
case RESERVED_ZONE: avStr="Reserved";
|
|
break;
|
|
case ACPI_ZONE: avStr="ACPI";
|
|
break;
|
|
case NVS_ZONE: avStr="NVS";
|
|
break;
|
|
case BADRAM_ZONE: avStr="Bad Ram";
|
|
break;
|
|
default:;
|
|
}
|
|
|
|
ulong len = memoryMap.entry[i].length;
|
|
|
|
KernLog("Mem zone : %lp\t%s\twith length: %luMB + %luKB + %luB\n",
|
|
memoryMap.entry[i].addr, avStr,
|
|
_ADDR_TO_MB(len), _ADDR_TO_KB(len), _ADDR_TO_B(len)
|
|
);
|
|
}
|
|
}
|