vm.h

 
#ifndef KERNEL_VM_H
#define KERNEL_VM_H
 
#include <kernel/error.h>
#include <kernel/spinlock.h>
 
#include <libalgo/linked_list.h>
#include <utils/bits.h>
 
struct vmm;
 
/* We should not be modifying another process's address_space */
#define AS_ASSERT_OWNED(_as) \
    WARN_ON((_as) != &kernel_address_space && (_as) != current->process->as);
 
struct address_space {
    // TODO: replace this lock with a R/W one.
    spinlock_t lock;   
    struct vmm *vmm;   
    paddr_t mmu;       
    llist_t *segments; 
    vaddr_t data_end;  
    vaddr_t brk_end;   
};
 
typedef enum vm_flags {
    VM_NONE = 0,
    VM_EXEC = BIT(0),   
    VM_READ = BIT(1),   
    VM_WRITE = BIT(2),  
    VM_KERNEL = BIT(3), 
    VM_CLEAR = BIT(4),  
    VM_FIXED = BIT(5),  
    /* Caching policies. */
    VM_CACHE_UC = BIT(6), 
    VM_CACHE_WC = BIT(7), 
    VM_CACHE_WT = BIT(8), 
    VM_CACHE_WB = BIT(9), 
} vm_flags_t;
 
#define VM_KERNEL_RO (VM_KERNEL | VM_READ)
#define VM_KERNEL_WO (VM_KERNEL | VM_WRITE)
#define VM_KERNEL_RW (VM_KERNEL | VM_READ | VM_WRITE)
 
#define VM_USER_RO (VM_READ)
#define VM_USER_WO (VM_WRITE)
#define VM_USER_RW (VM_READ | VM_WRITE)
 
/*
 * Memory-mapped I/O should be mapped as uncacheable since writes/read can
 * have side-effects and should not be combined or delayed.
 */
#define VM_IOMEM (VM_KERNEL_RW | VM_CACHE_UC)
 
#define VM_CACHE_MASK (VM_CACHE_UC | VM_CACHE_WT | VM_CACHE_WB | VM_CACHE_WC)
 
struct vm_segment_driver {
 
    struct vm_segment *(*vm_alloc)(struct address_space *, vaddr_t, size_t,
                                   vm_flags_t);
 
    struct vm_segment *(*vm_alloc_at)(struct address_space *, paddr_t, size_t,
                                      vm_flags_t);
 
    void (*vm_free)(struct address_space *, struct vm_segment *);
 
    error_t (*vm_resize)(struct address_space *, struct vm_segment *, size_t);
 
    error_t (*vm_fault)(struct address_space *, struct vm_segment *);
 
    error_t (*vm_map)(struct address_space *, struct vm_segment *, vm_flags_t);
 
    error_t (*vm_set_policy)(struct address_space *, struct vm_segment *,
                             vm_flags_t policy);
};
 
extern struct address_space kernel_address_space;
 
struct vm_segment {
    node_t this;   
    vaddr_t start; 
    size_t size;   
    u32 flags;     
    const struct vm_segment_driver *driver; 
};
 
static inline vaddr_t segment_end(const struct vm_segment *segment)
{
    return segment->start + segment->size;
}
 
struct address_space *address_space_new(void);
 
error_t address_space_init(struct address_space *);
 
error_t address_space_clear(struct address_space *);
 
error_t address_space_destroy(struct address_space *);
 
error_t address_space_copy_current(struct address_space *);
 
error_t address_space_load(struct address_space *);
 
error_t address_space_fault(struct address_space *, void *, bool is_cow);
 
void *vm_alloc(struct address_space *, size_t, vm_flags_t);
 
void *vm_alloc_start(struct address_space *, void *, size_t, vm_flags_t);
 
void *vm_alloc_at(struct address_space *, paddr_t, size_t, vm_flags_t);
 
void vm_free(struct address_space *, void *);
 
struct vm_segment *vm_find(const struct address_space *, void *);
 
error_t vm_map(struct address_space *, void *);
 
error_t vm_set_policy(struct address_space *, void *, vm_flags_t policy);
 
#endif /* KERNEL_VM_H */