virtual.h

Go to the documentation of this file.

 
#ifndef MAXOS_VIRTUAL_H
#define MAXOS_VIRTUAL_H
 
#include <stdint.h>
#include <stddef.h>
 
#include <libcommon/string.h>
 
#include <memory/physical.h>
 
 
namespace MaxOS::processes
{
    class Process;
}
 
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;
 
        constexpr size_t CHUNKS_PER_PAGE = PAGE_SIZE / sizeof(virtual_memory_chunk_t) - 1;   
        constexpr 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 = nullptr;
                uint64_t* m_pml4_root_physical_address = nullptr;
 
                virtual_memory_region_t* m_first_region = nullptr;
                virtual_memory_region_t* m_current_region = nullptr;
                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);
                virtual_memory_chunk_t* find_containing_chunk(const void* start_address, 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(size_t requested_size, size_t& actual_size, size_t flags);
                void* allocate(uint64_t address, size_t requested_size, size_t& actual_size, size_t flags);
                void free(void* address, bool reusable_pages = true);
 
                void* load_physical_into_address_space(uintptr_t physical_address, size_t size, size_t flags);
 
                void* load_range_from_process(VirtualMemoryManager* other_vmm, const void* start_address, size_t size);
                void  unload_range_from_process(const void* start_address, size_t size);
 
                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