vmm.h

 
#ifndef KERNEL_VMM_H
#define KERNEL_VMM_H
 
#include <kernel/memory.h>
#include <kernel/spinlock.h>
#include <kernel/types.h>
#include <kernel/vm.h>
 
#include <libalgo/avl.h>
#include <libalgo/bitmap.h>
#include <libalgo/linked_list.h>
#include <utils/compiler.h>
#include <utils/container_of.h>
 
#include <stdbool.h>
#include <stddef.h>
 
struct file;
 
typedef struct vma {
 
    struct vm_segment segment; 
    bool allocated; 
    struct vma_avl {
        struct avl by_address; 
        struct avl by_size;    
    } avl;
 
} vma_t;
 
/* For simplicity, we will allocate 64B for each VMA structure */
#define VMA_SIZE (64)
static_assert(sizeof(vma_t) <= VMA_SIZE, "Update the allocated size for VMA "
                                         "structures!");
 
static inline struct vma *to_vma(struct vm_segment *segment)
{
    return container_of(segment, struct vma, segment);
}
 
static inline vaddr_t vma_end(const vma_t *vma)
{
    return segment_end(&vma->segment);
}
 
static inline vaddr_t vma_start(const vma_t *vma)
{
    return vma->segment.start;
}
 
static inline size_t vma_size(const vma_t *vma)
{
    return vma->segment.size;
}
 
static inline u32 vma_flags(const vma_t *vma)
{
    return vma->segment.flags;
}
 
typedef struct vmm {
 
    vaddr_t start; 
    vaddr_t end;   
    struct address_space *as;
 
    struct vmm_vma_roots {
        avl_t *by_address;
        avl_t *by_size;
    } vmas;
 
    spinlock_t lock; 
    BITMAP(reserved, VMM_RESERVED_SIZE / VMA_SIZE);
 
} vmm_t;
 
#define MMAP_INVALID NULL
 
extern vmm_t kernel_vmm;
 
#define IS_KERNEL_ADDRESS(_addr) ((vaddr_t)(_addr) >= KERNEL_MEMORY_START)
 
/* Allocate a new VMM structure */
struct vmm *vmm_new(struct address_space *);
 
bool vmm_init(vmm_t *vmm, vaddr_t start, vaddr_t end);
 
void vmm_copy(vmm_t *dst, vmm_t *src);
 
struct vm_segment *vmm_allocate(vmm_t *, vaddr_t, size_t size, int flags);
 
void vmm_free(vmm_t *, vaddr_t, size_t length);
 
error_t vmm_resize(vmm_t *, vma_t *, size_t);
 
struct vm_segment *vmm_find(const vmm_t *, vaddr_t);
 
void vmm_clear(vmm_t *vmm);
 
void vmm_destroy(vmm_t *vmm);
 
void *map_file(struct file *file, int prot);
 
error_t unmap_file(struct file *file, void *addr);
 
#endif /* KERNEL_VMM_H */