os-k/kaleid/kernel/mm/palloc.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;
}