1
0
mirror of https://gitlab.os-k.eu/os-k-team/os-k.git synced 2023-08-25 14:03:10 +02:00
os-k/kaleid/kernel/mm/map.c
2019-04-11 08:35:00 +02:00

203 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:;
}
KernLog("Mem zone : %lp\t%s\twith length: %d Kio\n",
memoryMap.entry[i].addr,
avStr,
memoryMap.entry[i].length / KB
);
}
}