mm.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: GPL-3.0-or-later
 
#pragma once
 
#include "mos/io/io.hpp"
#include "mos/mm/mmstat.hpp"
#include "mos/mm/physical/pmm.hpp"
#include "mos/platform/platform.hpp"
#include "mos/syslog/syslog.hpp"
 
#include <mos/allocator.hpp>
#include <mos/lib/structures/list.hpp>
#include <mos/lib/sync/spinlock.hpp>
#include <mos/mm/mm_types.h>

 
typedef enum
{
    VMAP_UNKNOWN = 0,
    VMAP_STACK, // stack (user)
    VMAP_FILE,  // file mapping
    VMAP_MMAP,  // mmap mapping
    VMAP_DMA,   // DMA mapping
} vmap_content_t;
 
typedef enum
{
    VMAP_TYPE_PRIVATE = MMAP_PRIVATE, // there will be distinct copies of the memory region in the child process
    VMAP_TYPE_SHARED = MMAP_SHARED,   // the memory region will be shared between the parent and child processes
} vmap_type_t;
 
typedef struct
{
    bool is_present, is_write, is_user, is_exec;
    ptr_t ip;                       
    const platform_regs_t *regs;    
    phyframe_t *faulting_page;      
    const phyframe_t *backing_page; 
} pagefault_t;
 
typedef enum
{
    VMFAULT_COMPLETE,             
    VMFAULT_MAP_BACKING_PAGE_RO,  
    VMFAULT_MAP_BACKING_PAGE,     
    VMFAULT_COPY_BACKING_PAGE,    
    VMFAULT_CANNOT_HANDLE = 0xff, 
} vmfault_result_t;
 
struct vmap_t;
 
typedef vmfault_result_t (*vmfault_handler_t)(vmap_t *vmap, ptr_t fault_addr, pagefault_t *info);
 
struct vmap_t : mos::NamedType<"VMap">
{
    as_linked_list;
    spinlock_t lock;
 
    ptr_t vaddr; // virtual addresses
    size_t npages;
    VMFlags vmflags; // the expected flags for the region, regardless of the copy-on-write state
    MMContext *mmctx;
 
    IO *io;          // the io object that (possibly) backs this vmap
    off_t io_offset; // the offset in the io object, page-aligned
 
    vmap_content_t content;
    vmap_type_t type;
    vmap_stat_t stat;
    vmfault_handler_t on_fault;
 
    friend mos::SyslogStreamWriter operator<<(mos::SyslogStreamWriter stream, const vmap_t *vmap)
    {
        return stream << fmt("\\{ [{} - {}] }", (void *) vmap->vaddr, (void *) (vmap->vaddr + vmap->npages * MOS_PAGE_SIZE - 1));
    }
};
 
#define pfn_va(pfn)        ((ptr_t) (platform_info->direct_map_base + (pfn) * (MOS_PAGE_SIZE)))
#define va_pfn(va)         ((((ptr_t) (va)) - platform_info->direct_map_base) / MOS_PAGE_SIZE)
#define va_phyframe(va)    (&phyframes[va_pfn(va)])
#define phyframe_va(frame) ((ptr_t) pfn_va(phyframe_pfn(frame)))
#define pa_va(pa)          ((ptr_t) (pa) + platform_info->direct_map_base)
 
phyframe_t *mm_get_free_page(void);
phyframe_t *mm_get_free_page_raw(void);
phyframe_t *mm_get_free_pages(size_t npages);
 
#define mm_free_page(frame)          pmm_free_frames(frame, 1)
#define mm_free_pages(frame, npages) pmm_free_frames(frame, npages)

MMContext *mm_create_context(void);

void mm_destroy_context(MMContext *table);

void mm_lock_context_pair(MMContext *ctx1, MMContext *ctx2 = nullptr);
void mm_unlock_context_pair(MMContext *ctx1, MMContext *ctx2 = nullptr);
 
__nodiscard MMContext *mm_switch_context(MMContext *new_ctx);

vmap_t *vmap_create(MMContext *mmctx, ptr_t vaddr, size_t npages);

void vmap_destroy(vmap_t *vmap);

vmap_t *vmap_obtain(MMContext *mmctx, ptr_t vaddr, size_t *out_offset = nullptr);

vmap_t *vmap_split(vmap_t *vmap, size_t split);

vmap_t *vmap_split_for_range(vmap_t *vmap, size_t rstart_pgoff, size_t rend_pgoff);

void vmap_finalise_init(vmap_t *vmap, vmap_content_t content, vmap_type_t type);

[[nodiscard("resolve completed")]] vmfault_result_t mm_resolve_cow_fault(vmap_t *vmap, ptr_t fault_addr, pagefault_t *info);

void mm_handle_fault(ptr_t fault_addr, pagefault_t *info);