D:/COBE-Packet/cobe/system/pgng.c

gehe zur Dokumentation dieser Datei

#include <pgng.h>
#include <stdio.h>
#include <pmm.h>
#include <cmos.h>
#include <multitasking.h>

struct paging_directory* kernel_map; //----------Legt den Kernel-Addressraum an----------

extern const void start_kernel; //----------start_kernel und end_kernel sind Punkte, die im Linker-Script gekennzeichnet sind. Geben die Start und Endaddresse des Kernels an----------
extern const void end_kernel;
extern new_task_t* current_task;


void init_paging() {
        tick_counter = 0;
        uint32_t temp_cr0;
        kernel_map = paging_map();      //----------Die Kernel-Map wird vorbelegt und voll ausgestattet----------
        for(int i = 0; i < 1024 * 4096; i += 0x1000) identity_mapping(kernel_map, i, i, ACCS_BIT | WRITE_BIT);  //----------Vorläufig wird der Addressraum gleichgesetzt,  phys. Addresse = virtuelle Addresse, alle Pages werden mit RING0 belegt----------
        act_dir(kernel_map);            //----------Der Kernel-Addressraum wird sofort aktiviert----------
        
        __asm("mov %%cr0, %0" : "=b"(temp_cr0));        //----------Beim Register cr0 wird das 31. Bit für Paging gesetzt, 1 = Paging, 0 = Kein Paging----------
        temp_cr0 |= (1 << 31);
        __asm("mov %0, %%cr0" :: "b"(temp_cr0));
        return;
}


void act_dir(struct paging_directory* pg_dr) {
        __asm volatile("mov %0, %%cr3" :: "r"(pg_dr->page_directory));  //----------Die Addresse vom PageDirectory wird in das Register cr3 geladen, cr3 beinhaltet immer die Addresse des aktuellen PageDirectory----------
        return;
}


struct paging_directory* paging_map() {
        struct paging_directory* map_dr = pmm_alloc();  //----------Die Struktur des PageDirectory erhält einen eigenen Speicherbereich----------
        map_dr->page_directory = pmm_alloc();   //----------Das PageDirectory erhält einen eigenen Speicherbereich----------    

        for(int i = 0; i <1024; i++)
        {
                map_dr->page_directory[i] = 0;          //----------Jeder PageDirectory-Eintrag wird mit 0 vorbelegt----------
        }
        return map_dr;  //----------Die Addresse des Speicherbereichs der Struktur wird zurückgegeben----------
}


void identity_mapping(struct paging_directory* vmm, uint32_t virtaddr, uint32_t phyaddr, uint8_t flags) {
        uint32_t index = virtaddr / 4096;       //----------Der Index wird erzeugt, virtuelle Addrese durch 0x1000----------
        uint32_t dir_index = index / 1024;      //----------Das PageDirectory-Index ist der Index durch 0x400----------
        uint32_t table_index = index % 1024;    //----------Der PageTable-Index ist der Index modulo 0x400----------
        uint32_t* page_tbl;     //----------Eine neue PageTable wird erzeugt----------

        if(vmm->page_directory[dir_index] & ACCS_BIT) page_tbl = (uint32_t*) (vmm->page_directory[dir_index] & ~0xFFF);         //----------Wenn die PageTable bereits existiert, dann lösche alle Bits der PageTable----------
        else {
                        page_tbl = pmm_alloc();                         //----------Erzeuge für die PageTable einen neuen Speicherbereich----------
                        for(int i = 0; i < 1024; i++) page_tbl[i] = 0;                  //----------Belege die PageTable mit 0----------
                        vmm->page_directory[dir_index] = (uint32_t) page_tbl | flags;                   //----------Setze den Deskriptor in der PageDirectory zur PageTable und setze die Flags----------
        }
        page_tbl[table_index] = phyaddr | flags;        //----------Setze die angegebene physische Addresse in der PageTable und setze die Flags----------
        __asm volatile("invlpg %0" : : "m" (*(char*)virtaddr));
        return;
}


void kernel_mapping(struct paging_directory* pd) {
        uint32_t start = (uint32_t) &start_kernel;
        while(start < (uint32_t) &end_kernel) {
                identity_mapping(pd, start, start, ACCS_BIT | WRITE_BIT);
                start += 0x1000;
        }
        identity_mapping(pd, 0xB8000, 0xB8000,  ACCS_BIT | WRITE_BIT);
        return;
}


void* vmm_alloc() {
        uint32_t adr = 0;
        for(uint32_t i = 0; i < 32768; i++) {
                
                identity_mapping(current_task->task_pd, adr, (uint32_t)pmm_alloc(), ACCS_BIT | WRITE_BIT | ALL_ACCS_BIT);
        }
        return (void*)adr;
}


void vmm_free(void* page) {

}