305 lines
9.0 KiB
C
305 lines
9.0 KiB
C
//----------------------------------------------------------------------------//
|
|
// GNU GPL OS/K //
|
|
// //
|
|
// Desc: Page allocator 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.h>
|
|
#include <init/boot.h>
|
|
#include <ex/malloc.h>
|
|
#include <mm/paging.h>
|
|
#include <mm/palloc.h>
|
|
#include <mm/map.h>
|
|
#include <io/vga.h>
|
|
|
|
//---------
|
|
|
|
enum
|
|
{
|
|
Whatever = 1UL << 52,
|
|
Whatever2 = 1UL << 62
|
|
};
|
|
|
|
static AllocatedPage_t busyPagesList = { (void*)0, 0, (AllocatedPage_t*)0 };
|
|
extern MemoryMap_t memoryMap;
|
|
extern ulong MmPhysLastKernAddress;
|
|
|
|
//---------
|
|
|
|
static bool isPageBusy(void *phyPageAddr)
|
|
{
|
|
AllocatedPage_t *busyPage = &busyPagesList;
|
|
bool isBusy = false;
|
|
|
|
// In case of NVS, ACPI or BADRAM zone, considered busy
|
|
if (!MmGetAvailZoneSize(phyPageAddr))
|
|
return true;
|
|
|
|
// Search in the busylist if the phy addr is here
|
|
while(busyPage->next) {
|
|
busyPage = busyPage->next;
|
|
if (phyPageAddr == busyPage->phyAddress) {
|
|
isBusy = true;
|
|
break;
|
|
}
|
|
}
|
|
return isBusy;
|
|
}
|
|
|
|
static void printBusyPages(void)
|
|
{
|
|
AllocatedPage_t *busyPage = &busyPagesList;
|
|
|
|
if (!busyPage->next) {
|
|
KernLog("No busy page\n");
|
|
} else {
|
|
while(busyPage->next) {
|
|
busyPage = busyPage->next;
|
|
KernLog("Busy page at %p\n", busyPage->phyAddress);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void addPageToBusyList(void *phyPageAddr, ulong id)
|
|
{
|
|
AllocatedPage_t *busyPage = &busyPagesList;
|
|
AllocatedPage_t *prevBusyPage = NULL;
|
|
|
|
while(busyPage->next) {
|
|
prevBusyPage = busyPage;
|
|
busyPage = busyPage->next;
|
|
|
|
if (busyPage->phyAddress > phyPageAddr) {
|
|
busyPage = prevBusyPage;
|
|
break;
|
|
}
|
|
}
|
|
|
|
AllocatedPage_t *newBusyPage = (AllocatedPage_t*)malloc(sizeof(AllocatedPage_t));
|
|
newBusyPage->phyAddress = phyPageAddr;
|
|
newBusyPage->id = id;
|
|
newBusyPage->next = busyPage->next;
|
|
busyPage->next = newBusyPage;
|
|
}
|
|
|
|
static void removePageFromBusyList(void *phyPageAddr)
|
|
{
|
|
AllocatedPage_t *busyPage = &busyPagesList;
|
|
AllocatedPage_t *prevBusyPage = NULL;
|
|
|
|
while(busyPage->next) {
|
|
prevBusyPage = busyPage;
|
|
busyPage = busyPage->next;
|
|
|
|
if (phyPageAddr == busyPage->phyAddress) {
|
|
prevBusyPage->next = busyPage->next;
|
|
free(busyPage);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Returns an id to identify a page frame allocated (kernel)
|
|
//
|
|
ulong MmAllocPageFrame(void ***frameListPtr, size_t *pageNumber, size_t size, bool contiguous)
|
|
{
|
|
static ulong id = 0;
|
|
*pageNumber = (((ulong)size - 1) / KPAGESIZE) + 1;
|
|
|
|
*frameListPtr = (void**)malloc(sizeof(void*)*(*pageNumber));
|
|
size_t curNumber = 0;
|
|
bool inBlock = false;
|
|
|
|
// Incrementing id
|
|
id++;
|
|
|
|
// Maximum PHYSICAL address in memory
|
|
ulong phRamSize = memoryMap.freeRamSize + memoryMap.nonfreeRamSize;
|
|
|
|
DebugLog("Allocating %d pages...\n", *pageNumber);
|
|
|
|
for (void *curPage = (void*)(MmPhysLastKernAddress + KPAGESIZE); curPage < (void*)phRamSize; curPage += KPAGESIZE) {
|
|
if (!isPageBusy(curPage)) {
|
|
(*frameListPtr)[curNumber] = curPage;
|
|
inBlock = true;
|
|
//DebugLog("Select page : %p\n", curPage);
|
|
if (++curNumber >= *pageNumber) {
|
|
break;
|
|
}
|
|
} else {
|
|
inBlock = false;
|
|
}
|
|
if (contiguous)
|
|
if (!inBlock)
|
|
curNumber = 0;
|
|
}
|
|
|
|
for (size_t i = 0; i < *pageNumber; i++) {
|
|
addPageToBusyList((*frameListPtr)[i], id);
|
|
//DebugLog("Allocating page : %p\n", *frameListPtr[i]);
|
|
}
|
|
|
|
return id;
|
|
}
|
|
|
|
//
|
|
// Frees a page frame by its id
|
|
//
|
|
void MmFreePageFrame(ulong id)
|
|
{
|
|
AllocatedPage_t *busyPage = &busyPagesList;
|
|
|
|
while(busyPage->next) {
|
|
busyPage = busyPage->next;
|
|
|
|
if (id == busyPage->id) {
|
|
removePageFromBusyList(busyPage->phyAddress);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Maps an allocated page frame to the given address
|
|
//
|
|
error_t MmMapPageFrame(ulong id, void *virtAddr, ulong flags)
|
|
{
|
|
AllocatedPage_t *busyPage = &busyPagesList;
|
|
ulong offset = 0;
|
|
|
|
while(busyPage->next) {
|
|
busyPage = busyPage->next;
|
|
|
|
//DebugLog("Physical : %p is %p\n", busyPage->phyAddress, MmTransPhyToVirtAddr(busyPage->phyAddress));
|
|
|
|
if (MmTransPhyToVirtAddr(busyPage->phyAddress)) {
|
|
return EADDRINUSE;
|
|
}
|
|
|
|
if (id == busyPage->id) {
|
|
MmMapPage((void*)((ulong)virtAddr + offset), busyPage->phyAddress, flags);
|
|
DebugLog("Map %p at %p\n", busyPage->phyAddress, virtAddr + offset);
|
|
offset += KPAGESIZE;
|
|
}
|
|
}
|
|
|
|
return EOK;
|
|
}
|
|
|
|
error_t MmUnmapPageFrame(ulong id)
|
|
{
|
|
AllocatedPage_t *busyPage = &busyPagesList;
|
|
void *actualPhys = 0;
|
|
|
|
while(busyPage->next) {
|
|
busyPage = busyPage->next;
|
|
actualPhys = MmTransPhyToVirtAddr(busyPage->phyAddress);
|
|
|
|
//DebugLog("Physical : %p is %p\n", busyPage->phyAddress, actualPhys);
|
|
|
|
if (actualPhys && id == busyPage->id) {
|
|
DebugLog("Unmap %p from %p\n", busyPage->phyAddress, MmTransPhyToVirtAddr(busyPage->phyAddress));
|
|
MmUnmapPage(MmTransPhyToVirtAddr(busyPage->phyAddress));
|
|
}
|
|
}
|
|
|
|
return EOK;
|
|
}
|
|
|
|
error_t MmTestBusyPage(void)
|
|
{
|
|
DebugLog("\nBusy pages\n");
|
|
printBusyPages();
|
|
|
|
|
|
void **ptr = NULL;
|
|
size_t n = 0;
|
|
ulong id1 = MmAllocPageFrame(&ptr, &n, 6677, NORMAL);
|
|
DebugLog("Alloc 6677 bytes : %p, %d pages, first at %p\n", ptr, n, ptr[0]);
|
|
|
|
void **ptr2 = NULL;
|
|
size_t n2 = 0;
|
|
ulong id2 = MmAllocPageFrame(&ptr2, &n2, 9045, NORMAL);
|
|
DebugLog("Alloc 9045 bytes: %p, %d pages, first at %p\n", ptr2, n2, ptr2[0]);
|
|
|
|
void **ptr3 = NULL;
|
|
size_t n3 = 0;
|
|
ulong id3 = MmAllocPageFrame(&ptr3, &n3, 1200, NORMAL);
|
|
DebugLog("Alloc 1200 bytes: %p, %d pages, first at %p\n", ptr3, n3, ptr3[0]);
|
|
|
|
void **ptr4 = NULL;
|
|
size_t n4 = 0;
|
|
ulong id4 = MmAllocPageFrame(&ptr4, &n4, 4096, NORMAL);
|
|
DebugLog("Alloc 4096 bytes: %p, %d pages, first at %p\n", ptr4, n4, ptr4[0]);
|
|
void **ptr5 = NULL;
|
|
size_t n5 = 0;
|
|
ulong id5 = MmAllocPageFrame(&ptr5, &n5, 4097, NORMAL);
|
|
DebugLog("Alloc 4097 bytes: %p, %d pages, first at %p\n", ptr5, n5, ptr5[0]);
|
|
|
|
printBusyPages();
|
|
|
|
MmFreePageFrame(id1);
|
|
MmFreePageFrame(id3);
|
|
DebugLog("Free 6677 and 1200 bytes\n");
|
|
|
|
void **ptr6 = NULL;
|
|
size_t n6 = 0;
|
|
ulong id6 = MmAllocPageFrame(&ptr6, &n6, 10000, NORMAL);
|
|
DebugLog("Alloc 10000 bytes: %p, %d pages, first at %p\n", ptr6, n6, ptr6[0]);
|
|
|
|
printBusyPages();
|
|
|
|
MmFreePageFrame(id6);
|
|
DebugLog("Free 10000 bytes\n");
|
|
|
|
printBusyPages();
|
|
|
|
void **ptr7 = NULL;
|
|
size_t n7 = 0;
|
|
ulong id7 = MmAllocPageFrame(&ptr7, &n7, 10000, CONTIGUOUS);
|
|
DebugLog("Alloc 10000 bytes contiguous: %p, %d pages, first at %p\n", ptr7, n7, ptr7[0]);
|
|
|
|
printBusyPages();
|
|
|
|
MmFreePageFrame(id1);
|
|
MmFreePageFrame(id2);
|
|
MmFreePageFrame(id3);
|
|
MmFreePageFrame(id4);
|
|
MmFreePageFrame(id5);
|
|
MmFreePageFrame(id6);
|
|
MmFreePageFrame(id7);
|
|
DebugLog("Free all bytes\n");
|
|
|
|
printBusyPages();
|
|
|
|
id1 = MmAllocPageFrame(&ptr, &n, 1*MB, NORMAL);
|
|
error_t err = MmMapPageFrame(id1, (void*)USERSPACE, PRESENT | USERMODE | READWRITE);
|
|
|
|
if (err == EOK)
|
|
DebugLog("Map status : OK\n");
|
|
if (err == EADDRINUSE)
|
|
DebugLog("Map status : NOK\n");
|
|
|
|
MmUnmapPageFrame(id1);
|
|
|
|
return EOK;
|
|
}
|