From 239c267ed32801e12e1bb0568fa81afffe638aa5 Mon Sep 17 00:00:00 2001 From: Matheus Date: Wed, 1 Jul 2026 14:57:05 -0300 Subject: [PATCH] mm: rename vmm api to mm --- kernel-src/arch/x86-64/apic.c | 6 +- kernel-src/arch/x86-64/cpu.c | 2 +- kernel-src/arch/x86-64/hpet.c | 4 +- kernel-src/arch/x86-64/kvmclock.c | 2 +- kernel-src/arch/x86-64/ldt.c | 6 +- kernel-src/arch/x86-64/mmu.c | 18 +-- kernel-src/arch/x86-64/smp.c | 2 +- kernel-src/fs/ext2.c | 2 +- kernel-src/fs/initrd.c | 2 +- kernel-src/fs/pipefs.c | 2 +- kernel-src/fs/sockfs.c | 2 +- kernel-src/fs/tmpfs.c | 4 +- kernel-src/include/kernel/mm.h | 105 +++++++++++- kernel-src/include/kernel/proc.h | 2 +- kernel-src/include/kernel/thread.h | 4 +- kernel-src/include/kernel/vmm.h | 96 ----------- kernel-src/include/x86-64/arch/cpu.h | 10 +- kernel-src/include/x86-64/arch/pci.h | 2 +- kernel-src/io/acpi/glue.c | 4 +- kernel-src/io/block/block.c | 18 +-- kernel-src/io/block/nvme.c | 2 +- kernel-src/io/fb.c | 10 +- kernel-src/io/iovec.c | 4 +- kernel-src/io/pci.c | 4 +- kernel-src/io/term.c | 2 +- kernel-src/io/usb/ctrl/xhci.c | 2 +- kernel-src/io/usb/ctrl/xhci_xfer.c | 6 +- kernel-src/mm/cache.c | 3 +- kernel-src/mm/{vmm.c => mm.c} | 230 +++++++++++++-------------- kernel-src/mm/range.c | 115 +++++++------- kernel-src/mm/slab.c | 22 +-- kernel-src/sys/elf.c | 20 +-- kernel-src/sys/proc.c | 10 +- kernel-src/sys/scheduler/scheduler.c | 10 +- kernel-src/sys/syscalls/clockget.c | 2 +- kernel-src/sys/syscalls/execve.c | 20 +-- kernel-src/sys/syscalls/fork.c | 4 +- kernel-src/sys/syscalls/futex.c | 4 +- kernel-src/sys/syscalls/getdent.c | 2 +- kernel-src/sys/syscalls/mmap.c | 18 +-- kernel-src/sys/syscalls/mount.c | 2 +- kernel-src/sys/syscalls/mprotect.c | 4 +- kernel-src/sys/syscalls/munmap.c | 4 +- kernel-src/sys/syscalls/newthread.c | 2 +- kernel-src/sys/syscalls/poll.c | 2 +- kernel-src/sys/syscalls/sleep.c | 2 +- kernel-src/sys/thread.c | 16 +- 47 files changed, 402 insertions(+), 413 deletions(-) delete mode 100644 kernel-src/include/kernel/vmm.h rename kernel-src/mm/{vmm.c => mm.c} (61%) diff --git a/kernel-src/arch/x86-64/apic.c b/kernel-src/arch/x86-64/apic.c index 3a54c97f..fd170835 100644 --- a/kernel-src/arch/x86-64/apic.c +++ b/kernel-src/arch/x86-64/apic.c @@ -1,5 +1,5 @@ #include -#include +#include #include #include #include @@ -274,7 +274,7 @@ void arch_apic_init() { void *paddr = (void *) rdmsr(MSR_IA32APICBASE); - lapic_address = vmm_map(NULL, PAGE_SIZE, VMM_FLAGS_PHYSICAL, ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_WRITE | ARCH_MMU_FLAGS_NOEXEC, paddr); + lapic_address = mm_map(NULL, PAGE_SIZE, MM_RANGE_FLAGS_PHYSICAL, ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_WRITE | ARCH_MMU_FLAGS_NOEXEC, paddr); __assert(lapic_address); // map I/O apics to memory @@ -286,7 +286,7 @@ void arch_apic_init() { struct acpi_madt_ioapic *entry = getentry(ACPI_MADT_ENTRY_TYPE_IOAPIC, i); __assert((entry->address % PAGE_SIZE) == 0); - ioapics[i].addr = vmm_map(NULL, PAGE_SIZE, VMM_FLAGS_PHYSICAL, ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_WRITE | ARCH_MMU_FLAGS_NOEXEC, (void *)(uint64_t)entry->address); + ioapics[i].addr = mm_map(NULL, PAGE_SIZE, MM_RANGE_FLAGS_PHYSICAL, ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_WRITE | ARCH_MMU_FLAGS_NOEXEC, (void *)(uint64_t)entry->address); __assert(ioapics[i].addr); ioapics[i].base = entry->gsi_base; ioapics[i].top = ioapics[i].base + ((readioapic(ioapics[i].addr, IOAPIC_REG_ENTRY_COUNT) >> 16) & 0xff) + 1; diff --git a/kernel-src/arch/x86-64/cpu.c b/kernel-src/arch/x86-64/cpu.c index 34670acb..814aabb5 100644 --- a/kernel-src/arch/x86-64/cpu.c +++ b/kernel-src/arch/x86-64/cpu.c @@ -349,7 +349,7 @@ void arch_cpu_init() { current_cpu()->topology_node = topology_nodes[topology_depth - 1]; // allocate ists - uint64_t *ist1 = vmm_map(NULL, PAGE_SIZE * 4, VMM_FLAGS_ALLOCATE, ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_WRITE | ARCH_MMU_FLAGS_NOEXEC, NULL); + uint64_t *ist1 = mm_map(NULL, PAGE_SIZE * 4, MM_RANGE_FLAGS_ALLOCATE, ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_WRITE | ARCH_MMU_FLAGS_NOEXEC, NULL); __assert(ist1); // the cpu automatically aligns to 16 bytes when pushing the interrupt frame, so save ourselves the trouble: diff --git a/kernel-src/arch/x86-64/hpet.c b/kernel-src/arch/x86-64/hpet.c index de97cd48..6df90e8f 100644 --- a/kernel-src/arch/x86-64/hpet.c +++ b/kernel-src/arch/x86-64/hpet.c @@ -1,7 +1,7 @@ #include #include #include -#include +#include #include #include #include @@ -103,7 +103,7 @@ static timekeeper_source_info_t *hpet_init(void) { __assert(table->address.address_space_id == ACPI_AS_ID_SYS_MEM); uint64_t page_offset = table->address.address % PAGE_SIZE; - hpet_private.hpet = vmm_map(NULL, (PAGE_SIZE + page_offset), VMM_FLAGS_PHYSICAL, ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_WRITE | ARCH_MMU_FLAGS_NOEXEC, (void *)(table->address.address - page_offset)); + hpet_private.hpet = mm_map(NULL, (PAGE_SIZE + page_offset), MM_RANGE_FLAGS_PHYSICAL, ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_WRITE | ARCH_MMU_FLAGS_NOEXEC, (void *)(table->address.address - page_offset)); __assert(hpet_private.hpet); hpet_private.hpet = (void *)((uintptr_t)hpet_private.hpet + page_offset); diff --git a/kernel-src/arch/x86-64/kvmclock.c b/kernel-src/arch/x86-64/kvmclock.c index 48794d88..848eb0a9 100644 --- a/kernel-src/arch/x86-64/kvmclock.c +++ b/kernel-src/arch/x86-64/kvmclock.c @@ -56,7 +56,7 @@ static timekeeper_source_info_t *kvm_timer_init(void) { int page_offset = (uintptr_t)virtual_address % PAGE_SIZE; void *virtual_page = (void *)((uintptr_t)virtual_address - page_offset); - void *physical_page = vmm_getphysical(virtual_page, 0); + void *physical_page = mm_get_physical_address(virtual_page, 0); __assert(physical_page); timekeeper_source_info->private = (void *)((uintptr_t)physical_page + page_offset); diff --git a/kernel-src/arch/x86-64/ldt.c b/kernel-src/arch/x86-64/ldt.c index 2d1d1a68..e075cb0a 100644 --- a/kernel-src/arch/x86-64/ldt.c +++ b/kernel-src/arch/x86-64/ldt.c @@ -75,10 +75,10 @@ int arch_ldt_set_entry(unsigned int which, ldt_entry_t entry) { done = 0; for (int i = 0; i < arch_smp_cpusawake; ++i) { - // reading the vmm context like this is racey but there are no ill side effects other than spurious shootdowns - // if a cpu changes to this vmmctx, they will already have done a ldt invalidation. + // reading the mm context like this is racey but there are no ill side effects other than spurious shootdowns + // if a cpu changes to this mmctx, they will already have done a ldt invalidation. // if it changes out of it, same thing - if (smp_cpus[i] == current_cpu() || (smp_cpus[i]->vmmctx != current_thread()->vmmctx)) + if (smp_cpus[i] == current_cpu() || (smp_cpus[i]->mmctx != current_thread()->mmctx)) continue; ++shootdown_total; diff --git a/kernel-src/arch/x86-64/mmu.c b/kernel-src/arch/x86-64/mmu.c index 9babb4d0..777949fe 100644 --- a/kernel-src/arch/x86-64/mmu.c +++ b/kernel-src/arch/x86-64/mmu.c @@ -4,7 +4,7 @@ #include #include #include -#include +#include #include #include #include @@ -264,10 +264,10 @@ void arch_mmu_invalidate_range(void *page, size_t size) { old_ipl = interrupt_raiseipl(IPL_DPC); for (int i = 0; i < arch_smp_cpusawake; ++i) { - // reading the vmm context like this is racey but there are no ill side effects other than spurious shootdowns - // if a cpu changes to this vmmctx, they will already have done a tlb invalidation. + // reading the mm context like this is racey but there are no ill side effects other than spurious shootdowns + // if a cpu changes to this mmctx, they will already have done a tlb invalidation. // if it changes out of it, same thing - if (smp_cpus[i] == current_cpu() || (user_shootdown && smp_cpus[i]->vmmctx != current_thread()->vmmctx)) + if (smp_cpus[i] == current_cpu() || (user_shootdown && smp_cpus[i]->mmctx != current_thread()->mmctx)) continue; spinlock_acquire(&smp_cpus[i]->shootdown_lock); @@ -339,16 +339,16 @@ static void pfisr(isr_t *self, context_t *ctx) { arch_cpu_user_access_end(); interrupt_set(true); - int vmmerror = 0; + int mm_error = 0; - vmmerror |= VMM_ACTION_READ; // valid x86 PTEs will always have read permission (present) and actions will always have a read because of that. + mm_error |= MM_FAULT_ACTION_READ; // valid x86 PTEs will always have read permission (present) and actions will always have a read because of that. if (ctx->error & ERROR_WRITE) - vmmerror |= VMM_ACTION_WRITE; + mm_error |= MM_FAULT_ACTION_WRITE; if (ctx->error & ERROR_FETCH) - vmmerror |= VMM_ACTION_EXEC; + mm_error |= MM_FAULT_ACTION_EXEC; - if (vmm_pagefault((void *)ctx->cr2, ctx->cs != 8, vmmerror) == false) { + if (mm_handle_page_fault((void *)ctx->cr2, ctx->cs != 8, mm_error) == false) { if (thread && thread->usercopyctx) { memcpy(ctx, thread->usercopyctx, sizeof(context_t)); ctx->rflags &= ~ARCH_CONTEXT_RFLAGS_AC; diff --git a/kernel-src/arch/x86-64/smp.c b/kernel-src/arch/x86-64/smp.c index dccc0e82..b1bb1c52 100644 --- a/kernel-src/arch/x86-64/smp.c +++ b/kernel-src/arch/x86-64/smp.c @@ -39,7 +39,7 @@ static void cpuwakeup(struct limine_mp_info *info) { dpc_init(); arch_extracontext_detect(); arch_mmu_apswitch(); - vmm_apinit(); + mm_apinit(); arch_apic_initap(); diff --git a/kernel-src/fs/ext2.c b/kernel-src/fs/ext2.c index e275a2df..177833e9 100644 --- a/kernel-src/fs/ext2.c +++ b/kernel-src/fs/ext2.c @@ -2,7 +2,7 @@ #include #include #include -#include +#include #include #include #include diff --git a/kernel-src/fs/initrd.c b/kernel-src/fs/initrd.c index 4d9afc5c..af788605 100644 --- a/kernel-src/fs/initrd.c +++ b/kernel-src/fs/initrd.c @@ -3,7 +3,7 @@ #include #include #include -#include +#include #include #include #include diff --git a/kernel-src/fs/pipefs.c b/kernel-src/fs/pipefs.c index 8f6eb3cf..f87e16a1 100644 --- a/kernel-src/fs/pipefs.c +++ b/kernel-src/fs/pipefs.c @@ -3,7 +3,7 @@ #include #include #include -#include +#include #include #include #include diff --git a/kernel-src/fs/sockfs.c b/kernel-src/fs/sockfs.c index 439cc727..ede220e5 100644 --- a/kernel-src/fs/sockfs.c +++ b/kernel-src/fs/sockfs.c @@ -2,7 +2,7 @@ #include #include #include -#include +#include #include #include #include diff --git a/kernel-src/fs/tmpfs.c b/kernel-src/fs/tmpfs.c index 4b7941c7..043c7c01 100644 --- a/kernel-src/fs/tmpfs.c +++ b/kernel-src/fs/tmpfs.c @@ -4,12 +4,12 @@ #include #include #include -#include +#include #include #include #include #include -#include +#include #include #include #include diff --git a/kernel-src/include/kernel/mm.h b/kernel-src/include/kernel/mm.h index a55f32f0..145c29e9 100644 --- a/kernel-src/include/kernel/mm.h +++ b/kernel-src/include/kernel/mm.h @@ -1,9 +1,98 @@ #ifndef _MM_H #define _MM_H +#include +#include #include #include -#include +#include + +#define MM_RANGE_FLAGS_PAGESIZE 1 +#define MM_RANGE_FLAGS_ALLOCATE 2 +#define MM_RANGE_FLAGS_PHYSICAL 4 +#define MM_RANGE_FLAGS_FILE 8 +#define MM_RANGE_FLAGS_EXACT 16 +#define MM_RANGE_FLAGS_SHARED 32 +#define MM_RANGE_FLAGS_REPLACE 64 +#define MM_RANGE_FLAGS_CREDCHECK 128 + +#define MM_PERMANENT_RANGE_FLAGS_MASK (MM_RANGE_FLAGS_FILE | MM_RANGE_FLAGS_SHARED | MM_RANGE_FLAGS_PHYSICAL) + +#define MM_FAULT_ACTION_READ 1 +#define MM_FAULT_ACTION_WRITE 2 +#define MM_FAULT_ACTION_EXEC 4 + +typedef struct { + vnode_t *node; + uintmax_t offset; +} mm_map_file_desc_t; + +typedef struct mm_range_t{ + rbtree_t rbtree_node; + void *start; + size_t size; + int flags; + mmuflags_t mmuflags; + union { + struct { + vnode_t *vnode; + size_t offset; + }; + }; +} mm_range_t; + +typedef struct { + mutex_t lock; + rbtree_t *ranges; + void *start; + void *end; +} mm_space_t; + +typedef struct { + mm_space_t space; + pagetableptr_t pagetable; +} mm_context_t; + +extern mm_context_t mm_kernel_ctx; + +static inline mmuflags_t mm_vnode_flags_to_mmu_flags(int flags) { + mmuflags_t mmuflags = ARCH_MMU_FLAGS_USER; + if (flags & V_FFLAGS_READ) + mmuflags |= ARCH_MMU_FLAGS_READ; + if (flags & V_FFLAGS_WRITE) + mmuflags |= ARCH_MMU_FLAGS_WRITE; + if ((flags & V_FFLAGS_EXEC) == 0) + mmuflags |= ARCH_MMU_FLAGS_NOEXEC; + + return mmuflags; +} + +static inline int mm_mmu_flags_to_vnode_flags(mmuflags_t mmuflags) { + int flags = 0; + if (mmuflags & ARCH_MMU_FLAGS_READ) + flags |= V_FFLAGS_READ; + if (mmuflags & ARCH_MMU_FLAGS_WRITE) + flags |= V_FFLAGS_WRITE; + if ((mmuflags & ARCH_MMU_FLAGS_NOEXEC) == 0) + flags |= V_FFLAGS_EXEC; + + return flags; +} + +int mm_change_mmu_flags(void *base, size_t size, mmuflags_t mmuflags, int flags); +void mm_destroy_context(mm_context_t *context); +mm_context_t *mm_fork_context(mm_context_t *oldcontext); +void *mm_map(void *addr, size_t size, int flags, mmuflags_t mmuflags, void *private); +void mm_unmap(void *addr, size_t size, int flags); +bool mm_handle_page_fault(void *addr, bool user, int actions); +mm_context_t *mm_create_context(); +void mm_switch_context(mm_context_t *ctx); + +#define MM_GET_PHYSICAL_ADDRESS_FLAGS_HOLD 1 +#define MM_GET_PHYSICAL_ADDRESS_FLAGS_LOCK 2 +void *mm_get_physical_address(void *addr, int flags); +void mm_apinit(); +void mm_init(); extern size_t mm_cache_cached_pages; @@ -18,12 +107,12 @@ int mm_cache_sync(void); int mm_cache_evict(page_t *page); void mm_range_init(void); -vmmrange_t *mm_alloc_range(void); -void mm_free_range(vmmrange_t *range); -vmmrange_t *mm_get_range(vmmspace_t *space, void *addr); -void *mm_get_free_range(vmmspace_t *space, void *addr, size_t size); -void mm_insert_range(vmmspace_t *space, vmmrange_t *new_range); -void mm_destroy_range(vmmrange_t *range, uintmax_t offset, size_t size, int flags); -int mm_change_range(vmmspace_t *space, void *address, size_t size, bool free, int flags, mmuflags_t new_mmuflags); +mm_range_t *mm_alloc_range(void); +void mm_free_range(mm_range_t *range); +mm_range_t *mm_get_range(mm_space_t *space, void *addr); +void *mm_get_free_range(mm_space_t *space, void *addr, size_t size); +void mm_insert_range(mm_space_t *space, mm_range_t *new_range); +void mm_destroy_range(mm_range_t *range, uintmax_t offset, size_t size, int flags); +int mm_change_range(mm_space_t *space, void *address, size_t size, bool free, int flags, mmuflags_t new_mmuflags); #endif diff --git a/kernel-src/include/kernel/proc.h b/kernel-src/include/kernel/proc.h index 2f38f60f..aae73e0e 100644 --- a/kernel-src/include/kernel/proc.h +++ b/kernel-src/include/kernel/proc.h @@ -2,7 +2,7 @@ #define _PROC_H #include -#include +#include #include #include #include diff --git a/kernel-src/include/kernel/thread.h b/kernel-src/include/kernel/thread.h index ef452510..5cd362cd 100644 --- a/kernel-src/include/kernel/thread.h +++ b/kernel-src/include/kernel/thread.h @@ -2,7 +2,7 @@ #define _THREAD_H #include -#include +#include #include #include #include @@ -35,7 +35,7 @@ typedef struct thread_t { extracontext_t extracontext; void *kernelstack; size_t kernelstacksize; - vmmcontext_t *vmmctx; + mm_context_t *mmctx; tid_t tid; int flags; bool sleepintstatus; diff --git a/kernel-src/include/kernel/vmm.h b/kernel-src/include/kernel/vmm.h deleted file mode 100644 index 2fb3e312..00000000 --- a/kernel-src/include/kernel/vmm.h +++ /dev/null @@ -1,96 +0,0 @@ -#ifndef _VMM_H -#define _VMM_H - -#include -#include -#include -#include - -#define VMM_FLAGS_PAGESIZE 1 -#define VMM_FLAGS_ALLOCATE 2 -#define VMM_FLAGS_PHYSICAL 4 -#define VMM_FLAGS_FILE 8 -#define VMM_FLAGS_EXACT 16 -#define VMM_FLAGS_SHARED 32 -#define VMM_FLAGS_REPLACE 64 -#define VMM_FLAGS_CREDCHECK 128 - -#define VMM_PERMANENT_FLAGS_MASK (VMM_FLAGS_FILE | VMM_FLAGS_SHARED | VMM_FLAGS_PHYSICAL) - -#define VMM_ACTION_READ 1 -#define VMM_ACTION_WRITE 2 -#define VMM_ACTION_EXEC 4 - -typedef struct { - vnode_t *node; - uintmax_t offset; -} vmmfiledesc_t; - -typedef struct vmmrange_t{ - rbtree_t rbtree_node; - void *start; - size_t size; - int flags; - mmuflags_t mmuflags; - union { - struct { - vnode_t *vnode; - size_t offset; - }; - }; -} vmmrange_t; - -typedef struct { - mutex_t lock; - rbtree_t *ranges; - void *start; - void *end; -} vmmspace_t; - -typedef struct { - vmmspace_t space; - pagetableptr_t pagetable; -} vmmcontext_t; - -extern vmmcontext_t vmm_kernelctx; - -static inline mmuflags_t vnodeflagstommuflags(int flags) { - mmuflags_t mmuflags = ARCH_MMU_FLAGS_USER; - if (flags & V_FFLAGS_READ) - mmuflags |= ARCH_MMU_FLAGS_READ; - if (flags & V_FFLAGS_WRITE) - mmuflags |= ARCH_MMU_FLAGS_WRITE; - if ((flags & V_FFLAGS_EXEC) == 0) - mmuflags |= ARCH_MMU_FLAGS_NOEXEC; - - return mmuflags; -} - -static inline int mmuflagstovnodeflags(mmuflags_t mmuflags) { - int flags = 0; - if (mmuflags & ARCH_MMU_FLAGS_READ) - flags |= V_FFLAGS_READ; - if (mmuflags & ARCH_MMU_FLAGS_WRITE) - flags |= V_FFLAGS_WRITE; - if ((mmuflags & ARCH_MMU_FLAGS_NOEXEC) == 0) - flags |= V_FFLAGS_EXEC; - - return flags; -} - -int vmm_changemmuflags(void *base, size_t size, mmuflags_t mmuflags, int flags); -void vmm_destroycontext(vmmcontext_t *context); -vmmcontext_t *vmm_fork(vmmcontext_t *oldcontext); -void *vmm_map(void *addr, size_t size, int flags, mmuflags_t mmuflags, void *private); -void vmm_unmap(void *addr, size_t size, int flags); -bool vmm_pagefault(void *addr, bool user, int actions); -vmmcontext_t *vmm_newcontext(); -void vmm_switchcontext(vmmcontext_t *ctx); - -#define VMM_GET_PHYSICAL_FLAGS_HOLD 1 -#define VMM_GET_PHYSICAL_FLAGS_LOCK 2 -void *vmm_getphysical(void *addr, int flags); -void vmm_apinit(); -void vmm_init(); - -#endif diff --git a/kernel-src/include/x86-64/arch/cpu.h b/kernel-src/include/x86-64/arch/cpu.h index 3f239c2a..e02162b5 100644 --- a/kernel-src/include/x86-64/arch/cpu.h +++ b/kernel-src/include/x86-64/arch/cpu.h @@ -7,7 +7,7 @@ #include #include #include -#include +#include #include #include #include @@ -23,7 +23,7 @@ typedef struct cpu_t { struct cpu_t *self; // expected to be here by other code - vmmcontext_t *vmmctx; // expected to be here by other code + mm_context_t *mmctx; // expected to be here by other code long hardware_id; // expected to be here by other code long internal_id; // expected to be here by other code @@ -131,13 +131,13 @@ static inline cpu_t *current_cpu(void) { return cpu; } -static inline vmmcontext_t *current_vmm_context(void) { - vmmcontext_t *context; +static inline mm_context_t *current_mm_context(void) { + mm_context_t *context; asm volatile ("mov %%gs:16, %%rax" : "=a"(context) : : "memory"); return context; } -static inline void set_current_vmm_context(vmmcontext_t *context) { +static inline void set_current_mm_context(mm_context_t *context) { asm volatile ("mov %%rax, %%gs:16" : : "a"(context) : "memory"); } diff --git a/kernel-src/include/x86-64/arch/pci.h b/kernel-src/include/x86-64/arch/pci.h index 6185e056..0a3280af 100644 --- a/kernel-src/include/x86-64/arch/pci.h +++ b/kernel-src/include/x86-64/arch/pci.h @@ -96,7 +96,7 @@ static void pci_archinit() { void *phys = (void *)mcfgentries[i].address; uintmax_t pageoffset = (uintptr_t)phys % PAGE_SIZE; size_t mappingsize = pageoffset + MCFG_MAPPING_SIZE(mcfgentries[i].end_bus - mcfgentries[i].start_bus + 1); - void *virt = vmm_map(NULL, mappingsize, VMM_FLAGS_PHYSICAL, + void *virt = mm_map(NULL, mappingsize, MM_RANGE_FLAGS_PHYSICAL, ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_WRITE | ARCH_MMU_FLAGS_NOEXEC | ARCH_MMU_FLAGS_UC, phys); __assert(virt); mcfgentries[i].address = (uintptr_t)virt + pageoffset; diff --git a/kernel-src/io/acpi/glue.c b/kernel-src/io/acpi/glue.c index 8fe20b3a..5497898a 100644 --- a/kernel-src/io/acpi/glue.c +++ b/kernel-src/io/acpi/glue.c @@ -62,7 +62,7 @@ void uacpi_kernel_free(void *ptr) { void *uacpi_kernel_map(uacpi_phys_addr physical, uacpi_size length) { uintmax_t pageoffset = (uintptr_t)physical % PAGE_SIZE; - void *virt = vmm_map(NULL, ROUND_UP(length + pageoffset, PAGE_SIZE), VMM_FLAGS_PHYSICAL, + void *virt = mm_map(NULL, ROUND_UP(length + pageoffset, PAGE_SIZE), MM_RANGE_FLAGS_PHYSICAL, ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_WRITE | ARCH_MMU_FLAGS_NOEXEC, (void*)ROUND_DOWN(physical, PAGE_SIZE)); @@ -74,7 +74,7 @@ void uacpi_kernel_unmap(void *ptr, uacpi_size length) { uintmax_t pageoffset = (uintptr_t)ptr % PAGE_SIZE; uintptr_t addr = (uintptr_t)ptr; - vmm_unmap((void*)ROUND_DOWN(addr, PAGE_SIZE), ROUND_UP(length + pageoffset, PAGE_SIZE), 0); + mm_unmap((void*)ROUND_DOWN(addr, PAGE_SIZE), ROUND_UP(length + pageoffset, PAGE_SIZE), 0); } uacpi_status uacpi_kernel_raw_memory_read(uacpi_phys_addr address, uacpi_u8 width, uacpi_u64 *out) { diff --git a/kernel-src/io/block/block.c b/kernel-src/io/block/block.c index 7063ec94..41b8ea40 100644 --- a/kernel-src/io/block/block.c +++ b/kernel-src/io/block/block.c @@ -5,7 +5,7 @@ #include #include #include -#include +#include #include #define DISK_READ(desc, it, lba, size) (desc)->read(desc->private, it, lba, size) @@ -200,7 +200,7 @@ static int registerdesc(blockdesc_t *desc, char *name) { static int detectpart(blockdesc_t *desc) { // read first two sectors - void *sects = vmm_map(NULL, desc->blocksize * 2, VMM_FLAGS_ALLOCATE, MAP_FLAGS, NULL); + void *sects = mm_map(NULL, desc->blocksize * 2, MM_RANGE_FLAGS_ALLOCATE, MAP_FLAGS, NULL); __assert(sects); __assert(disk_read_direct(desc, sects, 0, 2) == 0); @@ -216,7 +216,7 @@ static int detectpart(blockdesc_t *desc) { else if (bootmagic == MBR_BOOT_MAGIC) ret = PART_MBR; - vmm_unmap(sects, desc->blocksize * 2, 0); + mm_unmap(sects, desc->blocksize * 2, 0); return ret; } @@ -241,7 +241,7 @@ static bool gptentryvalid(blockdesc_t *desc, gptheader_t *header, gptentry_t *en static void dogpt(blockdesc_t *desc, char *name) { // get header - void *lba1 = vmm_map(NULL, desc->blocksize, VMM_FLAGS_ALLOCATE, MAP_FLAGS, NULL); + void *lba1 = mm_map(NULL, desc->blocksize, MM_RANGE_FLAGS_ALLOCATE, MAP_FLAGS, NULL); __assert(lba1); __assert(disk_read_direct(desc, lba1, 1, 1) == 0); gptheader_t *header = lba1; @@ -249,7 +249,7 @@ static void dogpt(blockdesc_t *desc, char *name) { // get partition table size_t tablebytesize = header->entrybytesize * header->entrycount; size_t tablelbasize = ROUND_UP(tablebytesize, desc->blocksize) / desc->blocksize; - void *tablebuffer = vmm_map(NULL, tablelbasize * desc->blocksize, VMM_FLAGS_ALLOCATE, MAP_FLAGS, NULL); + void *tablebuffer = mm_map(NULL, tablelbasize * desc->blocksize, MM_RANGE_FLAGS_ALLOCATE, MAP_FLAGS, NULL); __assert(tablebuffer); __assert(disk_read_direct(desc, tablebuffer, header->entryarraylbastart, tablelbasize) == 0); @@ -277,13 +277,13 @@ static void dogpt(blockdesc_t *desc, char *name) { __assert(registerdesc(partdesc, partname) == 0); } - vmm_unmap(tablebuffer, tablelbasize * desc->blocksize, 0); - vmm_unmap(lba1, desc->blocksize, 0); + mm_unmap(tablebuffer, tablelbasize * desc->blocksize, 0); + mm_unmap(lba1, desc->blocksize, 0); } static void dombr(blockdesc_t *desc, char *name) { // get entries - void *lba0 = vmm_map(NULL, desc->blocksize, VMM_FLAGS_ALLOCATE, MAP_FLAGS, NULL); + void *lba0 = mm_map(NULL, desc->blocksize, MM_RANGE_FLAGS_ALLOCATE, MAP_FLAGS, NULL); __assert(lba0); __assert(disk_read_direct(desc, lba0, 0, 1) == 0); mbrentry_t *mbrents = (mbrentry_t *)((uintptr_t)lba0 + MBR_ENTRIES_OFFSET); @@ -310,7 +310,7 @@ static void dombr(blockdesc_t *desc, char *name) { __assert(registerdesc(partdesc, partname) == 0); } - vmm_unmap(lba0, desc->blocksize, 0); + mm_unmap(lba0, desc->blocksize, 0); } void block_register(blockdesc_t *desc, char *name) { diff --git a/kernel-src/io/block/nvme.c b/kernel-src/io/block/nvme.c index 62ed6c1f..ce2762b7 100644 --- a/kernel-src/io/block/nvme.c +++ b/kernel-src/io/block/nvme.c @@ -1,6 +1,6 @@ #include #include -#include +#include #include #include #include diff --git a/kernel-src/io/fb.c b/kernel-src/io/fb.c index 05dc290f..c0ce5dae 100644 --- a/kernel-src/io/fb.c +++ b/kernel-src/io/fb.c @@ -144,7 +144,7 @@ static int mmap(int minor, void *addr, uintmax_t offset, int flags) { if (flags & V_FFLAGS_SHARED) { // make sure offset is ALWAYS page aligned when doing a shared mapping __assert((offset % PAGE_SIZE) == 0); - return arch_mmu_map(current_vmm_context()->pagetable, FROM_HHDM((void *)((uintptr_t)fbs[minor]->address + offset)), addr, vnodeflagstommuflags(flags)) ? 0 : ENOMEM; + return arch_mmu_map(current_mm_context()->pagetable, FROM_HHDM((void *)((uintptr_t)fbs[minor]->address + offset)), addr, mm_vnode_flags_to_mmu_flags(flags)) ? 0 : ENOMEM; } else { size_t size = offset + PAGE_SIZE < end ? PAGE_SIZE : end - offset; paddr = mm_alloc_page(MEMORY_SECTION_DEFAULT); @@ -153,7 +153,7 @@ static int mmap(int minor, void *addr, uintmax_t offset, int flags) { memcpy(MAKE_HHDM(paddr), (void *)((uintptr_t)fbs[minor]->address + offset), size); - if (arch_mmu_map(current_vmm_context()->pagetable, paddr, addr, vnodeflagstommuflags(flags) | ARCH_MMU_FLAGS_WC) == false) { + if (arch_mmu_map(current_mm_context()->pagetable, paddr, addr, mm_vnode_flags_to_mmu_flags(flags) | ARCH_MMU_FLAGS_WC) == false) { mm_release_page(paddr); return ENOMEM; } @@ -163,9 +163,9 @@ static int mmap(int minor, void *addr, uintmax_t offset, int flags) { } static int munmap(int minor, void *addr, uintmax_t offset, int flags) { - void *phys = arch_mmu_getphysical(current_vmm_context()->pagetable, addr); - bool release = (flags & V_FFLAGS_SHARED) && arch_mmu_iswritable(current_vmm_context()->pagetable, addr); - arch_mmu_unmap(current_vmm_context()->pagetable, addr); + void *phys = arch_mmu_getphysical(current_mm_context()->pagetable, addr); + bool release = (flags & V_FFLAGS_SHARED) && arch_mmu_iswritable(current_mm_context()->pagetable, addr); + arch_mmu_unmap(current_mm_context()->pagetable, addr); arch_mmu_invalidate_range(addr, PAGE_SIZE); if (release) mm_release_page(phys); diff --git a/kernel-src/io/iovec.c b/kernel-src/io/iovec.c index c0f5e52c..b7dc9c66 100644 --- a/kernel-src/io/iovec.c +++ b/kernel-src/io/iovec.c @@ -1,5 +1,5 @@ #include -#include +#include #include static inline bool iovec_iterator_finished(iovec_iterator_t *iovec_iterator) { @@ -246,7 +246,7 @@ int iovec_iterator_next_page(iovec_iterator_t *iovec_iterator, size_t *page_offs return 0; } - void *phys = vmm_getphysical((void *)((uintptr_t)addr - offset_in_page), VMM_GET_PHYSICAL_FLAGS_HOLD | VMM_GET_PHYSICAL_FLAGS_LOCK); + void *phys = mm_get_physical_address((void *)((uintptr_t)addr - offset_in_page), MM_GET_PHYSICAL_ADDRESS_FLAGS_HOLD | MM_GET_PHYSICAL_ADDRESS_FLAGS_LOCK); if (phys == NULL) return EFAULT; diff --git a/kernel-src/io/pci.c b/kernel-src/io/pci.c index 4be9c75f..cc17bef0 100644 --- a/kernel-src/io/pci.c +++ b/kernel-src/io/pci.c @@ -2,7 +2,7 @@ #include #include #include -#include +#include #include uint8_t pci_read8(int bus, int device, int function, uint32_t offset) { @@ -185,7 +185,7 @@ void pci_msisetmask(pcienum_t *e, int vector, int value) { void *pci_mapbar(pcibar_t bar) { __assert(bar.mmio); - return vmm_map(NULL, bar.length, VMM_FLAGS_PHYSICAL, BAR_MAP_FLAGS | (bar.prefetchable ? ARCH_MMU_FLAGS_WT : ARCH_MMU_FLAGS_UC), (void *)bar.address); + return mm_map(NULL, bar.length, MM_RANGE_FLAGS_PHYSICAL, BAR_MAP_FLAGS | (bar.prefetchable ? ARCH_MMU_FLAGS_WT : ARCH_MMU_FLAGS_UC), (void *)bar.address); } #define BAR_IO 1 diff --git a/kernel-src/io/term.c b/kernel-src/io/term.c index ff9de592..8a145a2c 100644 --- a/kernel-src/io/term.c +++ b/kernel-src/io/term.c @@ -102,4 +102,4 @@ void term_init() { logging_sethook(term_putchar); } -INIT_ROUTINE_DEFINE(term, INIT_ROUTINE_FLAGS_NONE, term_init, vmm); +INIT_ROUTINE_DEFINE(term, INIT_ROUTINE_FLAGS_NONE, term_init, mm); diff --git a/kernel-src/io/usb/ctrl/xhci.c b/kernel-src/io/usb/ctrl/xhci.c index adb59394..13774dc3 100644 --- a/kernel-src/io/usb/ctrl/xhci.c +++ b/kernel-src/io/usb/ctrl/xhci.c @@ -6,7 +6,7 @@ #include #include #include -#include +#include #include #include #include diff --git a/kernel-src/io/usb/ctrl/xhci_xfer.c b/kernel-src/io/usb/ctrl/xhci_xfer.c index 6d09515f..f2f92642 100644 --- a/kernel-src/io/usb/ctrl/xhci_xfer.c +++ b/kernel-src/io/usb/ctrl/xhci_xfer.c @@ -1,7 +1,7 @@ #include #include #include -#include +#include #include #include @@ -70,7 +70,7 @@ int xhci_data_xfer(xhci_ctrl_t *xhci, xhci_device_t *dev, usb_xfer_t *xfer, xhci // This should never be called with user pages. Doing so is a bug. For user-fronting code, use // the scatter-gather variant __assert(!IS_USER_ADDRESS(xfer->data)); - void *page = vmm_getphysical(xfer->data - page_offset, VMM_GET_PHYSICAL_FLAGS_HOLD); + void *page = mm_get_physical_address(xfer->data - page_offset, MM_GET_PHYSICAL_ADDRESS_FLAGS_HOLD); __assert(page != NULL); trb.parameters = (uint64_t)page + page_offset; } @@ -242,7 +242,7 @@ int xhci_control_xfer(xhci_ctrl_t *xhci, xhci_device_t *dev, usb_xfer_t *xfer, x mm_hold_page(xfer->data - page_offset); data_trb.parameters = (uint64_t)xfer->data; } else { - void *page = vmm_getphysical(xfer->data - page_offset, VMM_GET_PHYSICAL_FLAGS_HOLD); + void *page = mm_get_physical_address(xfer->data - page_offset, MM_GET_PHYSICAL_ADDRESS_FLAGS_HOLD); if (page == NULL) { xhci_ring_unreserve(ring, trb_count); return EFAULT; diff --git a/kernel-src/mm/cache.c b/kernel-src/mm/cache.c index 11355e69..53f5bdba 100644 --- a/kernel-src/mm/cache.c +++ b/kernel-src/mm/cache.c @@ -1,5 +1,4 @@ #include -#include #include #include #include @@ -487,7 +486,7 @@ static void writer() { void mm_cache_init(void) { MUTEX_INIT(&mutex); - table = vmm_map(NULL, TABLE_SIZE * sizeof(page_t *), VMM_FLAGS_ALLOCATE, ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_WRITE | ARCH_MMU_FLAGS_NOEXEC, NULL); + table = mm_map(NULL, TABLE_SIZE * sizeof(page_t *), MM_RANGE_FLAGS_ALLOCATE, ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_WRITE | ARCH_MMU_FLAGS_NOEXEC, NULL); __assert(table); memset(table, 0, TABLE_SIZE * sizeof(page_t *)); diff --git a/kernel-src/mm/vmm.c b/kernel-src/mm/mm.c similarity index 61% rename from kernel-src/mm/vmm.c rename to kernel-src/mm/mm.c index 62a409d7..643c4cfc 100644 --- a/kernel-src/mm/vmm.c +++ b/kernel-src/mm/mm.c @@ -1,4 +1,4 @@ -#include +#include #include #include #include @@ -6,29 +6,28 @@ #include #include #include -#include #include // ranges are separated into kernel and user. the kernel has a temporary user context -vmmcontext_t vmm_kernelctx; -static vmmspace_t kernelspace = { +mm_context_t mm_kernel_ctx; +static mm_space_t kernelspace = { .start = KERNELSPACE_START, .end = KERNELSPACE_END }; // returns a pointer to the space of vaddr -static vmmspace_t *getspace(void *vaddr) { +static mm_space_t *getspace(void *vaddr) { if (USERSPACE_START <= vaddr && vaddr < USERSPACE_END) - return ¤t_vmm_context()->space; + return ¤t_mm_context()->space; else if (KERNELSPACE_START <= vaddr && vaddr < KERNELSPACE_END) return &kernelspace; else return NULL; } -static int vmm_range_compare(rbtree_t *a, rbtree_t *b) { - vmmrange_t *range_a = container_of(a, vmmrange_t, rbtree_node); - vmmrange_t *range_b = container_of(b, vmmrange_t, rbtree_node); +static int mm_range_compare(rbtree_t *a, rbtree_t *b) { + mm_range_t *range_a = container_of(a, mm_range_t, rbtree_node); + mm_range_t *range_b = container_of(b, mm_range_t, rbtree_node); if (range_a->start == range_b->start) return 0; @@ -36,10 +35,10 @@ static int vmm_range_compare(rbtree_t *a, rbtree_t *b) { return range_a->start > range_b->start ? 1 : -1; } -int vmm_changemmuflags(void *base, size_t size, mmuflags_t mmuflags, int flags) { +int mm_change_mmu_flags(void *base, size_t size, mmuflags_t mmuflags, int flags) { base = (void *)ROUND_DOWN((uintptr_t)base, PAGE_SIZE); - if (flags & VMM_FLAGS_PAGESIZE) + if (flags & MM_RANGE_FLAGS_PAGESIZE) size *= PAGE_SIZE; else size = ROUND_UP(size, PAGE_SIZE); @@ -47,7 +46,7 @@ int vmm_changemmuflags(void *base, size_t size, mmuflags_t mmuflags, int flags) if (size == 0) return 0; - vmmspace_t *space = getspace(base); + mm_space_t *space = getspace(base); if (space == NULL) return ENOMEM; @@ -63,40 +62,40 @@ int vmm_changemmuflags(void *base, size_t size, mmuflags_t mmuflags, int flags) return error; } -static void printspace(vmmspace_t *space) { - printf("vmm: ranges:\n"); +static void printspace(mm_space_t *space) { + printf("mm: ranges:\n"); rbtree_t *rbtree = rbtree_first(space->ranges); while (rbtree) { - vmmrange_t *range = container_of(rbtree, vmmrange_t, rbtree_node); - printf("vmm: address %p size %lx flags %x\n", range->start, range->size, range->flags); + mm_range_t *range = container_of(rbtree, mm_range_t, rbtree_node); + printf("mm: address %p size %lx flags %x\n", range->start, range->size, range->flags); rbtree = rbtree_successor(rbtree); } } static void *zeropage; -bool vmm_pagefault(void *addr, bool user, int actions) { +bool mm_handle_page_fault(void *addr, bool user, int actions) { if (user == false && addr > USERSPACE_END) { - printf("vmm: kernel access\n"); + printf("mm: kernel access\n"); return false; } addr = (void *)ROUND_DOWN((uintptr_t)addr, PAGE_SIZE); - vmmspace_t *space = getspace(addr); + mm_space_t *space = getspace(addr); if (space == NULL || (space == &kernelspace && user)) { - printf("vmm: no such space or space accessed is kerneç\n"); + printf("mm: no such space or space accessed is kernel\n"); return false; } MUTEX_ACQUIRE(&space->lock); - vmmrange_t *range = mm_get_range(space, addr); + mm_range_t *range = mm_get_range(space, addr); bool status = false; if (range == NULL) { - printf("vmm: no range\n"); + printf("mm: no range\n"); goto cleanup; } @@ -105,16 +104,16 @@ bool vmm_pagefault(void *addr, bool user, int actions) { int invalidactions = 0; if ((range->mmuflags & ARCH_MMU_FLAGS_READ) == 0) - invalidactions |= VMM_ACTION_READ; + invalidactions |= MM_FAULT_ACTION_READ; if ((range->mmuflags & ARCH_MMU_FLAGS_WRITE) == 0) - invalidactions |= VMM_ACTION_WRITE; + invalidactions |= MM_FAULT_ACTION_WRITE; if ((range->mmuflags & ARCH_MMU_FLAGS_NOEXEC)) - invalidactions |= VMM_ACTION_EXEC; + invalidactions |= MM_FAULT_ACTION_EXEC; if (invalidactions & actions) { - printf("vmm: bad action\n"); + printf("mm: bad action\n"); goto cleanup; } @@ -122,14 +121,14 @@ bool vmm_pagefault(void *addr, bool user, int actions) { proc_t *proc = thread ? thread->proc : NULL; cred_t *cred = proc ? &proc->cred : NULL; - if (arch_mmu_ispresent(current_vmm_context()->pagetable, addr) == false) { + if (arch_mmu_ispresent(current_mm_context()->pagetable, addr) == false) { // page not present in the page tables - if (range->flags & VMM_FLAGS_FILE) { + if (range->flags & MM_RANGE_FLAGS_FILE) { uintmax_t mapoffset = (uintptr_t)addr - (uintptr_t)range->start; if (vfs_iscacheable(range->vnode) == false) { // map non cacheable vnodes VOP_LOCK(range->vnode); - __assert(VOP_MMAP(range->vnode, addr, range->offset + mapoffset, mmuflagstovnodeflags(range->mmuflags) | (range->flags & VMM_FLAGS_SHARED ? V_FFLAGS_SHARED : 0), cred) == 0); + __assert(VOP_MMAP(range->vnode, addr, range->offset + mapoffset, mm_mmu_flags_to_vnode_flags(range->mmuflags) | (range->flags & MM_RANGE_FLAGS_SHARED ? V_FFLAGS_SHARED : 0), cred) == 0); VOP_UNLOCK(range->vnode); status = true; } else { @@ -139,17 +138,17 @@ bool vmm_pagefault(void *addr, bool user, int actions) { if (error == ENXIO || error == ENOMEM) { if (error == ENOMEM) - printf("vmm: out of memory to handle getpage (sending SIGBUS)\n"); + printf("mm: out of memory to handle getpage (sending SIGBUS)\n"); // address is past the last page of the file signal_signalthread(current_thread(), SIGBUS, true); status = true; } else if (error) { - printf("vmm: error on mm_cache_get_page(): %d\n", error); + printf("mm: error on mm_cache_get_page(): %d\n", error); status = false; } else { - status = arch_mmu_map(current_vmm_context()->pagetable, mm_get_page_address(res), addr, range->mmuflags & ~ARCH_MMU_FLAGS_WRITE); + status = arch_mmu_map(current_mm_context()->pagetable, mm_get_page_address(res), addr, range->mmuflags & ~ARCH_MMU_FLAGS_WRITE); if (!status) { - printf("vmm: out of memory to map file into address space (sending SIGBUS)\n"); + printf("mm: out of memory to map file into address space (sending SIGBUS)\n"); mm_release_page(mm_get_page_address(res)); signal_signalthread(current_thread(), SIGBUS, true); status = true; @@ -163,39 +162,39 @@ bool vmm_pagefault(void *addr, bool user, int actions) { // writeable range: allocate a new page, zero it and map it void *new_page = mm_alloc_page(MEMORY_SECTION_DEFAULT); if (new_page == NULL) { - printf("vmm: out of memory to allocate page to satisfy anonymous page-in (sending SIGBUS)\n"); + printf("mm: out of memory to allocate page to satisfy anonymous page-in (sending SIGBUS)\n"); signal_signalthread(current_thread(), SIGBUS, true); goto cleanup; } memset(MAKE_HHDM(new_page), 0, PAGE_SIZE); - if (!arch_mmu_map(current_vmm_context()->pagetable, new_page, addr, range->mmuflags)) { - printf("vmm: out of memory to map page (sending SIGBUS)\n"); + if (!arch_mmu_map(current_mm_context()->pagetable, new_page, addr, range->mmuflags)) { + printf("mm: out of memory to map page (sending SIGBUS)\n"); signal_signalthread(current_thread(), SIGBUS, true); mm_release_page(new_page); } } else { // read-only range: map a shared zero page - if (!arch_mmu_map(current_vmm_context()->pagetable, zeropage, addr, range->mmuflags)) { - printf("vmm: out of memory to map zero page into address space (sending SIGBUS)\n"); + if (!arch_mmu_map(current_mm_context()->pagetable, zeropage, addr, range->mmuflags)) { + printf("mm: out of memory to map zero page into address space (sending SIGBUS)\n"); signal_signalthread(current_thread(), SIGBUS, true); } else { mm_hold_page(zeropage); } } } - } else if (arch_mmu_iswritable(current_vmm_context()->pagetable, addr) == false) { + } else if (arch_mmu_iswritable(current_mm_context()->pagetable, addr) == false) { // page present but not writeable in the page tables - void *oldphys = arch_mmu_getphysical(current_vmm_context()->pagetable, addr); + void *oldphys = arch_mmu_getphysical(current_mm_context()->pagetable, addr); page_t *oldpage = mm_get_page(oldphys); - if ( ((range->flags & VMM_FLAGS_FILE) && (range->flags & VMM_FLAGS_SHARED)) || - ((range->flags & VMM_FLAGS_FILE) == 0 && oldpage->refcount == 1)) { + if ( ((range->flags & MM_RANGE_FLAGS_FILE) && (range->flags & MM_RANGE_FLAGS_SHARED)) || + ((range->flags & MM_RANGE_FLAGS_FILE) == 0 && oldpage->refcount == 1)) { // shared file or anon with refcount == 1, remap it as writable - arch_mmu_remap(current_vmm_context()->pagetable, oldphys, addr, range->mmuflags); - if ((range->flags & VMM_FLAGS_FILE) && vfs_iscacheable(range->vnode)) { + arch_mmu_remap(current_mm_context()->pagetable, oldphys, addr, range->mmuflags); + if ((range->flags & MM_RANGE_FLAGS_FILE) && vfs_iscacheable(range->vnode)) { // and if its a cache page, mark it as dirty VOP_LOCK(range->vnode); mm_cache_make_dirty(mm_get_page(oldphys)); @@ -207,14 +206,14 @@ bool vmm_pagefault(void *addr, bool user, int actions) { // do copy on write void *newphys = mm_alloc_page(MEMORY_SECTION_DEFAULT); if (newphys == NULL) { - printf("vmm: out of memory to do copy on write on address space (sending SIGBUS)\n"); + printf("mm: out of memory to do copy on write on address space (sending SIGBUS)\n"); signal_signalthread(current_thread(), SIGBUS, true); status = true; } else { memcpy(MAKE_HHDM(newphys), MAKE_HHDM(oldphys), PAGE_SIZE); - arch_mmu_remap(current_vmm_context()->pagetable, newphys, addr, range->mmuflags); + arch_mmu_remap(current_mm_context()->pagetable, newphys, addr, range->mmuflags); arch_mmu_invalidate_range(addr, PAGE_SIZE); - if ((range->flags & VMM_FLAGS_FILE) == 0 || vfs_iscacheable(range->vnode)) + if ((range->flags & MM_RANGE_FLAGS_FILE) == 0 || vfs_iscacheable(range->vnode)) mm_release_page(oldphys); status = true; @@ -231,16 +230,16 @@ bool vmm_pagefault(void *addr, bool user, int actions) { } /* -static int lock_page(vmmspace_t *space, void *vaddr) { - vmmrange_t *range = mm_get_range(space, vaddr); +static int lock_page(mm_space_t *space, void *vaddr) { + mm_range_t *range = mm_get_range(space, vaddr); if (!range) return ENOENT; - void *mapped_address = arch_mmu_getphysical(current_vmm_context()->pagetable, vaddr); - bool present = arch_mmu_ispresent(current_vmm_context()->pagetable, vaddr); - bool writable = arch_mmu_iswritable(current_vmm_context()->pagetable, vaddr); - bool file_mapping = range->flags & VMM_FLAGS_FILE; - bool private = (range->flags & VMM_FLAGS_SHARED) == 0 || file_mapping == false; + void *mapped_address = arch_mmu_getphysical(current_mm_context()->pagetable, vaddr); + bool present = arch_mmu_ispresent(current_mm_context()->pagetable, vaddr); + bool writable = arch_mmu_iswritable(current_mm_context()->pagetable, vaddr); + bool file_mapping = range->flags & MM_RANGE_FLAGS_FILE; + bool private = (range->flags & MM_RANGE_FLAGS_SHARED) == 0 || file_mapping == false; void *real_phys; // TODO anon with refcount == 1 can go into another cas @@ -254,7 +253,7 @@ static int lock_page(vmmspace_t *space, void *vaddr) { memcpy(MAKE_HHDM(real_phys), MAKE_HHDM(mapped_address), PAGE_SIZE); - arch_mmu_remap(current_vmm_context()->pagetable, real_phys, vaddr, range->mmuflags); + arch_mmu_remap(current_mm_context()->pagetable, real_phys, vaddr, range->mmuflags); arch_mmu_invalidate_range(vaddr, PAGE_SIZE); if (file_mapping == false || vfs_iscacheable(range->vnode)) mm_release_page(mapped_address); @@ -266,10 +265,10 @@ static int lock_page(vmmspace_t *space, void *vaddr) { } */ -void *vmm_getphysical(void *addr, int flags) { +void *mm_get_physical_address(void *addr, int flags) { void *aligned_addr = (void *)ROUND_DOWN((uintptr_t)addr, PAGE_SIZE); - vmmspace_t *space = getspace(aligned_addr); + mm_space_t *space = getspace(aligned_addr); if (space == NULL) return NULL; @@ -277,29 +276,28 @@ void *vmm_getphysical(void *addr, int flags) { void *physical; /* - if ((flags & VMM_GET_PHYSICAL_FLAGS_LOCK) && lock_page(space, aligned_addrr)) { + if ((flags & MM_GET_PHYSICAL_ADDRESS_FLAGS_LOCK) && lock_page(space, aligned_addrr)) { physical = NULL; goto leave; }*/ - physical = arch_mmu_getphysical(current_vmm_context()->pagetable, aligned_addr); + physical = arch_mmu_getphysical(current_mm_context()->pagetable, aligned_addr); - if (flags & VMM_GET_PHYSICAL_FLAGS_HOLD) + if (flags & MM_GET_PHYSICAL_ADDRESS_FLAGS_HOLD) mm_hold_page(physical); - leave: MUTEX_RELEASE(&space->lock); return physical + ((uintptr_t)addr - (uintptr_t)aligned_addr); } -void *vmm_map(void *addr, volatile size_t size, int flags, mmuflags_t mmuflags, void *private) { +void *mm_map(void *addr, volatile size_t size, int flags, mmuflags_t mmuflags, void *private) { if (addr == NULL) addr = KERNELSPACE_START; // XXX maps where addr is not page aligned can break addr = (void *)ROUND_DOWN((uintptr_t)addr, PAGE_SIZE); - if (flags & VMM_FLAGS_PAGESIZE) + if (flags & MM_RANGE_FLAGS_PAGESIZE) size *= PAGE_SIZE; else size = ROUND_UP(size, PAGE_SIZE); @@ -307,7 +305,7 @@ void *vmm_map(void *addr, volatile size_t size, int flags, mmuflags_t mmuflags, if (size == 0) return NULL; - vmmspace_t *space = getspace(addr); + mm_space_t *space = getspace(addr); if (space == NULL) return NULL; @@ -315,25 +313,25 @@ void *vmm_map(void *addr, volatile size_t size, int flags, mmuflags_t mmuflags, mmuflags |= ARCH_MMU_FLAGS_GLOBAL; MUTEX_ACQUIRE(&space->lock); - vmmrange_t *range = NULL; + mm_range_t *range = NULL; void *start = mm_get_free_range(space, addr, size); void *retaddr = NULL; - if (((flags & VMM_FLAGS_EXACT) && start != addr) || start == NULL) + if (((flags & MM_RANGE_FLAGS_EXACT) && start != addr) || start == NULL) goto cleanup; range = mm_alloc_range(); if (range == NULL) goto cleanup; - if (flags & VMM_FLAGS_REPLACE) { + if (flags & MM_RANGE_FLAGS_REPLACE) { __assert(addr); retaddr = addr; range->start = addr; range->size = size; - range->flags = VMM_PERMANENT_FLAGS_MASK & flags; + range->flags = MM_PERMANENT_RANGE_FLAGS_MASK & flags; range->mmuflags = mmuflags; - __assert((flags & (VMM_FLAGS_ALLOCATE | VMM_FLAGS_PHYSICAL)) == 0); + __assert((flags & (MM_RANGE_FLAGS_ALLOCATE | MM_RANGE_FLAGS_PHYSICAL)) == 0); // make the memory inacessible mm_change_range(space, addr, size, false, flags, 0); arch_mmu_invalidate_range(addr, size); @@ -343,25 +341,25 @@ void *vmm_map(void *addr, volatile size_t size, int flags, mmuflags_t mmuflags, retaddr = start; range->start = start; range->size = size; - range->flags = VMM_PERMANENT_FLAGS_MASK & flags; + range->flags = MM_PERMANENT_RANGE_FLAGS_MASK & flags; range->mmuflags = mmuflags; } - if (flags & VMM_FLAGS_FILE) { + if (flags & MM_RANGE_FLAGS_FILE) { // XXX make sure that writes can't happen to executable memory mapped files and check file permissions - vmmfiledesc_t *desc = private; + mm_map_file_desc_t *desc = private; __assert((desc->offset % PAGE_SIZE) == 0); range->vnode = desc->node; range->offset = desc->offset; VOP_HOLD(desc->node); } - if (flags & VMM_FLAGS_PHYSICAL) { + if (flags & MM_RANGE_FLAGS_PHYSICAL) { // map to allocated virtual memory for (uintmax_t i = 0; i < size; i += PAGE_SIZE) { - if (arch_mmu_map(current_vmm_context()->pagetable, (void *)((uintptr_t)private + i), (void *)((uintptr_t)start + i), mmuflags) == false) { + if (arch_mmu_map(current_mm_context()->pagetable, (void *)((uintptr_t)private + i), (void *)((uintptr_t)start + i), mmuflags) == false) { for (uintmax_t j = 0; j < size; j += PAGE_SIZE) - arch_mmu_unmap(current_vmm_context()->pagetable, (void *)((uintptr_t)start + j)); + arch_mmu_unmap(current_mm_context()->pagetable, (void *)((uintptr_t)start + j)); // invalidate here just to be sure arch_mmu_invalidate_range(start, size); @@ -369,7 +367,7 @@ void *vmm_map(void *addr, volatile size_t size, int flags, mmuflags_t mmuflags, goto cleanup; } } - } else if (flags & VMM_FLAGS_ALLOCATE) { + } else if (flags & MM_RANGE_FLAGS_ALLOCATE) { // allocate to virtual memory for (uintmax_t i = 0; i < size; i += PAGE_SIZE) { void *allocated = mm_alloc_page(MEMORY_SECTION_DEFAULT); @@ -378,14 +376,14 @@ void *vmm_map(void *addr, volatile size_t size, int flags, mmuflags_t mmuflags, goto cleanup; } - if (arch_mmu_map(current_vmm_context()->pagetable, allocated, (void *)((uintptr_t)start + i), mmuflags) == false) { + if (arch_mmu_map(current_mm_context()->pagetable, allocated, (void *)((uintptr_t)start + i), mmuflags) == false) { for (uintmax_t j = 0; j < size; j += PAGE_SIZE) { void *virt = (void *)((uintptr_t)start + i); - void *physical = arch_mmu_getphysical(current_vmm_context()->pagetable, virt); + void *physical = arch_mmu_getphysical(current_mm_context()->pagetable, virt); if (physical) { mm_release_page(physical); - arch_mmu_unmap(current_vmm_context()->pagetable, virt); + arch_mmu_unmap(current_mm_context()->pagetable, virt); } } @@ -407,10 +405,10 @@ void *vmm_map(void *addr, volatile size_t size, int flags, mmuflags_t mmuflags, return retaddr; } -void vmm_unmap(void *addr, size_t size, int flags) { +void mm_unmap(void *addr, size_t size, int flags) { addr = (void *)ROUND_DOWN((uintptr_t)addr, PAGE_SIZE); - if (flags & VMM_FLAGS_PAGESIZE) + if (flags & MM_RANGE_FLAGS_PAGESIZE) size *= PAGE_SIZE; else size = ROUND_UP(size, PAGE_SIZE); @@ -418,7 +416,7 @@ void vmm_unmap(void *addr, size_t size, int flags) { if (size == 0) return; - vmmspace_t *space = getspace(addr); + mm_space_t *space = getspace(addr); if (space == NULL) return; @@ -437,7 +435,7 @@ void vmm_unmap(void *addr, size_t size, int flags) { static scache_t *ctxcache; static bool ctxctor(scache_t *cache, void *obj) { - vmmcontext_t *ctx = obj; + mm_context_t *ctx = obj; ctx->space.start = USERSPACE_START; ctx->space.end = USERSPACE_END; MUTEX_INIT(&ctx->space.lock); @@ -445,13 +443,13 @@ static bool ctxctor(scache_t *cache, void *obj) { return true; } -vmmcontext_t *vmm_newcontext() { +mm_context_t *mm_create_context() { if (ctxcache == NULL) { - ctxcache = slab_newcache(sizeof(vmmcontext_t), 0, ctxctor, NULL); + ctxcache = slab_newcache(sizeof(mm_context_t), 0, ctxctor, NULL); __assert(ctxcache); } - vmmcontext_t *ctx = slab_allocate(ctxcache); + mm_context_t *ctx = slab_allocate(ctxcache); if (ctx == NULL) return NULL; @@ -464,19 +462,19 @@ vmmcontext_t *vmm_newcontext() { return ctx; } -void vmm_destroycontext(vmmcontext_t *context) { - vmmcontext_t *oldctx = current_thread()->vmmctx; - vmm_switchcontext(context); - vmm_unmap(context->space.start, context->space.end - context->space.start, 0); - vmm_switchcontext(oldctx); +void mm_destroy_context(mm_context_t *context) { + mm_context_t *oldctx = current_thread()->mmctx; + mm_switch_context(context); + mm_unmap(context->space.start, context->space.end - context->space.start, 0); + mm_switch_context(oldctx); arch_mmu_destroytable(context->pagetable); context->space.ranges = NULL; slab_free(ctxcache, context); } -vmmcontext_t *vmm_fork(vmmcontext_t *oldcontext) { - vmmcontext_t *newcontext = vmm_newcontext(); +mm_context_t *mm_fork_context(mm_context_t *oldcontext) { + mm_context_t *newcontext = mm_create_context(); if (newcontext == NULL) return NULL; @@ -484,15 +482,15 @@ vmmcontext_t *vmm_fork(vmmcontext_t *oldcontext) { rbtree_t *rbtree = oldcontext->space.ranges ? rbtree_first(oldcontext->space.ranges) : NULL; while (rbtree) { - vmmrange_t *range = container_of(rbtree, vmmrange_t, rbtree_node); - vmmrange_t *newrange = mm_alloc_range(); + mm_range_t *range = container_of(rbtree, mm_range_t, rbtree_node); + mm_range_t *newrange = mm_alloc_range(); if (newrange == NULL) goto error; - memcpy(newrange, range, sizeof(vmmrange_t)); + memcpy(newrange, range, sizeof(mm_range_t)); - rbtree_insert(&newcontext->space.ranges, &newrange->rbtree_node, vmm_range_compare); - if (range->flags & VMM_FLAGS_FILE) + rbtree_insert(&newcontext->space.ranges, &newrange->rbtree_node, mm_range_compare); + if (range->flags & MM_RANGE_FLAGS_FILE) VOP_HOLD(range->vnode); // copy any pages that are mapped @@ -522,14 +520,14 @@ vmmcontext_t *vmm_fork(vmmcontext_t *oldcontext) { return newcontext; error: MUTEX_RELEASE(&oldcontext->space.lock); - vmm_destroycontext(newcontext); + mm_destroy_context(newcontext); return NULL; } -void vmm_switchcontext(vmmcontext_t *ctx) { +void mm_switch_context(mm_context_t *ctx) { if (current_thread()) - current_thread()->vmmctx = ctx; - set_current_vmm_context(ctx); + current_thread()->mmctx = ctx; + set_current_mm_context(ctx); arch_mmu_switch(ctx->pagetable); } @@ -542,18 +540,18 @@ extern void *_rodata_end; extern volatile struct limine_memmap_request mm_page_limine_map; -void vmm_init() { +void mm_init() { // set up initial state mm_range_init(); MUTEX_INIT(&kernelspace.lock); - vmm_kernelctx.pagetable = arch_mmu_newtable(); - __assert(vmm_kernelctx.pagetable); + mm_kernel_ctx.pagetable = arch_mmu_newtable(); + __assert(mm_kernel_ctx.pagetable); - vmm_kernelctx.space.start = USERSPACE_START; - vmm_kernelctx.space.end = USERSPACE_END; + mm_kernel_ctx.space.start = USERSPACE_START; + mm_kernel_ctx.space.end = USERSPACE_END; - vmm_switchcontext(&vmm_kernelctx); + mm_switch_context(&mm_kernel_ctx); // map HHDM for (uint64_t i = 0; i < mm_page_limine_map.response->entry_count; ++i) { @@ -566,16 +564,16 @@ void vmm_init() { if (e->type == LIMINE_MEMMAP_FRAMEBUFFER) mmuflags |= ARCH_MMU_FLAGS_WC; - __assert(vmm_map(MAKE_HHDM(e->base), e->length, VMM_FLAGS_EXACT, mmuflags, NULL)); + __assert(mm_map(MAKE_HHDM(e->base), e->length, MM_RANGE_FLAGS_EXACT, mmuflags, NULL)); } // map kernel - __assert(vmm_map(&_text_start, (uintptr_t)&_text_end - (uintptr_t)&_text_start, VMM_FLAGS_EXACT, ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_GLOBAL, NULL)); - __assert(vmm_map(&_rodata_start, (uintptr_t)&_rodata_end - (uintptr_t)&_rodata_start, VMM_FLAGS_EXACT, ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_NOEXEC | ARCH_MMU_FLAGS_GLOBAL, NULL)); - __assert(vmm_map(&_data_start, (uintptr_t)&_data_end - (uintptr_t)&_data_start, VMM_FLAGS_EXACT, ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_WRITE | ARCH_MMU_FLAGS_NOEXEC | ARCH_MMU_FLAGS_GLOBAL, NULL)); + __assert(mm_map(&_text_start, (uintptr_t)&_text_end - (uintptr_t)&_text_start, MM_RANGE_FLAGS_EXACT, ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_GLOBAL, NULL)); + __assert(mm_map(&_rodata_start, (uintptr_t)&_rodata_end - (uintptr_t)&_rodata_start, MM_RANGE_FLAGS_EXACT, ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_NOEXEC | ARCH_MMU_FLAGS_GLOBAL, NULL)); + __assert(mm_map(&_data_start, (uintptr_t)&_data_end - (uintptr_t)&_data_start, MM_RANGE_FLAGS_EXACT, ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_WRITE | ARCH_MMU_FLAGS_NOEXEC | ARCH_MMU_FLAGS_GLOBAL, NULL)); // null page - vmm_map(MAKE_HHDM(NULL), PAGE_SIZE, VMM_FLAGS_EXACT, ARCH_MMU_FLAGS_NOEXEC, NULL); + mm_map(MAKE_HHDM(NULL), PAGE_SIZE, MM_RANGE_FLAGS_EXACT, ARCH_MMU_FLAGS_NOEXEC, NULL); // zero page zeropage = mm_alloc_page(MEMORY_SECTION_DEFAULT); @@ -584,8 +582,8 @@ void vmm_init() { printspace(&kernelspace); } -INIT_ROUTINE_DEFINE(vmm, INIT_ROUTINE_FLAGS_NONE, vmm_init, mmu, slab_early); +INIT_ROUTINE_DEFINE(mm, INIT_ROUTINE_FLAGS_NONE, mm_init, mmu, slab_early); -void vmm_apinit() { - vmm_switchcontext(&vmm_kernelctx); +void mm_apinit() { + mm_switch_context(&mm_kernel_ctx); } diff --git a/kernel-src/mm/range.c b/kernel-src/mm/range.c index 1bd8e258..93414034 100644 --- a/kernel-src/mm/range.c +++ b/kernel-src/mm/range.c @@ -1,30 +1,29 @@ -#include +#include #include #include #include #include #include -#include #define RANGE_TOP(x) (void *)((uintptr_t)x->start + x->size) static scache_t *range_cache; void mm_range_init(void) { - range_cache = slab_create_new_cache_from_pmm(sizeof(vmmrange_t), 0, NULL, NULL); + range_cache = slab_create_new_cache_from_pmm(sizeof(mm_range_t), 0, NULL, NULL); __assert(range_cache); } -vmmrange_t *mm_alloc_range(void) { +mm_range_t *mm_alloc_range(void) { return slab_allocate(range_cache); } -void mm_free_range(vmmrange_t *range) { +void mm_free_range(mm_range_t *range) { slab_free(range_cache, range); } static int rbtree_value_compare(void *addr, rbtree_t *node) { - vmmrange_t *range = container_of(node, vmmrange_t, rbtree_node); + mm_range_t *range = container_of(node, mm_range_t, rbtree_node); void *range_top = RANGE_TOP(range); if (addr >= range_top) @@ -37,13 +36,13 @@ static int rbtree_value_compare(void *addr, rbtree_t *node) { } // get a range from an address -vmmrange_t *mm_get_range(vmmspace_t *space, void *addr) { +mm_range_t *mm_get_range(mm_space_t *space, void *addr) { rbtree_t *rbtree = rbtree_lookup(space->ranges, addr, rbtree_value_compare); - return container_of(rbtree, vmmrange_t, rbtree_node); + return container_of(rbtree, mm_range_t, rbtree_node); } // get start of range that fits specific size from specific offset -void *mm_get_free_range(vmmspace_t *space, void *addr, size_t size) { +void *mm_get_free_range(mm_space_t *space, void *addr, size_t size) { rbtree_t *rbtree = space->ranges; if (addr == NULL) addr = space->start; @@ -53,7 +52,7 @@ void *mm_get_free_range(vmmspace_t *space, void *addr, size_t size) { return addr; rbtree = rbtree_first(rbtree); - vmmrange_t *range = container_of(rbtree, vmmrange_t, rbtree_node); + mm_range_t *range = container_of(rbtree, mm_range_t, rbtree_node); // if theres free space before the first range if (range->start != space->start && addr < range->start && (uintptr_t)range->start - (uintptr_t)addr >= size) @@ -62,7 +61,7 @@ void *mm_get_free_range(vmmspace_t *space, void *addr, size_t size) { // check for space between two ranges rbtree_t *next = rbtree_successor(rbtree); while (next) { - vmmrange_t *next_range = container_of(next, vmmrange_t, rbtree_node); + mm_range_t *next_range = container_of(next, mm_range_t, rbtree_node); void *range_top = RANGE_TOP(range); if (addr < range_top) @@ -75,7 +74,7 @@ void *mm_get_free_range(vmmspace_t *space, void *addr, size_t size) { } rbtree = next; - range = container_of(rbtree, vmmrange_t, rbtree_node); + range = container_of(rbtree, mm_range_t, rbtree_node); next = rbtree_successor(next); } @@ -92,8 +91,8 @@ void *mm_get_free_range(vmmspace_t *space, void *addr, size_t size) { } static int rbtree_compare(rbtree_t *a, rbtree_t *b) { - vmmrange_t *range_a = container_of(a, vmmrange_t, rbtree_node); - vmmrange_t *range_b = container_of(b, vmmrange_t, rbtree_node); + mm_range_t *range_a = container_of(a, mm_range_t, rbtree_node); + mm_range_t *range_b = container_of(b, mm_range_t, rbtree_node); if (range_a->start == range_b->start) return 0; @@ -101,21 +100,21 @@ static int rbtree_compare(rbtree_t *a, rbtree_t *b) { return range_a->start > range_b->start ? 1 : -1; } -static bool ranges_compatible(vmmrange_t *prev, vmmrange_t *next) { +static bool ranges_compatible(mm_range_t *prev, mm_range_t *next) { void *prev_range_top = RANGE_TOP(prev); return prev_range_top == next->start && prev->flags == next->flags && prev->mmuflags == next->mmuflags && // general compatibility - ((prev->flags & VMM_FLAGS_FILE) == 0 || (prev->vnode == next->vnode && prev->offset + prev->size == next->offset)); // same file mapping, if any + ((prev->flags & MM_RANGE_FLAGS_FILE) == 0 || (prev->vnode == next->vnode && prev->offset + prev->size == next->offset)); // same file mapping, if any } -void mm_insert_range(vmmspace_t *space, vmmrange_t *new_range) { +void mm_insert_range(mm_space_t *space, mm_range_t *new_range) { rbtree_insert(&space->ranges, &new_range->rbtree_node, rbtree_compare); rbtree_t *successor = rbtree_successor(&new_range->rbtree_node); rbtree_t *predecessor = rbtree_predecessor(&new_range->rbtree_node); - vmmrange_t *next_range = successor ? container_of(successor, vmmrange_t, rbtree_node) : NULL; - vmmrange_t *prev_range = predecessor ? container_of(predecessor, vmmrange_t, rbtree_node) : NULL; + mm_range_t *next_range = successor ? container_of(successor, mm_range_t, rbtree_node) : NULL; + mm_range_t *prev_range = predecessor ? container_of(predecessor, mm_range_t, rbtree_node) : NULL; // fragmentation checking @@ -125,7 +124,7 @@ void mm_insert_range(vmmspace_t *space, vmmrange_t *new_range) { rbtree_remove(&space->ranges, &next_range->rbtree_node); mm_free_range(next_range); - if (new_range->flags & VMM_FLAGS_FILE) { + if (new_range->flags & MM_RANGE_FLAGS_FILE) { VOP_RELEASE(new_range->vnode); } } @@ -136,19 +135,19 @@ void mm_insert_range(vmmspace_t *space, vmmrange_t *new_range) { rbtree_remove(&space->ranges, &new_range->rbtree_node); mm_free_range(new_range); - if (prev_range->flags & VMM_FLAGS_FILE) { + if (prev_range->flags & MM_RANGE_FLAGS_FILE) { VOP_RELEASE(prev_range->vnode); } } } -void mm_destroy_range(vmmrange_t *range, uintmax_t _offset, size_t size, int flags) { +void mm_destroy_range(mm_range_t *range, uintmax_t _offset, size_t size, int flags) { // TODO find first uintmax_t top = _offset + size; for (uintmax_t offset = _offset; offset < top; offset += PAGE_SIZE) { void *vaddr = (void *)((uintptr_t)range->start + offset); - void *physical = arch_mmu_getphysical(current_vmm_context()->pagetable, vaddr); + void *physical = arch_mmu_getphysical(current_mm_context()->pagetable, vaddr); if (physical == NULL) continue; @@ -156,34 +155,34 @@ void mm_destroy_range(vmmrange_t *range, uintmax_t _offset, size_t size, int fla proc_t *proc = thread ? thread->proc : NULL; cred_t *cred = proc ? &proc->cred : NULL; - if ((range->flags & VMM_FLAGS_FILE) && ((range->flags & VMM_FLAGS_SHARED) || vfs_iscacheable(range->vnode) == false)) { + if ((range->flags & MM_RANGE_FLAGS_FILE) && ((range->flags & MM_RANGE_FLAGS_SHARED) || vfs_iscacheable(range->vnode) == false)) { // shared file mapping or non cacheable mapping if (vfs_iscacheable(range->vnode) == false) { // non cacheable mapping VOP_LOCK(range->vnode); - __assert(VOP_MUNMAP(range->vnode, vaddr, range->offset + offset, mmuflagstovnodeflags(range->mmuflags) | (range->flags & VMM_FLAGS_SHARED ? V_FFLAGS_SHARED : 0), cred) == 0); + __assert(VOP_MUNMAP(range->vnode, vaddr, range->offset + offset, mm_mmu_flags_to_vnode_flags(range->mmuflags) | (range->flags & MM_RANGE_FLAGS_SHARED ? V_FFLAGS_SHARED : 0), cred) == 0); VOP_UNLOCK(range->vnode); - } else if (arch_mmu_iswritable(current_vmm_context()->pagetable, vaddr)) { + } else if (arch_mmu_iswritable(current_mm_context()->pagetable, vaddr)) { // dirty page cache mapping - arch_mmu_unmap(current_vmm_context()->pagetable, vaddr); + arch_mmu_unmap(current_mm_context()->pagetable, vaddr); VOP_LOCK(range->vnode); mm_cache_make_dirty(mm_get_page(physical)); VOP_UNLOCK(range->vnode); mm_release_page(physical); } else { // non dirty page mapping - arch_mmu_unmap(current_vmm_context()->pagetable, vaddr); + arch_mmu_unmap(current_mm_context()->pagetable, vaddr); mm_release_page(physical); } } else { // anonymous, physical or private non character device mapping - arch_mmu_unmap(current_vmm_context()->pagetable, vaddr); - if ((range->flags & VMM_FLAGS_PHYSICAL) == 0) + arch_mmu_unmap(current_mm_context()->pagetable, vaddr); + if ((range->flags & MM_RANGE_FLAGS_PHYSICAL) == 0) mm_release_page(physical); } } - if ((range->flags & VMM_FLAGS_FILE) && range->size == size) + if ((range->flags & MM_RANGE_FLAGS_FILE) && range->size == size) VOP_RELEASE(range->vnode); } @@ -191,16 +190,16 @@ void mm_destroy_range(vmmrange_t *range, uintmax_t _offset, size_t size, int fla if (((n) & (f)) == 0 && ((c) & (f))) \ m |= f; -static void change_mmu_range(vmmrange_t *range, void *base, size_t size, mmuflags_t new_flags) { +static void change_mmu_range(mm_range_t *range, void *base, size_t size, mmuflags_t new_flags) { for (uintmax_t offset = 0; offset < size; offset += PAGE_SIZE) { void *address = (void *)((uintptr_t)base + offset); mmuflags_t current_flags; // if page is not mapped, do nothing - if (arch_mmu_getflags(current_vmm_context()->pagetable, address, ¤t_flags) == false) + if (arch_mmu_getflags(current_mm_context()->pagetable, address, ¤t_flags) == false) continue; - void *physical = arch_mmu_getphysical(current_vmm_context()->pagetable, address); + void *physical = arch_mmu_getphysical(current_mm_context()->pagetable, address); uintmax_t mask = 0; // check which flags are currently set and will be unset @@ -209,9 +208,9 @@ static void change_mmu_range(vmmrange_t *range, void *base, size_t size, mmuflag CHANGE_MASK_CHECK(mask, ARCH_MMU_FLAGS_USER, current_flags, new_flags); CHANGE_MASK_CHECK(mask, ARCH_MMU_FLAGS_NOEXEC, current_flags, new_flags); - if ((range->flags & VMM_FLAGS_FILE) && (range->flags & VMM_FLAGS_SHARED) && (mask & ARCH_MMU_FLAGS_WRITE) && vfs_iscacheable(range->vnode)) { + if ((range->flags & MM_RANGE_FLAGS_FILE) && (range->flags & MM_RANGE_FLAGS_SHARED) && (mask & ARCH_MMU_FLAGS_WRITE) && vfs_iscacheable(range->vnode)) { // removing write permissions from a writeable dirty shared mapped page, mark it as dirty, as - // it won't be marked dirty upon a vmm_unmap after this + // it won't be marked dirty upon a mm_unmap after this page_t *page = mm_get_page(physical); VOP_LOCK(range->vnode); mm_cache_make_dirty(page); @@ -220,21 +219,21 @@ static void change_mmu_range(vmmrange_t *range, void *base, size_t size, mmuflag // we will only change the mapping if the permissions decreased if (mask) { - arch_mmu_remap(current_vmm_context()->pagetable, physical, address, current_flags & ~mask); + arch_mmu_remap(current_mm_context()->pagetable, physical, address, current_flags & ~mask); } } } -static inline bool can_write_vnode(vmmrange_t *range) { +static inline bool can_write_vnode(mm_range_t *range) { VOP_LOCK(range->vnode); int error = VOP_ACCESS(range->vnode, V_ACCESS_WRITE, ¤t_thread()->proc->cred); VOP_UNLOCK(range->vnode); return error == 0; } -int mm_change_range(vmmspace_t *space, void *address, size_t size, bool free, int flags, mmuflags_t new_mmuflags) { +int mm_change_range(mm_space_t *space, void *address, size_t size, bool free, int flags, mmuflags_t new_mmuflags) { void *top = (void *)((uintptr_t)address + size); - vmmrange_t *new_range = NULL; + mm_range_t *new_range = NULL; if (space->ranges == NULL) return 0; @@ -251,7 +250,7 @@ int mm_change_range(vmmspace_t *space, void *address, size_t size, bool free, in // get first range after address rbtree_t *rbtree = rbtree_find_first_larger_equal(space->ranges, address, rbtree_value_compare); - vmmrange_t *range = container_of(rbtree, vmmrange_t, rbtree_node); + mm_range_t *range = container_of(rbtree, mm_range_t, rbtree_node); if (rbtree == NULL) goto leave; @@ -259,27 +258,27 @@ int mm_change_range(vmmspace_t *space, void *address, size_t size, bool free, in // check if we actually start at the predecessor rbtree_t *predecessor = rbtree_predecessor(rbtree); if (predecessor) { - vmmrange_t *predecessor_range = container_of(predecessor, vmmrange_t, rbtree_node); + mm_range_t *predecessor_range = container_of(predecessor, mm_range_t, rbtree_node); if (RANGE_TOP(predecessor_range) > address) { rbtree = predecessor; range = predecessor_range; } } - // rbtree now has the first vmm range to be unmapped/remapped + // rbtree now has the first mm range to be unmapped/remapped // is the range we want to change in the middle of a mapping? if (address > range->start && top < RANGE_TOP(range)) { // split the mapping // check for write permission if changing a shared file mapping - if (free == false && (flags & VMM_FLAGS_CREDCHECK) && (range->flags & VMM_FLAGS_SHARED) && - (range->flags & VMM_FLAGS_FILE) && can_write_vnode(range) == false) { + if (free == false && (flags & MM_RANGE_FLAGS_CREDCHECK) && (range->flags & MM_RANGE_FLAGS_SHARED) && + (range->flags & MM_RANGE_FLAGS_FILE) && can_write_vnode(range) == false) { error = EACCES; goto leave; } - vmmrange_t *split_range = mm_alloc_range(); + mm_range_t *split_range = mm_alloc_range(); if (range == NULL) { error = ENOMEM; goto leave; @@ -297,7 +296,7 @@ int mm_change_range(vmmspace_t *space, void *address, size_t size, bool free, in split_range->size = (uintptr_t)RANGE_TOP(range) - (uintptr_t)split_range->start; range->size = (uintptr_t)address - (uintptr_t)range->start; - if (range->flags & VMM_FLAGS_FILE) { + if (range->flags & MM_RANGE_FLAGS_FILE) { VOP_HOLD(range->vnode); split_range->offset += range->size + size; } @@ -313,7 +312,7 @@ int mm_change_range(vmmspace_t *space, void *address, size_t size, bool free, in change_mmu_range(range, new_range->start, new_range->size, new_range->mmuflags); - if (range->flags & VMM_FLAGS_FILE) { + if (range->flags & MM_RANGE_FLAGS_FILE) { new_range->vnode = range->vnode; new_range->offset = range->offset + range->size; VOP_HOLD(range->vnode); @@ -331,8 +330,8 @@ int mm_change_range(vmmspace_t *space, void *address, size_t size, bool free, in // shrink the mapping // permission checking - if (free == false && (flags & VMM_FLAGS_CREDCHECK) && (range->flags & VMM_FLAGS_SHARED) && - (range->flags & VMM_FLAGS_FILE) && can_write_vnode(range) == false) { + if (free == false && (flags & MM_RANGE_FLAGS_CREDCHECK) && (range->flags & MM_RANGE_FLAGS_SHARED) && + (range->flags & MM_RANGE_FLAGS_FILE) && can_write_vnode(range) == false) { error = EACCES; goto leave; } @@ -352,7 +351,7 @@ int mm_change_range(vmmspace_t *space, void *address, size_t size, bool free, in change_mmu_range(range, new_range->start, new_range->size, new_range->mmuflags); - if (range->flags & VMM_FLAGS_FILE) { + if (range->flags & MM_RANGE_FLAGS_FILE) { new_range->vnode = range->vnode; new_range->offset = range->offset + range->size; VOP_HOLD(range->vnode); @@ -375,7 +374,7 @@ int mm_change_range(vmmspace_t *space, void *address, size_t size, bool free, in if (rbtree == NULL) goto leave; - range = container_of(rbtree, vmmrange_t, rbtree_node); + range = container_of(rbtree, mm_range_t, rbtree_node); if (RANGE_TOP(range) > top) break; @@ -388,8 +387,8 @@ int mm_change_range(vmmspace_t *space, void *address, size_t size, bool free, in mm_free_range(range); } else { // permission check - if ((flags & VMM_FLAGS_CREDCHECK) && (range->flags & VMM_FLAGS_SHARED) && - (range->flags & VMM_FLAGS_FILE) && can_write_vnode(range) == false) { + if ((flags & MM_RANGE_FLAGS_CREDCHECK) && (range->flags & MM_RANGE_FLAGS_SHARED) && + (range->flags & MM_RANGE_FLAGS_FILE) && can_write_vnode(range) == false) { error = EACCES; goto leave; } @@ -404,8 +403,8 @@ int mm_change_range(vmmspace_t *space, void *address, size_t size, bool free, in // move the start of the range // permission check - if (free == false && (flags & VMM_FLAGS_CREDCHECK) && (range->flags & VMM_FLAGS_SHARED) && - (range->flags & VMM_FLAGS_FILE) && can_write_vnode(range) == false) { + if (free == false && (flags & MM_RANGE_FLAGS_CREDCHECK) && (range->flags & MM_RANGE_FLAGS_SHARED) && + (range->flags & MM_RANGE_FLAGS_FILE) && can_write_vnode(range) == false) { error = EACCES; goto leave; } @@ -417,7 +416,7 @@ int mm_change_range(vmmspace_t *space, void *address, size_t size, bool free, in range->start = (void *)((uintptr_t)range->start + difference); range->size -= difference; - if (range->flags & VMM_FLAGS_FILE) + if (range->flags & MM_RANGE_FLAGS_FILE) range->offset += difference; if (free == false) { @@ -429,7 +428,7 @@ int mm_change_range(vmmspace_t *space, void *address, size_t size, bool free, in change_mmu_range(range, new_range->start, new_range->size, new_range->mmuflags); - if (range->flags & VMM_FLAGS_FILE) { + if (range->flags & MM_RANGE_FLAGS_FILE) { new_range->vnode = range->vnode; new_range->offset = range->offset - difference; VOP_HOLD(range->vnode); diff --git a/kernel-src/mm/slab.c b/kernel-src/mm/slab.c index 1dc78271..59389b18 100644 --- a/kernel-src/mm/slab.c +++ b/kernel-src/mm/slab.c @@ -1,5 +1,5 @@ #include -#include +#include #include #include #include @@ -47,7 +47,7 @@ static inline bool grow_cache(scache_t *cache) { return false; size_t byte_size = cache->slab_object_count * cache->true_size; - slab->base = vmm_map(NULL, byte_size, VMM_FLAGS_ALLOCATE, ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_WRITE | ARCH_MMU_FLAGS_NOEXEC, NULL); + slab->base = mm_map(NULL, byte_size, MM_RANGE_FLAGS_ALLOCATE, ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_WRITE | ARCH_MMU_FLAGS_NOEXEC, NULL); if (unlikely(slab->base == NULL)) { slab_free(slab_cache, slab); return false; @@ -68,7 +68,7 @@ static inline bool grow_cache(scache_t *cache) { for (int j = 0; j < i; ++j) slab_free(indirect_cache, indirect[j]); - vmm_unmap(slab->base, byte_size, 0); + mm_unmap(slab->base, byte_size, 0); slab_free(slab_cache, slab); return false; @@ -454,9 +454,9 @@ static bool magazine_ctor(scache_t *, void *obj) { return true; } -static scache_t *create_new_from_vmm(size_t size, size_t alignment, bool (*ctor)(scache_t *, void *), void (*dtor)(scache_t *, void *)) { +static scache_t *create_new_from_mm(size_t size, size_t alignment, bool (*ctor)(scache_t *, void *), void (*dtor)(scache_t *, void *)) { size_t cache_size = sizeof(scache_t) + sizeof(cache_per_cpu_t) * arch_smp_get_cpu_count(); - scache_t *cache = vmm_map(NULL, cache_size, VMM_FLAGS_ALLOCATE, ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_WRITE | ARCH_MMU_FLAGS_NOEXEC, NULL); + scache_t *cache = mm_map(NULL, cache_size, MM_RANGE_FLAGS_ALLOCATE, ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_WRITE | ARCH_MMU_FLAGS_NOEXEC, NULL); __assert(cache); __assert(slab_initialize(cache, size, alignment, ctor, dtor)); return cache; @@ -472,7 +472,7 @@ scache_t *slab_create_new_cache_from_pmm(size_t size, size_t alignment, bool (*c return cache; } -// initializes enough to allow for the vmm to bootstrap +// initializes enough to allow for the mm to bootstrap void slab_early_init(void) { size_t magazine_object_size = sizeof(magazine_t) + sizeof(void *) * MAGAZINE_SIZE; __assert(magazine_object_size < SLAB_INDIRECT_CUTOFF); @@ -483,11 +483,11 @@ void slab_early_init(void) { void slab_init(void) { size_t cache_size = sizeof(scache_t) + sizeof(cache_per_cpu_t) * arch_smp_get_cpu_count(); // the cache of caches needs for the slab and indirect caches to be up - slab_cache = create_new_from_vmm(sizeof(slab_t), 0, NULL, NULL); - indirect_cache = create_new_from_vmm(sizeof(slab_indirect_t), 0, NULL, NULL); - indirect_table_cache = create_new_from_vmm(sizeof(slab_indirect_t *) * 32, 0, NULL, NULL); - self_cache = create_new_from_vmm(cache_size, 0, NULL, NULL); + slab_cache = create_new_from_mm(sizeof(slab_t), 0, NULL, NULL); + indirect_cache = create_new_from_mm(sizeof(slab_indirect_t), 0, NULL, NULL); + indirect_table_cache = create_new_from_mm(sizeof(slab_indirect_t *) * 32, 0, NULL, NULL); + self_cache = create_new_from_mm(cache_size, 0, NULL, NULL); } -INIT_ROUTINE_DEFINE(slab, INIT_ROUTINE_FLAGS_NONE, slab_init, vmm); +INIT_ROUTINE_DEFINE(slab, INIT_ROUTINE_FLAGS_NONE, slab_init, mm); INIT_ROUTINE_DEFINE(slab_early, INIT_ROUTINE_FLAGS_NONE, slab_early_init, mm_page); diff --git a/kernel-src/sys/elf.c b/kernel-src/sys/elf.c index 973a3812..5a072756 100644 --- a/kernel-src/sys/elf.c +++ b/kernel-src/sys/elf.c @@ -3,7 +3,7 @@ #include #include #include -#include +#include #include #include @@ -67,7 +67,7 @@ static int load(vnode_t *vnode, elfph64_t *ph) { size_t firstpagecount = PAGE_SIZE - firstpageoffset; firstpagecount = fsize > firstpagecount ? firstpagecount : fsize; void *page = (void *)ROUND_DOWN(mempos, PAGE_SIZE); - if (vmm_map(page, PAGE_SIZE, VMM_FLAGS_EXACT | VMM_FLAGS_ALLOCATE, ARCH_MMU_FLAGS_USER | ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_WRITE, NULL) == NULL) + if (mm_map(page, PAGE_SIZE, MM_RANGE_FLAGS_EXACT | MM_RANGE_FLAGS_ALLOCATE, ARCH_MMU_FLAGS_USER | ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_WRITE, NULL) == NULL) return ENOMEM; error = readexact(vnode, (void *)mempos, firstpagecount, foffset); @@ -98,7 +98,7 @@ static int load(vnode_t *vnode, elfph64_t *ph) { mempos += remainingmsize; } - error = vmm_changemmuflags(page, PAGE_SIZE, mmuflags, 0); + error = mm_change_mmu_flags(page, PAGE_SIZE, mmuflags, 0); if (error) return error; } @@ -106,11 +106,11 @@ static int load(vnode_t *vnode, elfph64_t *ph) { // map middle of file size_t filepagecount = fsize / PAGE_SIZE; if (filepagecount) { - vmmfiledesc_t vfd = { + mm_map_file_desc_t vfd = { .node = vnode, .offset = foffset }; - if (vmm_map((void *)mempos, filepagecount, VMM_FLAGS_EXACT | VMM_FLAGS_PAGESIZE | VMM_FLAGS_FILE, mmuflags, &vfd) == NULL) + if (mm_map((void *)mempos, filepagecount, MM_RANGE_FLAGS_EXACT | MM_RANGE_FLAGS_PAGESIZE | MM_RANGE_FLAGS_FILE, mmuflags, &vfd) == NULL) return ENOMEM; size_t bytesize = filepagecount * PAGE_SIZE; mempos += bytesize; @@ -122,7 +122,7 @@ static int load(vnode_t *vnode, elfph64_t *ph) { // map end of file size_t lastpagecount = fsize % PAGE_SIZE; if (lastpagecount) { - if (vmm_map((void *)mempos, PAGE_SIZE, VMM_FLAGS_EXACT | VMM_FLAGS_ALLOCATE, ARCH_MMU_FLAGS_USER | ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_WRITE, NULL) == NULL) + if (mm_map((void *)mempos, PAGE_SIZE, MM_RANGE_FLAGS_EXACT | MM_RANGE_FLAGS_ALLOCATE, ARCH_MMU_FLAGS_USER | ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_WRITE, NULL) == NULL) return ENOMEM; error = readexact(vnode, (void *)mempos, lastpagecount, foffset); @@ -135,7 +135,7 @@ static int load(vnode_t *vnode, elfph64_t *ph) { msize -= msize > PAGE_SIZE ? PAGE_SIZE : msize; - error = vmm_changemmuflags((void *)mempos, PAGE_SIZE, mmuflags, 0); + error = mm_change_mmu_flags((void *)mempos, PAGE_SIZE, mmuflags, 0); if (error) return error; @@ -144,7 +144,7 @@ static int load(vnode_t *vnode, elfph64_t *ph) { // zero some parts if needed if (msize) { - if (vmm_map((void *)mempos, msize, VMM_FLAGS_EXACT, mmuflags, NULL) == NULL) + if (mm_map((void *)mempos, msize, MM_RANGE_FLAGS_EXACT, mmuflags, NULL) == NULL) return ENOMEM; } @@ -255,12 +255,12 @@ void *elf_preparestack(void *top, auxv64list_t *auxv64, char **argv, char **envp size_t initialsizeround = ROUND_UP(initialsize, PAGE_SIZE); void *initialpagebase = (void *)((uintptr_t)top - initialsizeround); - if (vmm_map(initialpagebase, initialsizeround, VMM_FLAGS_ALLOCATE | VMM_FLAGS_EXACT, STACK_MMUFLAGS, NULL) == NULL) + if (mm_map(initialpagebase, initialsizeround, MM_RANGE_FLAGS_ALLOCATE | MM_RANGE_FLAGS_EXACT, STACK_MMUFLAGS, NULL) == NULL) return NULL; void *stackbase = (void *)((uintptr_t)top - STACK_SIZE); size_t unallocatedsize = STACK_SIZE - initialsizeround; - if (vmm_map(stackbase, unallocatedsize, VMM_FLAGS_EXACT, STACK_MMUFLAGS, NULL) == NULL) + if (mm_map(stackbase, unallocatedsize, MM_RANGE_FLAGS_EXACT, STACK_MMUFLAGS, NULL) == NULL) return NULL; top = (void *)((uintptr_t)top - STACK_TOP_BUFFER); diff --git a/kernel-src/sys/proc.c b/kernel-src/sys/proc.c index 0b1a5ff3..d739aa0b 100644 --- a/kernel-src/sys/proc.c +++ b/kernel-src/sys/proc.c @@ -367,11 +367,11 @@ void proc_run_init() { printf("proc: loading %s\n", init_path); - vmmcontext_t *vmmctx = vmm_newcontext(); - __assert(vmmctx); + mm_context_t *mmctx = mm_create_context(); + __assert(mmctx); // leave kernel context to load elf - vmm_switchcontext(vmmctx); + mm_switch_context(mmctx); proc_t *proc = proc_create(); __assert(proc); @@ -440,7 +440,7 @@ void proc_run_init() { __assert(stack); // reenter kernel context - vmm_switchcontext(&vmm_kernelctx); + mm_switch_context(&mm_kernel_ctx); thread_t *uthread = sched_newthread(entry, PAGE_SIZE * 16, 1, proc, stack); __assert(uthread); @@ -448,7 +448,7 @@ void proc_run_init() { proc->threadlist = uthread; uthread->procnext = NULL; - uthread->vmmctx = vmmctx; + uthread->mmctx = mmctx; sched_queue(uthread); VOP_RELEASE(initnode); diff --git a/kernel-src/sys/scheduler/scheduler.c b/kernel-src/sys/scheduler/scheduler.c index 25561d4c..82bb0a66 100644 --- a/kernel-src/sys/scheduler/scheduler.c +++ b/kernel-src/sys/scheduler/scheduler.c @@ -2,7 +2,7 @@ #include #include #include -#include +#include #include #include #include @@ -25,8 +25,8 @@ static __attribute__((noreturn)) void switch_thread(thread_t *thread) { current_cpu()->thread = thread; - if(current == NULL || thread->vmmctx != current->vmmctx) - vmm_switchcontext(thread->vmmctx); + if(current == NULL || thread->mmctx != current->mmctx) + mm_switch_context(thread->mmctx); current_cpu()->intstatus = ARCH_CONTEXT_INTSTATUS(&thread->context); thread->cpu = current_cpu(); @@ -350,7 +350,7 @@ void sched_ap_entry() { dpc_prepare(¤t_cpu()->reschedule_dpc, sched_reschedule_dpc); set_up_bitmaps(); - current_cpu()->schedulerstack = vmm_map(NULL, SCHEDULER_STACK_SIZE, VMM_FLAGS_ALLOCATE, ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_WRITE | ARCH_MMU_FLAGS_NOEXEC, NULL); + current_cpu()->schedulerstack = mm_map(NULL, SCHEDULER_STACK_SIZE, MM_RANGE_FLAGS_ALLOCATE, ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_WRITE | ARCH_MMU_FLAGS_NOEXEC, NULL); __assert(current_cpu()->schedulerstack); current_cpu()->schedulerstack = (void *)((uintptr_t)current_cpu()->schedulerstack + SCHEDULER_STACK_SIZE); @@ -381,7 +381,7 @@ void sched_init() { __assert(bitmap_init(&sched_idle_cpu_bitmap, arch_smp_get_cpu_count()) == 0); - current_cpu()->schedulerstack = vmm_map(NULL, SCHEDULER_STACK_SIZE, VMM_FLAGS_ALLOCATE, ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_WRITE | ARCH_MMU_FLAGS_NOEXEC, NULL); + current_cpu()->schedulerstack = mm_map(NULL, SCHEDULER_STACK_SIZE, MM_RANGE_FLAGS_ALLOCATE, ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_WRITE | ARCH_MMU_FLAGS_NOEXEC, NULL); __assert(current_cpu()->schedulerstack); current_cpu()->schedulerstack = (void *)((uintptr_t)current_cpu()->schedulerstack + SCHEDULER_STACK_SIZE); diff --git a/kernel-src/sys/syscalls/clockget.c b/kernel-src/sys/syscalls/clockget.c index 250cfe99..f0cf6c43 100644 --- a/kernel-src/sys/syscalls/clockget.c +++ b/kernel-src/sys/syscalls/clockget.c @@ -2,7 +2,7 @@ #include #include #include -#include +#include syscallret_t syscall_clockget(context_t *, int clockid, timespec_t *tp) { syscallret_t ret = { diff --git a/kernel-src/sys/syscalls/execve.c b/kernel-src/sys/syscalls/execve.c index 89e9aacc..2846b47e 100644 --- a/kernel-src/sys/syscalls/execve.c +++ b/kernel-src/sys/syscalls/execve.c @@ -2,7 +2,7 @@ #include #include #include -#include +#include #include #include #include @@ -67,8 +67,8 @@ static syscallret_t execve(context_t *context, char *upath, char *uargv[], char size_t envsize = 0; char **argv = NULL; char **envp = NULL; - vmmcontext_t *vmmctx = NULL; - vmmcontext_t *oldctx = current_vmm_context(); + mm_context_t *mmctx = NULL; + mm_context_t *oldctx = current_mm_context(); vnode_t *node = NULL; vnode_t *refnode = NULL; char *interp = NULL; @@ -237,13 +237,13 @@ static syscallret_t execve(context_t *context, char *upath, char *uargv[], char } } - vmmctx = vmm_newcontext(); - if (vmmctx == NULL) { + mmctx = mm_create_context(); + if (mmctx == NULL) { ret.errno = ENOMEM; goto error; } - vmm_switchcontext(vmmctx); + mm_switch_context(mmctx); auxv64list_t auxv64; void *entry; @@ -321,7 +321,7 @@ static syscallret_t execve(context_t *context, char *upath, char *uargv[], char proc->signals.actions[i].address = SIG_IGN; } - vmm_destroycontext(oldctx); + mm_destroy_context(oldctx); CTX_SP(context) = (uint64_t)stack; CTX_IP(context) = (uint64_t)entry; @@ -339,9 +339,9 @@ static syscallret_t execve(context_t *context, char *upath, char *uargv[], char if (envp) freevec(envp); - if (vmmctx && ret.errno) { - vmm_switchcontext(oldctx); - vmm_destroycontext(vmmctx); + if (mmctx && ret.errno) { + mm_switch_context(oldctx); + mm_destroy_context(mmctx); } if (refnode) diff --git a/kernel-src/sys/syscalls/fork.c b/kernel-src/sys/syscalls/fork.c index 51a51866..7d7de677 100644 --- a/kernel-src/sys/syscalls/fork.c +++ b/kernel-src/sys/syscalls/fork.c @@ -27,9 +27,9 @@ syscallret_t syscall_fork(context_t *ctx) { goto cleanup; } - nthread->vmmctx = vmm_fork(current_thread()->vmmctx); + nthread->mmctx = mm_fork_context(current_thread()->mmctx); - if (nthread->vmmctx == NULL) { + if (nthread->mmctx == NULL) { ret.errno = ENOMEM; goto cleanup; } diff --git a/kernel-src/sys/syscalls/futex.c b/kernel-src/sys/syscalls/futex.c index 3277e355..17eb2938 100644 --- a/kernel-src/sys/syscalls/futex.c +++ b/kernel-src/sys/syscalls/futex.c @@ -1,6 +1,6 @@ #include #include -#include +#include #include #include #include @@ -66,7 +66,7 @@ syscallret_t syscall_futex(context_t *, uint32_t *futexp, int op, uint32_t value if (unlikely(ret.errno)) goto cleanup; - uint32_t *physical = vmm_getphysical(futexp, 0); + uint32_t *physical = mm_get_physical_address(futexp, 0); futex_t *futex = getfutex(physical); switch (op) { diff --git a/kernel-src/sys/syscalls/getdent.c b/kernel-src/sys/syscalls/getdent.c index d341804a..09c33196 100644 --- a/kernel-src/sys/syscalls/getdent.c +++ b/kernel-src/sys/syscalls/getdent.c @@ -1,6 +1,6 @@ #include #include -#include +#include #include #include diff --git a/kernel-src/sys/syscalls/mmap.c b/kernel-src/sys/syscalls/mmap.c index e00c0336..1b9fca4c 100644 --- a/kernel-src/sys/syscalls/mmap.c +++ b/kernel-src/sys/syscalls/mmap.c @@ -1,7 +1,7 @@ #include #include #include -#include +#include #include #define PROT_READ 0x01 @@ -59,21 +59,21 @@ syscallret_t syscall_mmap(context_t *context, void *hint, size_t len, int prot, mmuflags |= ARCH_MMU_FLAGS_NOEXEC; bool isfile = (flags & MAP_ANONYMOUS) == 0; - int vmmflags = 0; + int mm_flags = 0; if (flags & MAP_FIXED) - vmmflags |= VMM_FLAGS_REPLACE; + mm_flags |= MM_RANGE_FLAGS_REPLACE; if (flags & MAP_FIXED_NOREPLACE) - vmmflags |= VMM_FLAGS_EXACT; + mm_flags |= MM_RANGE_FLAGS_EXACT; if ((flags & MAP_ANONYMOUS) == 0) - vmmflags |= VMM_FLAGS_FILE; + mm_flags |= MM_RANGE_FLAGS_FILE; if (flags & MAP_SHARED) - vmmflags |= VMM_FLAGS_SHARED; + mm_flags |= MM_RANGE_FLAGS_SHARED; - vmmfiledesc_t vfd; + mm_map_file_desc_t vfd; file_t *file = NULL; if (isfile) { // make sure offset is page aligned @@ -99,7 +99,7 @@ syscallret_t syscall_mmap(context_t *context, void *hint, size_t len, int prot, } // if the vnode is not cacheable, we need to make sure we can map it - // TODO move this check to vmm_map once the return value of mmap is fixed to return an errno + // TODO move this check to mm_map once the return value of mmap is fixed to return an errno if (vfs_iscacheable(file->vnode) == false) { ret.errno = VOP_MMAP(file->vnode, VOP_MMAP_ADDRESS_MMAP_SUPPORTED, 0, 0, NULL); if (ret.errno) @@ -113,7 +113,7 @@ syscallret_t syscall_mmap(context_t *context, void *hint, size_t len, int prot, if (hint < USERSPACE_START) hint = USERSPACE_MMAP_START; - ret.ret = (uint64_t)vmm_map(hint, len, vmmflags, mmuflags, &vfd); + ret.ret = (uint64_t)mm_map(hint, len, mm_flags, mmuflags, &vfd); if (ret.ret == 0) ret.errno = ENOMEM; diff --git a/kernel-src/sys/syscalls/mount.c b/kernel-src/sys/syscalls/mount.c index 40559562..97282cee 100644 --- a/kernel-src/sys/syscalls/mount.c +++ b/kernel-src/sys/syscalls/mount.c @@ -1,5 +1,5 @@ #include -#include +#include #include #include #include diff --git a/kernel-src/sys/syscalls/mprotect.c b/kernel-src/sys/syscalls/mprotect.c index 616ecdd8..dc82e554 100644 --- a/kernel-src/sys/syscalls/mprotect.c +++ b/kernel-src/sys/syscalls/mprotect.c @@ -1,7 +1,7 @@ #include #include #include -#include +#include #include #define PROT_READ 0x01 @@ -37,7 +37,7 @@ syscallret_t syscall_mprotect(context_t *context, void *address, size_t len, int if ((prot & PROT_EXEC) == 0) mmuflags |= ARCH_MMU_FLAGS_NOEXEC; - ret.errno = vmm_changemmuflags(address, len, mmuflags, VMM_FLAGS_CREDCHECK); + ret.errno = mm_change_mmu_flags(address, len, mmuflags, MM_RANGE_FLAGS_CREDCHECK); ret.ret = ret.errno ? -1 : 0; return ret; diff --git a/kernel-src/sys/syscalls/munmap.c b/kernel-src/sys/syscalls/munmap.c index 5e7b5575..7fdeb75b 100644 --- a/kernel-src/sys/syscalls/munmap.c +++ b/kernel-src/sys/syscalls/munmap.c @@ -1,5 +1,5 @@ #include -#include +#include #include syscallret_t syscall_munmap(context_t *ctx, void *addr, size_t length) { @@ -18,7 +18,7 @@ syscallret_t syscall_munmap(context_t *ctx, void *addr, size_t length) { return ret; } - vmm_unmap(addr, length, 0); + mm_unmap(addr, length, 0); ret.ret = 0; ret.errno = 0; diff --git a/kernel-src/sys/syscalls/newthread.c b/kernel-src/sys/syscalls/newthread.c index 3c6cd952..13d8b68f 100644 --- a/kernel-src/sys/syscalls/newthread.c +++ b/kernel-src/sys/syscalls/newthread.c @@ -26,7 +26,7 @@ syscallret_t syscall_newthread(context_t *, void *entry, void *stack) { return ret; } - thread->vmmctx = current_thread()->vmmctx; + thread->mmctx = current_thread()->mmctx; bool intstatus = interrupt_set(false); spinlock_acquire(&proc->threadlistlock); diff --git a/kernel-src/sys/syscalls/poll.c b/kernel-src/sys/syscalls/poll.c index 8742762c..0e9f0be4 100644 --- a/kernel-src/sys/syscalls/poll.c +++ b/kernel-src/sys/syscalls/poll.c @@ -1,7 +1,7 @@ #include #include #include -#include +#include #include #include diff --git a/kernel-src/sys/syscalls/sleep.c b/kernel-src/sys/syscalls/sleep.c index 5f05b91c..a5652139 100644 --- a/kernel-src/sys/syscalls/sleep.c +++ b/kernel-src/sys/syscalls/sleep.c @@ -1,6 +1,6 @@ #include #include -#include +#include #include #include diff --git a/kernel-src/sys/thread.c b/kernel-src/sys/thread.c index e1fee627..c1036316 100644 --- a/kernel-src/sys/thread.c +++ b/kernel-src/sys/thread.c @@ -23,7 +23,7 @@ thread_t *sched_newthread(void *ip, size_t kstacksize, int nice, proc_t *proc, v return NULL; } - thread->kernelstack = vmm_map(NULL, kstacksize, VMM_FLAGS_ALLOCATE, ARCH_MMU_FLAGS_WRITE | ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_NOEXEC, NULL); + thread->kernelstack = mm_map(NULL, kstacksize, MM_RANGE_FLAGS_ALLOCATE, ARCH_MMU_FLAGS_WRITE | ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_NOEXEC, NULL); if (thread->kernelstack == NULL) { arch_extracontext_free(&thread->extracontext); slab_free(thread_cache, thread); @@ -32,8 +32,8 @@ thread_t *sched_newthread(void *ip, size_t kstacksize, int nice, proc_t *proc, v thread->kernelstacktop = (void *)((uintptr_t)thread->kernelstack + kstacksize); - // non kernel thread vmm contexts are handled by the caller - thread->vmmctx = proc ? NULL : &vmm_kernelctx; + // non kernel thread mm contexts are handled by the caller + thread->mmctx = proc ? NULL : &mm_kernel_ctx; thread->proc = proc; thread->kernelstacksize = kstacksize; thread->nice = nice; @@ -57,7 +57,7 @@ thread_t *sched_newthread(void *ip, size_t kstacksize, int nice, proc_t *proc, v } void sched_destroythread(thread_t *thread) { - vmm_unmap(thread->kernelstack, thread->kernelstacksize, 0); + mm_unmap(thread->kernelstack, thread->kernelstacksize, 0); arch_extracontext_free(&thread->extracontext); slab_free(thread_cache, thread); } @@ -84,18 +84,18 @@ __attribute__((noreturn)) void sched_threadexit() { thread_t *thread = current_thread(); proc_t *proc = thread->proc; - vmmcontext_t *oldctx = thread->vmmctx; - vmm_switchcontext(&vmm_kernelctx); + mm_context_t *oldctx = thread->mmctx; + mm_switch_context(&mm_kernel_ctx); if (proc) { __atomic_fetch_sub(&proc->runningthreadcount, 1, __ATOMIC_SEQ_CST); - __assert(oldctx != &vmm_kernelctx); + __assert(oldctx != &mm_kernel_ctx); if (proc->runningthreadcount == 0) { if (thread->shouldexit) proc->status = -1; proc_exit(); - vmm_destroycontext(oldctx); + mm_destroy_context(oldctx); PROC_RELEASE(proc); } }