virtual.h

Go to the documentation of this file.

 
#ifndef MAXOS_VIRTUAL_H
#define MAXOS_VIRTUAL_H
 
#include <stdint.h>
#include <stddef.h>
#include <memory/physical.h>
#include <common/string.h>
 
 
namespace MaxOS {
    namespace memory {
 
        typedef enum VirtualFlags {
 
            RESERVE = (1 << 9),         
            SHARED = (1 << 10),         
 
        } virtual_flags_t;
 
        typedef struct VirtualMemoryChunk {
 
            uintptr_t start_address;    
            size_t size;                
            size_t flags;               
 
        } virtual_memory_chunk_t;
 
        typedef struct FreeChunk {
 
            uintptr_t start_address;    
            size_t size;                
            struct FreeChunk* next;     
 
        } free_chunk_t;
 
        static const size_t CHUNKS_PER_PAGE = PAGE_SIZE / sizeof(virtual_memory_chunk_t) -
                                              1;    
        static const size_t VMM_RESERVED = 0x138000000;                                         
 
        typedef struct PACKED VirtualMemoryRegion {
 
            virtual_memory_chunk_t chunks[CHUNKS_PER_PAGE];     
            struct VirtualMemoryRegion* next;                   
 
        } virtual_memory_region_t;
 
        class VirtualMemoryManager {
 
            private:
                uint64_t* m_pml4_root_address;
                uint64_t* m_pml4_root_physical_address;
 
                virtual_memory_region_t* m_first_region;
                virtual_memory_region_t* m_current_region;
                size_t m_current_chunk = 0;
                size_t m_next_available_address;
 
                free_chunk_t* m_free_chunks = nullptr;
                void add_free_chunk(uintptr_t start_address, size_t size);
                free_chunk_t* find_and_remove_free_chunk(size_t size);
 
                void new_region();
                void fill_up_to_address(uintptr_t address, size_t flags, bool mark_used);
 
            public:
                VirtualMemoryManager();
                ~VirtualMemoryManager();
 
                void* allocate(size_t size, size_t flags);
                void* allocate(uint64_t address, size_t size, size_t flags);
                void free(void* address);
 
                void* load_physical_into_address_space(uintptr_t physical_address, size_t size, size_t flags);
 
                void* load_shared_memory(const string &name);
                void* load_shared_memory(uintptr_t physical_address, size_t size);
 
                uint64_t* pml4_root_address();
                uint64_t* pml4_root_address_physical();
 
                size_t memory_used();
 
        };
    }
}
 
 
#endif // MAXOS_VIRTUAL_H