diff --git a/kernel-src/arch/x86-64/acpi.c b/kernel-src/arch/x86-64/acpi.c index 16d76e10..4b25eb42 100644 --- a/kernel-src/arch/x86-64/acpi.c +++ b/kernel-src/arch/x86-64/acpi.c @@ -1,5 +1,5 @@ #include -#include +#include #include #include diff --git a/kernel-src/arch/x86-64/kvmclock.c b/kernel-src/arch/x86-64/kvmclock.c index 4515df86..48794d88 100644 --- a/kernel-src/arch/x86-64/kvmclock.c +++ b/kernel-src/arch/x86-64/kvmclock.c @@ -4,7 +4,7 @@ #include #include #include -#include +#include #include #include diff --git a/kernel-src/arch/x86-64/mmu.c b/kernel-src/arch/x86-64/mmu.c index 89ca9a5a..9babb4d0 100644 --- a/kernel-src/arch/x86-64/mmu.c +++ b/kernel-src/arch/x86-64/mmu.c @@ -1,6 +1,6 @@ #include #include -#include +#include #include #include #include @@ -71,7 +71,7 @@ static bool add_page(pagetableptr_t top, void *vaddr, uint64_t entry, int depth) uint64_t *pdpt = next(pml4[pml4offset]); if (pdpt == NULL) { - pdpt = pmm_allocpage(PMM_SECTION_DEFAULT); + pdpt = mm_alloc_page(MEMORY_SECTION_DEFAULT); if (pdpt == NULL) return false; pml4[pml4offset] = (uint64_t)pdpt | INTERMEDIATE_FLAGS; @@ -86,7 +86,7 @@ static bool add_page(pagetableptr_t top, void *vaddr, uint64_t entry, int depth) uint64_t *pd = next(pdpt[pdptoffset]); if (pd == NULL) { - pd = pmm_allocpage(PMM_SECTION_DEFAULT); + pd = mm_alloc_page(MEMORY_SECTION_DEFAULT); if (pd == NULL) return false; pdpt[pdptoffset] = (uint64_t)pd | INTERMEDIATE_FLAGS; @@ -101,7 +101,7 @@ static bool add_page(pagetableptr_t top, void *vaddr, uint64_t entry, int depth) uint64_t *pt = next(pd[pdoffset]); if (pt == NULL) { - pt = pmm_allocpage(PMM_SECTION_DEFAULT); + pt = mm_alloc_page(MEMORY_SECTION_DEFAULT); if (pt == NULL) return false; pd[pdoffset] = (uint64_t)pt | INTERMEDIATE_FLAGS; @@ -123,13 +123,13 @@ static void destroy(uint64_t *table, int depth) { if (depth > 0) destroy(MAKE_HHDM(addr), depth - 1); - pmm_release(addr); + mm_release_page(addr); } } void arch_mmu_destroytable(pagetableptr_t table) { destroy(MAKE_HHDM(table), 3); - pmm_release(table); + mm_release_page(table); } bool arch_mmu_map(pagetableptr_t table, void *paddr, void *vaddr, mmuflags_t flags) { @@ -212,7 +212,7 @@ void x86_64_mmu_disable_global_pages(void) { static pagetableptr_t template; pagetableptr_t arch_mmu_newtable() { - pagetableptr_t table = pmm_allocpage(PMM_SECTION_DEFAULT); + pagetableptr_t table = mm_alloc_page(MEMORY_SECTION_DEFAULT); if (table == NULL) return NULL; memcpy(MAKE_HHDM(table), template, PAGE_SIZE); @@ -312,7 +312,7 @@ static mmuflags_t kernelflags[3] = { ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_NOEXEC | ARCH_MMU_FLAGS_GLOBAL }; -extern volatile struct limine_memmap_request pmm_liminemap; +extern volatile struct limine_memmap_request mm_page_limine_map; static volatile struct limine_executable_address_request kaddrreq = { .id = LIMINE_EXECUTABLE_ADDRESS_REQUEST_ID, @@ -388,13 +388,13 @@ static void gpfisr(isr_t *self, context_t *ctx) { } void arch_mmu_init() { - template = pmm_allocpage(PMM_SECTION_DEFAULT); + template = mm_alloc_page(MEMORY_SECTION_DEFAULT); __assert(template); template = MAKE_HHDM(template); memset(template, 0, PAGE_SIZE); for (int i = 256; i < 512; ++i) { - uint64_t *entry = pmm_allocpage(PMM_SECTION_DEFAULT); + uint64_t *entry = mm_alloc_page(MEMORY_SECTION_DEFAULT); __assert(entry); memset(MAKE_HHDM(entry), 0, PAGE_SIZE); template[i] = (uint64_t)entry | INTERMEDIATE_FLAGS; @@ -403,8 +403,8 @@ void arch_mmu_init() { // TODO use 2mb pages // populate hhdm - for (size_t i = 0; i < pmm_liminemap.response->entry_count; ++i) { - struct limine_memmap_entry *e = pmm_liminemap.response->entries[i]; + for (size_t i = 0; i < mm_page_limine_map.response->entry_count; ++i) { + struct limine_memmap_entry *e = mm_page_limine_map.response->entries[i]; if (e->type != LIMINE_MEMMAP_USABLE && e->type != LIMINE_MEMMAP_BOOTLOADER_RECLAIMABLE && e->type != LIMINE_MEMMAP_EXECUTABLE_AND_MODULES && e->type != LIMINE_MEMMAP_FRAMEBUFFER) continue; @@ -434,7 +434,7 @@ void arch_mmu_init() { arch_mmu_apswitch(); } -INIT_ROUTINE_DEFINE(mmu, INIT_ROUTINE_FLAGS_NONE, arch_mmu_init, pmm); +INIT_ROUTINE_DEFINE(mmu, INIT_ROUTINE_FLAGS_NONE, arch_mmu_init, mm_page); void arch_mmu_apswitch() { arch_mmu_switch(FROM_HHDM(template)); diff --git a/kernel-src/arch/x86-64/smp.c b/kernel-src/arch/x86-64/smp.c index 8d64675d..dccc0e82 100644 --- a/kernel-src/arch/x86-64/smp.c +++ b/kernel-src/arch/x86-64/smp.c @@ -1,6 +1,6 @@ #include #include -#include +#include #include #include #include @@ -96,7 +96,7 @@ void arch_smp_wakeup(void) { // use physical pages so the other cpus have it on the hhdm size_t cpu_size = ROUND_UP(sizeof(cpu_t) * response->cpu_count, PAGE_SIZE); - cpu_t *cpus = pmm_alloc(cpu_size / PAGE_SIZE, PMM_SECTION_DEFAULT); + cpu_t *cpus = mm_alloc_pages(cpu_size / PAGE_SIZE, MEMORY_SECTION_DEFAULT); __assert(cpus); cpus = MAKE_HHDM(cpus); memset(cpus, 0, cpu_size); diff --git a/kernel-src/fs/devfs.c b/kernel-src/fs/devfs.c index 2589a012..7d13a72f 100644 --- a/kernel-src/fs/devfs.c +++ b/kernel-src/fs/devfs.c @@ -6,7 +6,7 @@ #include #include #include -#include +#include #include #include #include @@ -391,7 +391,7 @@ static int devfs_getpage(vnode_t *node, uintmax_t offset, struct page_t *page) { // only block devices will have this called __assert(node->type == V_TYPE_BLKDEV); iovec_t iovec = { - .addr = MAKE_HHDM(pmm_getpageaddress(page)), + .addr = MAKE_HHDM(mm_get_page_address(page)), .len = PAGE_SIZE }; @@ -410,7 +410,7 @@ static int devfs_putpage(vnode_t *node, uintmax_t offset, struct page_t *page) { // only block devices will have this called __assert(node->type == V_TYPE_BLKDEV); iovec_t iovec = { - .addr = MAKE_HHDM(pmm_getpageaddress(page)), + .addr = MAKE_HHDM(mm_get_page_address(page)), .len = PAGE_SIZE }; diff --git a/kernel-src/fs/ext2.c b/kernel-src/fs/ext2.c index a975e5dd..27f61441 100644 --- a/kernel-src/fs/ext2.c +++ b/kernel-src/fs/ext2.c @@ -4,7 +4,7 @@ #include #include #include -#include +#include #include #include #include @@ -1761,7 +1761,7 @@ static int ext2_getpage(vnode_t *node, uintmax_t offset, struct page_t *page) { // only regular files get cached __assert(node->type == V_TYPE_REGULAR); size_t readc = PAGE_SIZE; - void *addr = MAKE_HHDM(pmm_getpageaddress(page)); + void *addr = MAKE_HHDM(mm_get_page_address(page)); iovec_t iovec = { .addr = addr, @@ -1784,7 +1784,7 @@ static int ext2_putpage(vnode_t *node, uintmax_t offset, struct page_t *page) { __assert(node->type == V_TYPE_REGULAR); size_t writec; iovec_t iovec = { - .addr = MAKE_HHDM(pmm_getpageaddress(page)), + .addr = MAKE_HHDM(mm_get_page_address(page)), .len = PAGE_SIZE }; diff --git a/kernel-src/fs/fat/fatfs.c b/kernel-src/fs/fat/fatfs.c index 9f155c56..7b59d353 100644 --- a/kernel-src/fs/fat/fatfs.c +++ b/kernel-src/fs/fat/fatfs.c @@ -6,7 +6,7 @@ #include #include #include -#include +#include #include typedef struct { @@ -383,7 +383,7 @@ static int fatfs_putpage(vnode_t *node, uintmax_t offset, struct page_t *page) { __assert(node->type == V_TYPE_REGULAR); size_t write_count; iovec_t iovec = { - .addr = MAKE_HHDM(pmm_getpageaddress(page)), + .addr = MAKE_HHDM(mm_get_page_address(page)), .len = PAGE_SIZE }; @@ -410,7 +410,7 @@ static int fatfs_getpage(vnode_t *node, uintmax_t offset, struct page_t *page) { // only regular files get cached __assert(node->type == V_TYPE_REGULAR); size_t read_count = PAGE_SIZE; - void *addr = MAKE_HHDM(pmm_getpageaddress(page)); + void *addr = MAKE_HHDM(mm_get_page_address(page)); iovec_t iovec = { .addr = addr, diff --git a/kernel-src/fs/initrd.c b/kernel-src/fs/initrd.c index a167a73c..4d9afc5c 100644 --- a/kernel-src/fs/initrd.c +++ b/kernel-src/fs/initrd.c @@ -4,7 +4,7 @@ #include #include #include -#include +#include #include #include #include @@ -128,7 +128,7 @@ void initrd_unpack() { for (;;) { if (cleanupbytespassed >= PAGE_SIZE) { size_t pagec = cleanupbytespassed / PAGE_SIZE; - pmm_makefree(FROM_HHDM(cleanupptr), pagec); + mm_force_free_page(FROM_HHDM(cleanupptr), pagec); cleanupptr = (void *)((uintptr_t)cleanupptr + ROUND_DOWN(cleanupbytespassed, PAGE_SIZE)); cleanupbytespassed %= PAGE_SIZE; } @@ -181,5 +181,5 @@ void initrd_unpack() { } // free remaining pages to be freed - pmm_makefree(FROM_HHDM(cleanupptr), ROUND_UP(cleanupbytespassed, PAGE_SIZE) / PAGE_SIZE); + mm_force_free_page(FROM_HHDM(cleanupptr), ROUND_UP(cleanupbytespassed, PAGE_SIZE) / PAGE_SIZE); } diff --git a/kernel-src/fs/tmpfs.c b/kernel-src/fs/tmpfs.c index 55c15986..b87e8da2 100644 --- a/kernel-src/fs/tmpfs.c +++ b/kernel-src/fs/tmpfs.c @@ -8,7 +8,7 @@ #include #include #include -#include +#include #include #include #include @@ -528,10 +528,10 @@ static int tmpfs_getpage(vnode_t *node, uintmax_t offset, struct page_t *page) { // since tmpfs files now store their data on the vmmcache, // all getpage will do will be set the page to 0 and pin it in memory - void *phy = pmm_getpageaddress(page); + void *phy = mm_get_page_address(page); void *phyhhdm = MAKE_HHDM(phy); - pmm_hold(phy); + mm_hold_page(phy); page->flags |= PAGE_FLAGS_PINNED; memset(phyhhdm, 0, PAGE_SIZE); return 0; @@ -565,7 +565,7 @@ static int tmpfs_statfs(vfs_t *vfs, fsattr_t *fsattr) { tmpfs_t *tmpfs = (tmpfs_t *)vfs; size_t total_pages, free_pages; - pmm_getinfo(&total_pages, &free_pages); + mm_get_page_statistics(&total_pages, &free_pages); fsattr->io_size = PAGE_SIZE; fsattr->block_size = PAGE_SIZE; diff --git a/kernel-src/fs/vfs.c b/kernel-src/fs/vfs.c index 83a1b22b..657b9a2d 100644 --- a/kernel-src/fs/vfs.c +++ b/kernel-src/fs/vfs.c @@ -454,11 +454,11 @@ int vfs_write_iovec(vnode_t *node, iovec_iterator_t *iovec_iterator, size_t size goto leave; size_t writesize = min(PAGE_SIZE - startoffset, size); - void *address = MAKE_HHDM(pmm_getpageaddress(page)); + void *address = MAKE_HHDM(mm_get_page_address(page)); err = iovec_iterator_copy_to_buffer(iovec_iterator, (void *)((uintptr_t)address + startoffset), writesize); if (err) { - pmm_release(FROM_HHDM(address)); + mm_release_page(FROM_HHDM(address)); goto leave; } @@ -471,7 +471,7 @@ int vfs_write_iovec(vnode_t *node, iovec_iterator_t *iovec_iterator, size_t size pageoffset += 1; pagecount -= 1; - pmm_release(FROM_HHDM(address)); + mm_release_page(FROM_HHDM(address)); if (err) goto leave; } @@ -483,11 +483,11 @@ int vfs_write_iovec(vnode_t *node, iovec_iterator_t *iovec_iterator, size_t size goto leave; size_t writesize = min(PAGE_SIZE, size - *written); - void *address = MAKE_HHDM(pmm_getpageaddress(page)); + void *address = MAKE_HHDM(mm_get_page_address(page)); err = iovec_iterator_copy_to_buffer(iovec_iterator, address, writesize); if (err) { - pmm_release(FROM_HHDM(address)); + mm_release_page(FROM_HHDM(address)); goto leave; } @@ -497,7 +497,7 @@ int vfs_write_iovec(vnode_t *node, iovec_iterator_t *iovec_iterator, size_t size if (flags & V_FFLAGS_NOCACHE) err = writenocache(node, page, pageoffset * PAGE_SIZE + offset); - pmm_release(FROM_HHDM(address)); + mm_release_page(FROM_HHDM(address)); if (err) goto leave; @@ -567,11 +567,11 @@ int vfs_read_iovec(vnode_t *node, iovec_iterator_t *iovec_iterator, size_t size, goto leave; size_t readsize = min(PAGE_SIZE - startoffset, size); - void *address = MAKE_HHDM(pmm_getpageaddress(page)); + void *address = MAKE_HHDM(mm_get_page_address(page)); err = iovec_iterator_copy_from_buffer(iovec_iterator, (void *)((uintptr_t)address + startoffset), readsize); if (err) { - pmm_release(FROM_HHDM(address)); + mm_release_page(FROM_HHDM(address)); goto leave; } @@ -585,7 +585,7 @@ int vfs_read_iovec(vnode_t *node, iovec_iterator_t *iovec_iterator, size_t size, pageoffset += 1; pagecount -= 1; - pmm_release(FROM_HHDM(address)); + mm_release_page(FROM_HHDM(address)); } for (uintmax_t offset = 0; offset < pagecount * PAGE_SIZE; offset += PAGE_SIZE) { @@ -595,11 +595,11 @@ int vfs_read_iovec(vnode_t *node, iovec_iterator_t *iovec_iterator, size_t size, goto leave; size_t readsize = min(PAGE_SIZE, size - *bytesread); - void *address = MAKE_HHDM(pmm_getpageaddress(page)); + void *address = MAKE_HHDM(mm_get_page_address(page)); err = iovec_iterator_copy_from_buffer(iovec_iterator, address, readsize); if (err) { - pmm_release(FROM_HHDM(address)); + mm_release_page(FROM_HHDM(address)); goto leave; } @@ -608,7 +608,7 @@ int vfs_read_iovec(vnode_t *node, iovec_iterator_t *iovec_iterator, size_t size, // try to turn it into anonymous memory vmmcache_evict(page); } - pmm_release(FROM_HHDM(address)); + mm_release_page(FROM_HHDM(address)); } leave: MUTEX_RELEASE(&node->size_lock); diff --git a/kernel-src/include/kernel/pmm.h b/kernel-src/include/kernel/page.h similarity index 57% rename from kernel-src/include/kernel/pmm.h rename to kernel-src/include/kernel/page.h index 23b3d340..62109f15 100644 --- a/kernel-src/include/kernel/pmm.h +++ b/kernel-src/include/kernel/page.h @@ -1,13 +1,13 @@ -#ifndef _PMM_H -#define _PMM_H +#ifndef _PAGE_H +#define _PAGE_H #include #include -#define PMM_SECTION_COUNT 3 -#define PMM_SECTION_1MB 0 -#define PMM_SECTION_4GB 1 -#define PMM_SECTION_DEFAULT 2 +#define MEMORY_SECTION_COUNT 3 +#define MEMORY_SECTION_1MB 0 +#define MEMORY_SECTION_4GB 1 +#define MEMORY_SECTION_DEFAULT 2 #define PAGE_FLAGS_FREE 1 #define PAGE_FLAGS_TRUNCATED 2 @@ -38,16 +38,16 @@ typedef struct page_t { int flags; } page_t; -void *pmm_allocpage(int section); -page_t *pmm_getpage(void *addr); -void *pmm_getpageaddress(page_t *); -void pmm_hold(void *addr); -void pmm_release(void *addr); -void pmm_makefree(void *address, size_t count); -void *pmm_alloc(size_t size, int section); -void pmm_free(void *addr, size_t size); -void pmm_init(); -void pmm_getinfo(size_t *total_pages, size_t *free_pages); +void *mm_alloc_page(int section); +page_t *mm_get_page(void *addr); +void *mm_get_page_address(page_t *); +void mm_hold_page(void *addr); +void mm_release_page(void *addr); +void mm_force_free_page(void *address, size_t count); +void *mm_alloc_pages(size_t size, int section); +void mm_release_range(void *addr, size_t size); +void mm_page_init(); +void mm_get_page_statistics(size_t *total_pages, size_t *free_pages); extern uintptr_t hhdmbase; diff --git a/kernel-src/include/kernel/vmmcache.h b/kernel-src/include/kernel/vmmcache.h index 1acd0b3d..f2f6903c 100644 --- a/kernel-src/include/kernel/vmmcache.h +++ b/kernel-src/include/kernel/vmmcache.h @@ -1,7 +1,7 @@ #ifndef _VMMCACHE_H #define _VMMCACHE_H -#include +#include #include extern size_t vmmcache_cachedpages; diff --git a/kernel-src/include/x86-64/arch/pci.h b/kernel-src/include/x86-64/arch/pci.h index 9140f1ec..6185e056 100644 --- a/kernel-src/include/x86-64/arch/pci.h +++ b/kernel-src/include/x86-64/arch/pci.h @@ -6,7 +6,7 @@ #include #include #include -#include +#include #include #include diff --git a/kernel-src/io/acpi/glue.c b/kernel-src/io/acpi/glue.c index 4afd1b79..8fe20b3a 100644 --- a/kernel-src/io/acpi/glue.c +++ b/kernel-src/io/acpi/glue.c @@ -4,7 +4,7 @@ #include #include #include -#include +#include #include #include #include diff --git a/kernel-src/io/audio/hda.c b/kernel-src/io/audio/hda.c index ab466113..71bdf419 100644 --- a/kernel-src/io/audio/hda.c +++ b/kernel-src/io/audio/hda.c @@ -2,7 +2,7 @@ #include #include #include -#include +#include #include #include #include @@ -376,12 +376,12 @@ static hda_stream_t *hda_allocate_output_stream(hda_t *hda) { hda->streams[stream_n] = stream; hda->regs->intctl |= (1 << stream_n); - stream->bdl_phys = pmm_allocpage(PMM_SECTION_DEFAULT); + stream->bdl_phys = mm_alloc_page(MEMORY_SECTION_DEFAULT); __assert(stream->bdl_phys); hda_bdl_entry_t *bdl = MAKE_HHDM(stream->bdl_phys); for (int i = 0; i < HDA_BUFFER_PAGE_COUNT; ++i) { - void *phys_page = pmm_allocpage(PMM_SECTION_DEFAULT); + void *phys_page = mm_alloc_page(MEMORY_SECTION_DEFAULT); __assert(phys_page); memset(MAKE_HHDM(phys_page), 0, PAGE_SIZE); @@ -907,7 +907,7 @@ static void initcontroller(pcienum_t *e) { sched_sleep_us(1000); // we can fit all of corb/rirb in a single page - void *corb_phys = pmm_allocpage(PMM_SECTION_DEFAULT); + void *corb_phys = mm_alloc_page(MEMORY_SECTION_DEFAULT); __assert(corb_phys); void *corb = MAKE_HHDM(corb_phys); memset(corb, 0, PAGE_SIZE); diff --git a/kernel-src/io/block/ahci.c b/kernel-src/io/block/ahci.c index 4698bb7b..cb03648a 100644 --- a/kernel-src/io/block/ahci.c +++ b/kernel-src/io/block/ahci.c @@ -1,7 +1,7 @@ #include #include #include -#include +#include #include #include @@ -282,7 +282,7 @@ static int cmd_identify(ahci_t *ahci, int port, identify_t *results_phys) { .prdtl = 1, }; - command_table_t *command_table_phys = pmm_allocpage(PMM_SECTION_DEFAULT); + command_table_t *command_table_phys = mm_alloc_page(MEMORY_SECTION_DEFAULT); if (command_table_phys == NULL) return ENOMEM; @@ -300,7 +300,7 @@ static int cmd_identify(ahci_t *ahci, int port, identify_t *results_phys) { int error = dispatch_command_and_wait(ahci, port, &command_header); - pmm_release(command_table_phys); + mm_release_page(command_table_phys); return error; } @@ -308,7 +308,7 @@ static int cmd_identify(ahci_t *ahci, int port, identify_t *results_phys) { static void release_prdt(command_table_t *command_table, uint16_t prdtl) { for (int i = 0; i < prdtl; ++i) { void *address = (void *)((uint64_t)command_table->prdt[i].base_low | ((uint64_t)command_table->prdt[i].base_high << 32)); - pmm_release(address); + mm_release_page(address); } } @@ -328,7 +328,7 @@ static int setup_prdt(iovec_iterator_t *iterator, command_table_t *command_table __assert(page); // not block aligned if (page_remaining % 512) { - pmm_release(page); + mm_release_page(page); err = EINVAL; goto cleanup; } @@ -367,7 +367,7 @@ static int rw(port_data_t *port_data, iovec_iterator_t *iterator, uintmax_t lba, .flags = (sizeof(fis_h2d_t) / 4) | (write ? CMDHDR_WRITE : 0), }; - command_table_t *command_table_phys = pmm_allocpage(PMM_SECTION_DEFAULT); + command_table_t *command_table_phys = mm_alloc_page(MEMORY_SECTION_DEFAULT); if (command_table_phys == NULL) return ENOMEM; @@ -412,7 +412,7 @@ static int rw(port_data_t *port_data, iovec_iterator_t *iterator, uintmax_t lba, done += do_count; } - pmm_release(command_table_phys); + mm_release_page(command_table_phys); return error; } @@ -427,13 +427,13 @@ static int read(void *private, iovec_iterator_t *buffer, uintmax_t lba, size_t c static void init_port(ahci_t *ahci, int port) { // send identify command - identify_t *identify_phys = pmm_allocpage(PMM_SECTION_DEFAULT); + identify_t *identify_phys = mm_alloc_page(MEMORY_SECTION_DEFAULT); __assert(identify_phys); identify_t *identify = MAKE_HHDM(identify_phys); memset(identify, 0, 512); if (cmd_identify(ahci, port, identify_phys)) { - pmm_release(identify_phys); + mm_release_page(identify_phys); return; } @@ -446,13 +446,13 @@ static void init_port(ahci_t *ahci, int port) { if (logical_sector_size != 512) { printf("ahci%dp%d: unsupported logical sector size %lu\n", ahci->id, port, logical_sector_size); - pmm_release(identify_phys); + mm_release_page(identify_phys); return; } ahci->port_data[port]->sector_count = (uint64_t)identify->lba48_size[0] | ((uint64_t)identify->lba48_size[1] << 16) | ((uint64_t)identify->lba48_size[2] << 32) | ((uint64_t)identify->lba48_size[3] << 48); - pmm_release(identify_phys); + mm_release_page(identify_phys); printf("ahci%dp%d: ATA drive with %lu sectors\n", ahci->id, port, ahci->port_data[port]->sector_count); @@ -553,11 +553,11 @@ static void init_controller(pcienum_t *pci_enum) { ahci->ghc->ghc &= ~GHC_IE; // initialize ports - void *command_slot_mem = pmm_allocpage(PMM_SECTION_DEFAULT); + void *command_slot_mem = mm_alloc_page(MEMORY_SECTION_DEFAULT); __assert(command_slot_mem); size_t command_slot_offset = 0; - void *fis_base_mem = pmm_allocpage(PMM_SECTION_DEFAULT); + void *fis_base_mem = mm_alloc_page(MEMORY_SECTION_DEFAULT); __assert(fis_base_mem); size_t fis_base_offset = 0; FOR_EACH_PORT(ahci) { @@ -597,7 +597,7 @@ static void init_controller(pcienum_t *pci_enum) { command_slot_offset += 1024; if (command_slot_offset >= PAGE_SIZE) { // used up the page, allocate another - command_slot_mem = pmm_allocpage(PMM_SECTION_DEFAULT); + command_slot_mem = mm_alloc_page(MEMORY_SECTION_DEFAULT); __assert(command_slot_mem); command_slot_offset = 0; } @@ -612,7 +612,7 @@ static void init_controller(pcienum_t *pci_enum) { fis_base_offset += 256; if (fis_base_offset >= PAGE_SIZE) { // used up the page, allocate another - fis_base_mem = pmm_allocpage(PMM_SECTION_DEFAULT); + fis_base_mem = mm_alloc_page(MEMORY_SECTION_DEFAULT); __assert(fis_base_mem); fis_base_offset = 0; } @@ -653,9 +653,9 @@ static void init_controller(pcienum_t *pci_enum) { } if (command_slot_offset == 0) - pmm_release(command_slot_mem); + mm_release_page(command_slot_mem); if (fis_base_offset == 0) - pmm_release(fis_base_mem); + mm_release_page(fis_base_mem); // clear global interrupt status ahci->ghc->is = 0xffffffff; diff --git a/kernel-src/io/block/nvme.c b/kernel-src/io/block/nvme.c index 7225ec79..62ed6c1f 100644 --- a/kernel-src/io/block/nvme.c +++ b/kernel-src/io/block/nvme.c @@ -2,7 +2,7 @@ #include #include #include -#include +#include #include #include #include @@ -342,7 +342,7 @@ static int identify(nvmecontroller_t *controller, void *buffer, int what, int na entrypair_t pair = {0}; PAIR_INIT(&pair, SUB_DW0_OPCODE_IDENTIFY, SUB_DW0_UNFUSED, SUB_DW0_PRP, namespace); - pair.sub.datapointer[0] = (uint64_t)pmm_allocpage(PMM_SECTION_DEFAULT); + pair.sub.datapointer[0] = (uint64_t)mm_alloc_page(MEMORY_SECTION_DEFAULT); if (pair.sub.datapointer[0] == 0) return ENOMEM; @@ -351,7 +351,7 @@ static int identify(nvmecontroller_t *controller, void *buffer, int what, int na enqueueandwait(&controller->adminqueue, &pair); memcpy(buffer, MAKE_HHDM(pair.sub.datapointer[0]), IDENTIFY_SIZE); - pmm_release((void *)pair.sub.datapointer[0]); + mm_release_page((void *)pair.sub.datapointer[0]); return COMP_CMDINFO_STATUS(pair.comp.cmdinfo) ? EIO : 0; } @@ -401,7 +401,7 @@ static int createiocompqueue(nvmecontroller_t *controller, queuedesc_t *desc, si size_t size = entrycount * sizeof(compentry_t); size_t pagesize = ROUND_UP(size, PAGE_SIZE) / PAGE_SIZE; - void *queuepages = pmm_alloc(pagesize, PMM_SECTION_DEFAULT); + void *queuepages = mm_alloc_pages(pagesize, MEMORY_SECTION_DEFAULT); if (queuepages == NULL) return ENOMEM; @@ -415,7 +415,7 @@ static int createiocompqueue(nvmecontroller_t *controller, queuedesc_t *desc, si enqueueandwait(&controller->adminqueue, &pair); if (COMP_CMDINFO_STATUS(pair.comp.cmdinfo)) { - pmm_free(queuepages, pagesize); + mm_release_range(queuepages, pagesize); return EIO; } @@ -433,7 +433,7 @@ static int createiosubqueue(nvmecontroller_t *controller, queuedesc_t *desc, siz size_t size = entrycount * sizeof(subentry_t); size_t pagesize = ROUND_UP(size, PAGE_SIZE) / PAGE_SIZE; - void *queuepages = pmm_alloc(pagesize, PMM_SECTION_DEFAULT); + void *queuepages = mm_alloc_pages(pagesize, MEMORY_SECTION_DEFAULT); if (queuepages == NULL) return ENOMEM; @@ -447,7 +447,7 @@ static int createiosubqueue(nvmecontroller_t *controller, queuedesc_t *desc, siz enqueueandwait(&controller->adminqueue, &pair); if (COMP_CMDINFO_STATUS(pair.comp.cmdinfo)) { - pmm_free(queuepages, pagesize); + mm_release_range(queuepages, pagesize); return EIO; } @@ -510,15 +510,15 @@ static int iowrite(nvmenamespace_t *namespace, uint64_t prp[2], uint64_t lba, ui #define PAGES_IN_PRP_PAGE (PAGE_SIZE / sizeof(uint64_t)) static void free_prps(uint64_t prp[2], bool has_list) { - pmm_release((void *)ROUND_DOWN(prp[0], PAGE_SIZE)); + mm_release_page((void *)ROUND_DOWN(prp[0], PAGE_SIZE)); if (has_list) { uint64_t *prp_list = MAKE_HHDM((uint64_t *)prp[1]); for (int i = 0; prp_list[i] && i < PAGES_IN_PRP_PAGE; ++i) - pmm_release((void *)prp_list[i]); + mm_release_page((void *)prp_list[i]); } if (prp[1]) - pmm_release((void *)prp[1]); + mm_release_page((void *)prp[1]); } // sets up prps based on an iovec iterator. @@ -576,7 +576,7 @@ static int setup_prps(nvmenamespace_t *namespace, iovec_iterator_t *iovec_iterat } // we have to allocate a proper prp list now - uint64_t *prp_list_phys = pmm_allocpage(PMM_SECTION_DEFAULT); + uint64_t *prp_list_phys = mm_alloc_page(MEMORY_SECTION_DEFAULT); if (prp_list_phys == NULL) { // out of memory, we'll have to make do with 2 pages *has_list = false; @@ -603,7 +603,7 @@ static int setup_prps(nvmenamespace_t *namespace, iovec_iterator_t *iovec_iterat if (page_offset || page_remaining % namespace->blocksize) { prp_list[i] = 0; free_prps(prp, true); - pmm_release(page); + mm_release_page(page); return EINVAL; } @@ -777,7 +777,7 @@ static void initcontroller(pcienum_t *e) { bar0->aqattr = aqattr; - void *acq = pmm_alloc(2, PMM_SECTION_DEFAULT); + void *acq = mm_alloc_pages(2, MEMORY_SECTION_DEFAULT); __assert(acq); memset(MAKE_HHDM(acq), 0, PAGE_SIZE * 2); void *asq = (void *)((uintptr_t)acq + PAGE_SIZE); @@ -793,7 +793,7 @@ static void initcontroller(pcienum_t *e) { if (STATUS_FATAL(bar0->status)) { printf("nvme: controller returned fatal while initializing\n"); - pmm_free(acq, 2); + mm_release_range(acq, 2); return; } @@ -835,7 +835,7 @@ static void initcontroller(pcienum_t *e) { if (controllerid->type != 0 && controllerid->type != CONTROLLER_TYPE_IO) { printf("nvme: controller type not supported\n"); // FIXME free ISRs - pmm_free(acq, 2); + mm_release_range(acq, 2); free(controllerid); free(controller); return; diff --git a/kernel-src/io/block/vioblk.c b/kernel-src/io/block/vioblk.c index da0f5b02..4200968e 100644 --- a/kernel-src/io/block/vioblk.c +++ b/kernel-src/io/block/vioblk.c @@ -5,7 +5,7 @@ #include #include #include -#include +#include #include #define QUEUE_MAX_SIZE 144 @@ -100,7 +100,7 @@ static void vioblk_enqueue(vioblkdev_t *blkdev, requestheader_t *headerphys, voi } static int vioblk_rw(vioblkdev_t *blkdev, iovec_iterator_t *iovec_iterator, uintmax_t lba, size_t count, bool write) { - void *physpage = pmm_allocpage(PMM_SECTION_DEFAULT); + void *physpage = mm_alloc_page(MEMORY_SECTION_DEFAULT); if (physpage == NULL) return ENOMEM; @@ -133,7 +133,7 @@ static int vioblk_rw(vioblkdev_t *blkdev, iovec_iterator_t *iovec_iterator, uint vioblk_enqueue(blkdev, header, (void *)((uintptr_t)page + page_offset), PAGE_SIZE, status, write); - pmm_release(page); + mm_release_page(page); // if we didnt use the whole space in the page, set the iterator back a bit size_t diff_between_available_and_used = page_remaining - docount * 512; @@ -150,7 +150,7 @@ static int vioblk_rw(vioblkdev_t *blkdev, iovec_iterator_t *iovec_iterator, uint done += docount; } - pmm_release(physpage); + mm_release_page(physpage); return err; } diff --git a/kernel-src/io/fb.c b/kernel-src/io/fb.c index 2061a239..05dc290f 100644 --- a/kernel-src/io/fb.c +++ b/kernel-src/io/fb.c @@ -5,7 +5,7 @@ #include #include #include -#include +#include #include #include #include @@ -147,14 +147,14 @@ static int mmap(int minor, void *addr, uintmax_t offset, int flags) { return arch_mmu_map(current_vmm_context()->pagetable, FROM_HHDM((void *)((uintptr_t)fbs[minor]->address + offset)), addr, vnodeflagstommuflags(flags)) ? 0 : ENOMEM; } else { size_t size = offset + PAGE_SIZE < end ? PAGE_SIZE : end - offset; - paddr = pmm_allocpage(PMM_SECTION_DEFAULT); + paddr = mm_alloc_page(MEMORY_SECTION_DEFAULT); if (paddr == NULL) return ENOMEM; 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) { - pmm_release(paddr); + mm_release_page(paddr); return ENOMEM; } @@ -168,7 +168,7 @@ static int munmap(int minor, void *addr, uintmax_t offset, int flags) { arch_mmu_unmap(current_vmm_context()->pagetable, addr); arch_mmu_invalidate_range(addr, PAGE_SIZE); if (release) - pmm_release(phys); + mm_release_page(phys); return 0; } diff --git a/kernel-src/io/net/loopback.c b/kernel-src/io/net/loopback.c index 4f72ed88..2f5bd924 100644 --- a/kernel-src/io/net/loopback.c +++ b/kernel-src/io/net/loopback.c @@ -1,6 +1,6 @@ #include #include -#include +#include #include #include #include diff --git a/kernel-src/io/net/rtl8169.c b/kernel-src/io/net/rtl8169.c index 3e7f8d04..3c956c4d 100644 --- a/kernel-src/io/net/rtl8169.c +++ b/kernel-src/io/net/rtl8169.c @@ -4,7 +4,7 @@ #include #include #include -#include +#include #include #include @@ -198,7 +198,7 @@ static int rtl8169_sendpacket(netdev_t *internal, netdesc_t desc, mac_t target, static int rtl8169_allocdesc(netdev_t *netdev, size_t requested_size, netdesc_t *desc) { __assert(requested_size <= netdev->mtu); size_t true_size = sizeof(ethframe_t) + requested_size; - void *physical = pmm_allocpage(PMM_SECTION_DEFAULT); + void *physical = mm_alloc_page(MEMORY_SECTION_DEFAULT); if (physical == NULL) return ENOMEM; @@ -209,7 +209,7 @@ static int rtl8169_allocdesc(netdev_t *netdev, size_t requested_size, netdesc_t } static int rtl8169_freedesc(netdev_t *netdev, netdesc_t *desc) { - pmm_release(FROM_HHDM(desc->address)); + mm_release_page(FROM_HHDM(desc->address)); return 0; } @@ -275,9 +275,9 @@ static void init_controller(pcienum_t *pci_enum) { printf("rtl8169.%d: %x:%x:%x:%x:%x:%x\n", id, mac.address[0], mac.address[1], mac.address[2], mac.address[3], mac.address[4], mac.address[5]); // set up descriptor rings - descriptor_t *tx_ring_phys = pmm_alloc(ROUND_UP(sizeof(descriptor_t) * TX_DESCRIPTOR_COUNT, PAGE_SIZE) / PAGE_SIZE, PMM_SECTION_DEFAULT); + descriptor_t *tx_ring_phys = mm_alloc_pages(ROUND_UP(sizeof(descriptor_t) * TX_DESCRIPTOR_COUNT, PAGE_SIZE) / PAGE_SIZE, MEMORY_SECTION_DEFAULT); __assert(tx_ring_phys); - descriptor_t *rx_ring_phys = pmm_alloc(ROUND_UP(sizeof(descriptor_t) * RX_DESCRIPTOR_COUNT, PAGE_SIZE) / PAGE_SIZE, PMM_SECTION_DEFAULT); + descriptor_t *rx_ring_phys = mm_alloc_pages(ROUND_UP(sizeof(descriptor_t) * RX_DESCRIPTOR_COUNT, PAGE_SIZE) / PAGE_SIZE, MEMORY_SECTION_DEFAULT); __assert(rx_ring_phys); descriptor_t *tx_ring = MAKE_HHDM(tx_ring_phys); @@ -288,7 +288,7 @@ static void init_controller(pcienum_t *pci_enum) { // fill rx descriptors // XXX figure out a better way of doing this - void *rx_buffer = pmm_alloc(ROUND_UP((RX_DESCRIPTOR_COUNT * RX_BUFFER_SIZE), PAGE_SIZE) / PAGE_SIZE, PMM_SECTION_DEFAULT); + void *rx_buffer = mm_alloc_pages(ROUND_UP((RX_DESCRIPTOR_COUNT * RX_BUFFER_SIZE), PAGE_SIZE) / PAGE_SIZE, MEMORY_SECTION_DEFAULT); __assert(rx_buffer); for (int i = 0; i < RX_DESCRIPTOR_COUNT; ++i) { diff --git a/kernel-src/io/net/udp.c b/kernel-src/io/net/udp.c index d929e081..73a22fcd 100644 --- a/kernel-src/io/net/udp.c +++ b/kernel-src/io/net/udp.c @@ -285,7 +285,7 @@ static int udp_recv(socket_t *socket, sockdesc_t *sockdesc) { __assert(sockdesc->donecount == copycount); - // remove the message if not asked to peek + // remove the message if not asked to peek TODO: if sonecount != header.length, add truncate flag. also do the same to localsocket if ((flags & SOCKET_RECV_FLAGS_PEEK) == 0) ringbuffer_truncate(&udpsocket->ringbuffer, sizeof(header) + header.length); diff --git a/kernel-src/io/net/vionet.c b/kernel-src/io/net/vionet.c index 400849e6..4047ea34 100644 --- a/kernel-src/io/net/vionet.c +++ b/kernel-src/io/net/vionet.c @@ -1,6 +1,6 @@ #include #include -#include +#include #include #include #include @@ -84,7 +84,7 @@ static void tx_irq(isr_t *isr, context_t *context) { static int vionet_allocdesc(netdev_t *netdev, size_t requestedsize, netdesc_t *desc) { __assert(requestedsize <= netdev->mtu); size_t truesize = PREFIX_SIZE + requestedsize; - void *phys = pmm_allocpage(PMM_SECTION_DEFAULT); + void *phys = mm_alloc_page(MEMORY_SECTION_DEFAULT); if (phys == NULL) return ENOMEM; @@ -95,7 +95,7 @@ static int vionet_allocdesc(netdev_t *netdev, size_t requestedsize, netdesc_t *d } static int vionet_freedesc(netdev_t *netdev, netdesc_t *desc) { - pmm_release(FROM_HHDM(desc->address)); + mm_release_page(FROM_HHDM(desc->address)); return 0; } @@ -210,7 +210,7 @@ int vionet_newdevice(viodevice_t *viodevice) { // XXX is the memory saving of allocating hundreds of KiBs of contiguous physical memory really worth it? // the system literally might not have enough (contiguous) physical memory for this, especially considering // this device is initialised deeper into the boot process. - void *receivebuffer = pmm_alloc(ROUND_UP((rxsize * BUFFER_SIZE), PAGE_SIZE) / PAGE_SIZE, PMM_SECTION_DEFAULT); + void *receivebuffer = mm_alloc_pages(ROUND_UP((rxsize * BUFFER_SIZE), PAGE_SIZE) / PAGE_SIZE, MEMORY_SECTION_DEFAULT); __assert(receivebuffer); for (int i = 0; i < rxsize; ++i) { diff --git a/kernel-src/io/term.c b/kernel-src/io/term.c index fc0fddf4..ff9de592 100644 --- a/kernel-src/io/term.c +++ b/kernel-src/io/term.c @@ -6,7 +6,7 @@ #include #include #include -#include +#include #include #include #include @@ -31,7 +31,7 @@ static void *internalalloc(size_t n) { #else // TODO make more efficient. works for now static void *internalalloc(size_t n) { - void *addr = pmm_alloc(n / PAGE_SIZE + 1, PMM_SECTION_DEFAULT); + void *addr = mm_alloc_pages(n / PAGE_SIZE + 1, MEMORY_SECTION_DEFAULT); __assert(addr); return MAKE_HHDM(addr); } diff --git a/kernel-src/io/usb/core/usb.c b/kernel-src/io/usb/core/usb.c index f5efc8bb..edd7273d 100644 --- a/kernel-src/io/usb/core/usb.c +++ b/kernel-src/io/usb/core/usb.c @@ -1,5 +1,5 @@ #include -#include +#include #include #include diff --git a/kernel-src/io/usb/ctrl/xhci.c b/kernel-src/io/usb/ctrl/xhci.c index abd545bc..adb59394 100644 --- a/kernel-src/io/usb/ctrl/xhci.c +++ b/kernel-src/io/usb/ctrl/xhci.c @@ -4,7 +4,7 @@ #include #include #include -#include +#include #include #include #include @@ -28,7 +28,7 @@ static void xhci_release_submission_page(xhci_submission_t *submission) { uint32_t cmd_type = xhci_trb_type(&submission->cmd_trb); if ((cmd_type == TRB_NORMAL || cmd_type == TRB_DATA_STAGE) && submission->cmd_trb.parameters != 0) - pmm_release((void *)(submission->cmd_trb.parameters & ~(PAGE_SIZE - 1))); + mm_release_page((void *)(submission->cmd_trb.parameters & ~(PAGE_SIZE - 1))); } static bool xhci_reclaim_submission_slot(xhci_submission_t *slot, xhci_submission_t *submission) { @@ -614,7 +614,7 @@ static int xhci_ctrl_start(usb_ctrl_t *ctrl) { xhci->opregs->config = max_slots; // Set up the Device Context Base Address Array. - void *dcbaa_phys = pmm_allocpage(PMM_SECTION_DEFAULT); + void *dcbaa_phys = mm_alloc_page(MEMORY_SECTION_DEFAULT); __assert(dcbaa_phys); uint64_t *dcbaa_virt = MAKE_HHDM(dcbaa_phys); @@ -629,12 +629,12 @@ static int xhci_ctrl_start(usb_ctrl_t *ctrl) { printf("xhci: setting up %u scratchpad buffers\n", max_scratchpads); __assert(max_scratchpads < PAGE_SIZE / sizeof(uint64_t)); - void *scratchpad_array_phys = pmm_allocpage(PMM_SECTION_DEFAULT); + void *scratchpad_array_phys = mm_alloc_page(MEMORY_SECTION_DEFAULT); __assert(scratchpad_array_phys); uint64_t *scratchpad_array_virt = MAKE_HHDM(scratchpad_array_phys); for (uint32_t i = 0; i < max_scratchpads; i++) { - void *scratchpad_phys = pmm_allocpage(PMM_SECTION_DEFAULT); + void *scratchpad_phys = mm_alloc_page(MEMORY_SECTION_DEFAULT); __assert(scratchpad_phys); memset(MAKE_HHDM(scratchpad_phys), 0, PAGE_SIZE); scratchpad_array_virt[i] = (uint64_t)scratchpad_phys; @@ -650,7 +650,7 @@ static int xhci_ctrl_start(usb_ctrl_t *ctrl) { xhci->opregs->crcr = (uint64_t)xhci->command_ring.ring_phys | XHCI_CRCR_RCS; // Set up Event Ring Segment Table. - void *erst_phys = pmm_allocpage(PMM_SECTION_DEFAULT); + void *erst_phys = mm_alloc_page(MEMORY_SECTION_DEFAULT); __assert(erst_phys); xhci_erst_entry_t *erst_virt = MAKE_HHDM(erst_phys); diff --git a/kernel-src/io/usb/ctrl/xhci_ctrl.c b/kernel-src/io/usb/ctrl/xhci_ctrl.c index d59b5d74..9f0b351e 100644 --- a/kernel-src/io/usb/ctrl/xhci_ctrl.c +++ b/kernel-src/io/usb/ctrl/xhci_ctrl.c @@ -1,7 +1,7 @@ #include #include #include -#include +#include #include #include @@ -132,9 +132,9 @@ static void xhci_release_device_resources(xhci_ctrl_t *xhci, xhci_device_t *dev) } if (dev->input_ctx_phys) - pmm_release(dev->input_ctx_phys); + mm_release_page(dev->input_ctx_phys); if (dev->device_ctx_phys) - pmm_release(dev->device_ctx_phys); + mm_release_page(dev->device_ctx_phys); free(dev); } @@ -394,22 +394,22 @@ static int xhci_ctrl_address_device(usb_ctrl_t *ctrl, usb_hub_t *hub, uint8_t po if (xhci_dev == NULL) return ENOMEM; - void *device_ctx_phys = pmm_allocpage(PMM_SECTION_DEFAULT); + void *device_ctx_phys = mm_alloc_page(MEMORY_SECTION_DEFAULT); if (device_ctx_phys == NULL) { free(xhci_dev); return ENOMEM; } - void *input_ctx_phys = pmm_allocpage(PMM_SECTION_DEFAULT); + void *input_ctx_phys = mm_alloc_page(MEMORY_SECTION_DEFAULT); if (input_ctx_phys == NULL) { - pmm_release(device_ctx_phys); + mm_release_page(device_ctx_phys); free(xhci_dev); return ENOMEM; } if (xhci_alloc_ring(xhci, &xhci_dev->ep_rings[0], false)) { - pmm_release(input_ctx_phys); - pmm_release(device_ctx_phys); + mm_release_page(input_ctx_phys); + mm_release_page(device_ctx_phys); free(xhci_dev); return ENOMEM; } diff --git a/kernel-src/io/usb/ctrl/xhci_ring.c b/kernel-src/io/usb/ctrl/xhci_ring.c index ff5e811d..6ab237a5 100644 --- a/kernel-src/io/usb/ctrl/xhci_ring.c +++ b/kernel-src/io/usb/ctrl/xhci_ring.c @@ -1,11 +1,11 @@ #include #include -#include +#include #include #include int xhci_alloc_ring(xhci_ctrl_t *ctrl, xhci_ring_t *r, bool event_ring) { - void *ring_phys = pmm_allocpage(PMM_SECTION_DEFAULT); + void *ring_phys = mm_alloc_page(MEMORY_SECTION_DEFAULT); if (ring_phys == NULL) return ENOMEM; @@ -24,7 +24,7 @@ int xhci_alloc_ring(xhci_ctrl_t *ctrl, xhci_ring_t *r, bool event_ring) { } else { r->submissions = alloc(sizeof(xhci_submission_t) * r->size); if (r->submissions == NULL) { - pmm_release(ring_phys); + mm_release_page(ring_phys); return ENOMEM; } @@ -37,7 +37,7 @@ int xhci_alloc_ring(xhci_ctrl_t *ctrl, xhci_ring_t *r, bool event_ring) { } void xhci_free_ring(xhci_ring_t *ring) { - pmm_release(ring->ring_phys); + mm_release_page(ring->ring_phys); free(ring->submissions); } diff --git a/kernel-src/io/usb/ctrl/xhci_xfer.c b/kernel-src/io/usb/ctrl/xhci_xfer.c index 2ef373b7..6d09515f 100644 --- a/kernel-src/io/usb/ctrl/xhci_xfer.c +++ b/kernel-src/io/usb/ctrl/xhci_xfer.c @@ -2,7 +2,7 @@ #include #include #include -#include +#include #include typedef struct { @@ -27,7 +27,7 @@ static int xhci_count_sg_trbs(iovec_iterator_t *iov, size_t total_size, size_t * if (page == NULL) return EFAULT; - pmm_release(page); + mm_release_page(page); done += min(page_remaining, total_size - done); count++; @@ -64,7 +64,7 @@ int xhci_data_xfer(xhci_ctrl_t *xhci, xhci_device_t *dev, usb_xfer_t *xfer, xhci xhci_trb_t trb = {0}; if (xfer->flags & USB_XFER_FLAG_BUFFER_PHYSICAL) { - pmm_hold(xfer->data - page_offset); + mm_hold_page(xfer->data - page_offset); trb.parameters = (uint64_t)xfer->data; } else { // This should never be called with user pages. Doing so is a bug. For user-fronting code, use @@ -187,7 +187,7 @@ int xhci_sg_data_xfer(xhci_ctrl_t *xhci, xhci_ring_t *ring, xhci_device_t *dev, fail: for (size_t i = 0; i < prepared_count; ++i) - pmm_release(prepared[i].page); + mm_release_page(prepared[i].page); free(prepared); xhci_ring_unreserve(ring, trb_count); return err; @@ -239,7 +239,7 @@ int xhci_control_xfer(xhci_ctrl_t *xhci, xhci_device_t *dev, usb_xfer_t *xfer, x if (xfer->data_length) { if (xfer->flags & USB_XFER_FLAG_BUFFER_PHYSICAL) { - pmm_hold(xfer->data - page_offset); + 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); diff --git a/kernel-src/io/virtio.c b/kernel-src/io/virtio.c index befac83f..4e41be3c 100644 --- a/kernel-src/io/virtio.c +++ b/kernel-src/io/virtio.c @@ -2,7 +2,7 @@ #include #include #include -#include +#include #include #define VIRTIO_VENDOR 0x1af4 @@ -63,7 +63,7 @@ void *virtio_createqueue(viodevice_t *viodevice, vioqueue_t *vioqueue, int queue size_t bytesize = VIO_QUEUE_BYTESIZE(size); size_t pagesize = ROUND_UP(bytesize, PAGE_SIZE) / PAGE_SIZE; - void *queuephys = pmm_alloc(pagesize, PMM_SECTION_DEFAULT); + void *queuephys = mm_alloc_pages(pagesize, MEMORY_SECTION_DEFAULT); __assert(queuephys); memset(MAKE_HHDM(queuephys), 0, bytesize); diff --git a/kernel-src/mm/pmm.c b/kernel-src/mm/page.c similarity index 78% rename from kernel-src/mm/pmm.c rename to kernel-src/mm/page.c index 11bbdef1..41e10ecd 100644 --- a/kernel-src/mm/pmm.c +++ b/kernel-src/mm/page.c @@ -1,4 +1,4 @@ -#include +#include #include #include #include @@ -14,10 +14,10 @@ static size_t pagecount; size_t freepagecount; static mutex_t freelistmutex; -static page_t *freelists[PMM_SECTION_COUNT]; -static page_t *freetails[PMM_SECTION_COUNT]; -static page_t *standbylists[PMM_SECTION_COUNT]; -static page_t *standbytails[PMM_SECTION_COUNT]; +static page_t *freelists[MEMORY_SECTION_COUNT]; +static page_t *freetails[MEMORY_SECTION_COUNT]; +static page_t *standbylists[MEMORY_SECTION_COUNT]; +static page_t *standbytails[MEMORY_SECTION_COUNT]; typedef struct { uintmax_t baseid; @@ -28,7 +28,7 @@ typedef struct { #define TOP_1MB (0x100000 / PAGE_SIZE) #define TOP_4GB ((uint64_t)0x100000000 / PAGE_SIZE) -static section_t sections[PMM_SECTION_COUNT] = { +static section_t sections[MEMORY_SECTION_COUNT] = { {0, TOP_1MB, 0}, {TOP_1MB, TOP_4GB, TOP_1MB}, {TOP_4GB, 0xffffffffffffffffl, TOP_4GB} @@ -39,7 +39,7 @@ static volatile struct limine_hhdm_request hhdmreq = { .revision = 0 }; -volatile struct limine_memmap_request pmm_liminemap = { +volatile struct limine_memmap_request mm_page_limine_map = { .id = LIMINE_MEMMAP_REQUEST_ID, .revision = 0 }; @@ -59,11 +59,11 @@ static void insertinfreelist(page_t *page) { int section; if (pageid < TOP_1MB) - section = PMM_SECTION_1MB; + section = MEMORY_SECTION_1MB; else if (pageid < TOP_4GB) - section = PMM_SECTION_4GB; + section = MEMORY_SECTION_4GB; else - section = PMM_SECTION_DEFAULT; + section = MEMORY_SECTION_DEFAULT; list = page->backing ? &standbylists[section] : &freelists[section]; tail = page->backing ? &standbytails[section] : &freetails[section]; @@ -91,11 +91,11 @@ static void removefromfreelist(page_t *page) { int section; if (pageid < TOP_1MB) - section = PMM_SECTION_1MB; + section = MEMORY_SECTION_1MB; else if (pageid < TOP_4GB) - section = PMM_SECTION_4GB; + section = MEMORY_SECTION_4GB; else - section = PMM_SECTION_DEFAULT; + section = MEMORY_SECTION_DEFAULT; list = page->backing ? &standbylists[section] : &freelists[section]; tail = page->backing ? &standbytails[section] : &freetails[section]; @@ -124,15 +124,15 @@ static void internalhold(page_t *page) { } } -page_t *pmm_getpage(void *address) { +page_t *mm_get_page(void *address) { return &pages[((uintptr_t)address / PAGE_SIZE)]; } -void *pmm_getpageaddress(page_t *page) { +void *mm_get_page_address(page_t *page) { return (void *)(PAGE_GETID(page) * PAGE_SIZE); } -void pmm_hold(void *addr) { +void mm_hold_page(void *addr) { page_t *page = &pages[((uintptr_t)addr / PAGE_SIZE)]; MUTEX_ACQUIRE(&freelistmutex); @@ -140,7 +140,7 @@ void pmm_hold(void *addr) { MUTEX_RELEASE(&freelistmutex); } -void pmm_release(void *addr) { +void mm_release_page(void *addr) { page_t *page = &pages[(uintptr_t)addr / PAGE_SIZE]; MUTEX_ACQUIRE(&freelistmutex); @@ -160,7 +160,7 @@ static void doalloc(page_t *page) { page->refcount = 1; } -void *pmm_allocpage(int section) { +void *mm_alloc_page(int section) { retry: MUTEX_ACQUIRE(&freelistmutex); page_t *page = NULL; @@ -193,7 +193,7 @@ void *pmm_allocpage(int section) { if (cachepage && vmmcache_takepage(page) == EAGAIN) { // someone already got the page from the cache between us holding it and taking it - pmm_release(pmm_getpageaddress(page)); + mm_release_page(mm_get_page_address(page)); page = NULL; // retry it from the start, as an anonymous page could have been released while the lock was not held goto retry; @@ -212,7 +212,7 @@ void *pmm_allocpage(int section) { return address; } -void pmm_makefree(void *address, size_t count) { +void mm_force_free_page(void *address, size_t count) { MUTEX_ACQUIRE(&freelistmutex); memorysize += PAGE_SIZE * count; __assert(((uintptr_t)address % PAGE_SIZE) == 0); @@ -227,18 +227,18 @@ void pmm_makefree(void *address, size_t count) { MUTEX_RELEASE(&freelistmutex); } -void pmm_init() { +void mm_page_init() { __assert(hhdmreq.response); hhdmbase = hhdmreq.response->offset; - __assert(pmm_liminemap.response); + __assert(mm_page_limine_map.response); // get size of memory, top of usable memory, biggest section and print memory map size_t top = 0; struct limine_memmap_entry *biggest = NULL; - printf("pmm: ranges:\n"); - for (size_t i = 0; i < pmm_liminemap.response->entry_count; ++i) { - struct limine_memmap_entry *e = pmm_liminemap.response->entries[i]; - printf("pmm: %016p -> %016p: %d\n", e->base, e->base + e->length, e->type); + printf("mm: ranges:\n"); + for (size_t i = 0; i < mm_page_limine_map.response->entry_count; ++i) { + struct limine_memmap_entry *e = mm_page_limine_map.response->entries[i]; + printf("mm: %016p -> %016p: %d\n", e->base, e->base + e->length, e->type); if (e->type == LIMINE_MEMMAP_USABLE || e->type == LIMINE_MEMMAP_BOOTLOADER_RECLAIMABLE || e->type == LIMINE_MEMMAP_EXECUTABLE_AND_MODULES) { size_t sectiontop = e->base + e->length; if (sectiontop > top) @@ -254,11 +254,11 @@ void pmm_init() { pages = MAKE_HHDM((page_t *)biggest->base); pagecount = ROUND_UP(top, PAGE_SIZE) / PAGE_SIZE; memset(pages, 0, pagecount * sizeof(page_t)); - printf("pmm: %d pages used for page list\n", ROUND_UP(pagecount * sizeof(page_t), PAGE_SIZE) / PAGE_SIZE); + printf("mm: %d pages used for page list\n", ROUND_UP(pagecount * sizeof(page_t), PAGE_SIZE) / PAGE_SIZE); // initialize usable memory - for (size_t i = 0; i < pmm_liminemap.response->entry_count; ++i) { - struct limine_memmap_entry *e = pmm_liminemap.response->entries[i]; + for (size_t i = 0; i < mm_page_limine_map.response->entry_count; ++i) { + struct limine_memmap_entry *e = mm_page_limine_map.response->entries[i]; if (e->type == LIMINE_MEMMAP_USABLE) { int firstusablepage = e == biggest ? ROUND_UP(e->base + pagecount * sizeof(page_t), PAGE_SIZE) / PAGE_SIZE : e->base / PAGE_SIZE; for (int i = firstusablepage; i < (e->base + e->length) / PAGE_SIZE; ++i) { @@ -276,15 +276,15 @@ void pmm_init() { MUTEX_INIT(&freelistmutex); } -INIT_ROUTINE_DEFINE(pmm, INIT_ROUTINE_FLAGS_NONE, pmm_init, arch_early); +INIT_ROUTINE_DEFINE(mm_page, INIT_ROUTINE_FLAGS_NONE, mm_page_init, arch_early); -// XXX pmm_alloc won't be able to take pages from the page cache when the allocation size is over 1 page +// XXX mm_alloc_pages won't be able to take pages from the page cache when the allocation size is over 1 page -void *pmm_alloc(size_t size, int section) { +void *mm_alloc_pages(size_t size, int section) { __assert(size); - // pmm_allocpage is more suited for single page allocations, so use that instead + // mm_alloc_page is more suited for single page allocations, so use that instead if (size == 1) - return pmm_allocpage(section); + return mm_alloc_page(section); MUTEX_ACQUIRE(&freelistmutex); @@ -322,15 +322,15 @@ void *pmm_alloc(size_t size, int section) { return addr; } -void pmm_free(void *addr, size_t size) { +void mm_release_range(void *addr, size_t size) { __assert(size); // release multiple pages at once __assert(((uintptr_t)addr % PAGE_SIZE) == 0); for (int i = 0; i < size; ++i) - pmm_release((void *)((uintptr_t)addr + PAGE_SIZE * i)); + mm_release_page((void *)((uintptr_t)addr + PAGE_SIZE * i)); } -void pmm_getinfo(size_t *total_pages, size_t *free_pages) { +void mm_get_page_statistics(size_t *total_pages, size_t *free_pages) { *total_pages = memorysize / PAGE_SIZE; *free_pages = freepagecount; } diff --git a/kernel-src/mm/slab.c b/kernel-src/mm/slab.c index 3b90f68d..1dc78271 100644 --- a/kernel-src/mm/slab.c +++ b/kernel-src/mm/slab.c @@ -1,6 +1,6 @@ #include #include -#include +#include #include #include #include @@ -28,7 +28,7 @@ static inline bool grow_cache(scache_t *cache) { slab_t *slab; if (cache->size < SLAB_INDIRECT_CUTOFF) { - void *slab_hhdm = pmm_allocpage(PMM_SECTION_DEFAULT); + void *slab_hhdm = mm_alloc_page(MEMORY_SECTION_DEFAULT); if (unlikely(slab_hhdm == NULL)) return false; @@ -465,7 +465,7 @@ static scache_t *create_new_from_vmm(size_t size, size_t alignment, bool (*ctor) scache_t *slab_create_new_cache_from_pmm(size_t size, size_t alignment, bool (*ctor)(scache_t *, void *), void (*dtor)(scache_t *, void *)) { __assert(size < SLAB_INDIRECT_CUTOFF); size_t cache_size = sizeof(scache_t) + sizeof(cache_per_cpu_t) * arch_smp_get_cpu_count(); - scache_t *cache = pmm_alloc(ROUND_UP(cache_size, PAGE_SIZE) / PAGE_SIZE, PMM_SECTION_DEFAULT); + scache_t *cache = mm_alloc_pages(ROUND_UP(cache_size, PAGE_SIZE) / PAGE_SIZE, MEMORY_SECTION_DEFAULT); __assert(cache); cache = MAKE_HHDM(cache); __assert(slab_initialize(cache, size, alignment, ctor, dtor)); @@ -490,4 +490,4 @@ void slab_init(void) { } INIT_ROUTINE_DEFINE(slab, INIT_ROUTINE_FLAGS_NONE, slab_init, vmm); -INIT_ROUTINE_DEFINE(slab_early, INIT_ROUTINE_FLAGS_NONE, slab_early_init, pmm); +INIT_ROUTINE_DEFINE(slab_early, INIT_ROUTINE_FLAGS_NONE, slab_early_init, mm_page); diff --git a/kernel-src/mm/vmm.c b/kernel-src/mm/vmm.c index db95cb84..d94b2ada 100644 --- a/kernel-src/mm/vmm.c +++ b/kernel-src/mm/vmm.c @@ -1,6 +1,6 @@ #include #include -#include +#include #include #include #include @@ -175,19 +175,19 @@ static void destroyrange(vmmrange_t *range, uintmax_t _offset, size_t size, int // dirty page cache mapping arch_mmu_unmap(current_vmm_context()->pagetable, vaddr); VOP_LOCK(range->vnode); - vmmcache_makedirty(pmm_getpage(physical)); + vmmcache_makedirty(mm_get_page(physical)); VOP_UNLOCK(range->vnode); - pmm_release(physical); + mm_release_page(physical); } else { // non dirty page mapping arch_mmu_unmap(current_vmm_context()->pagetable, vaddr); - pmm_release(physical); + 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) - pmm_release(physical); + mm_release_page(physical); } } @@ -220,7 +220,7 @@ static void changemmurange(vmmrange_t *range, void *base, size_t size, mmuflags_ if ((range->flags & VMM_FLAGS_FILE) && (range->flags & VMM_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 - page_t *page = pmm_getpage(physical); + page_t *page = mm_get_page(physical); VOP_LOCK(range->vnode); vmmcache_makedirty(page); VOP_UNLOCK(range->vnode); @@ -566,10 +566,10 @@ bool vmm_pagefault(void *addr, bool user, int actions) { printf("vmm: error on vmmcache_getpage(): %d\n", error); status = false; } else { - status = arch_mmu_map(current_vmm_context()->pagetable, pmm_getpageaddress(res), addr, range->mmuflags & ~ARCH_MMU_FLAGS_WRITE); + status = arch_mmu_map(current_vmm_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"); - pmm_release(pmm_getpageaddress(res)); + mm_release_page(mm_get_page_address(res)); signal_signalthread(current_thread(), SIGBUS, true); status = true; } @@ -580,7 +580,7 @@ bool vmm_pagefault(void *addr, bool user, int actions) { // anonymous memory. if (range->mmuflags & ARCH_MMU_FLAGS_WRITE) { // writeable range: allocate a new page, zero it and map it - void *new_page = pmm_allocpage(PMM_SECTION_DEFAULT); + 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"); signal_signalthread(current_thread(), SIGBUS, true); @@ -592,7 +592,7 @@ bool vmm_pagefault(void *addr, bool user, int actions) { if (!arch_mmu_map(current_vmm_context()->pagetable, new_page, addr, range->mmuflags)) { printf("vmm: out of memory to map page (sending SIGBUS)\n"); signal_signalthread(current_thread(), SIGBUS, true); - pmm_release(new_page); + mm_release_page(new_page); } } else { // read-only range: map a shared zero page @@ -600,14 +600,14 @@ bool vmm_pagefault(void *addr, bool user, int actions) { printf("vmm: out of memory to map zero page into address space (sending SIGBUS)\n"); signal_signalthread(current_thread(), SIGBUS, true); } else { - pmm_hold(zeropage); + mm_hold_page(zeropage); } } } } else if (arch_mmu_iswritable(current_vmm_context()->pagetable, addr) == false) { // page present but not writeable in the page tables void *oldphys = arch_mmu_getphysical(current_vmm_context()->pagetable, addr); - page_t *oldpage = pmm_getpage(oldphys); + 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)) { @@ -617,14 +617,14 @@ bool vmm_pagefault(void *addr, bool user, int actions) { if ((range->flags & VMM_FLAGS_FILE) && vfs_iscacheable(range->vnode)) { // and if its a cache page, mark it as dirty VOP_LOCK(range->vnode); - vmmcache_makedirty(pmm_getpage(oldphys)); + vmmcache_makedirty(mm_get_page(oldphys)); VOP_UNLOCK(range->vnode); } status = true; } else { // do copy on write - void *newphys = pmm_allocpage(PMM_SECTION_DEFAULT); + 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"); signal_signalthread(current_thread(), SIGBUS, true); @@ -634,7 +634,7 @@ bool vmm_pagefault(void *addr, bool user, int actions) { arch_mmu_remap(current_vmm_context()->pagetable, newphys, addr, range->mmuflags); arch_mmu_invalidate_range(addr, PAGE_SIZE); if ((range->flags & VMM_FLAGS_FILE) == 0 || vfs_iscacheable(range->vnode)) - pmm_release(oldphys); + mm_release_page(oldphys); status = true; } @@ -667,7 +667,7 @@ static int lock_page(vmmspace_t *space, void *vaddr) { // TODO shared anonymous mappings are not handled properly by the kernel if (present && writable == false && private)) { // CoW cases (private mapping) - real_phys = pmm_allocpage(PMM_SECTION_DEFAULT); + real_phys = mm_alloc_page(MEMORY_SECTION_DEFAULT); if (real_phys == NULL) return ENOMEM; @@ -676,10 +676,10 @@ static int lock_page(vmmspace_t *space, void *vaddr) { arch_mmu_remap(current_vmm_context()->pagetable, real_phys, vaddr, range->mmuflags); arch_mmu_invalidate_range(vaddr, PAGE_SIZE); if (file_mapping == false || vfs_iscacheable(range->vnode)) - pmm_release(mapped_address); + mm_release_page(mapped_address); } else if (present == false && private) { // not present private mapping case - real_phys = pmm_allocpage(PMM_SECTION_DEFAULT); + real_phys = mm_alloc_page(MEMORY_SECTION_DEFAULT); if (real_phys == NULL) } } @@ -704,7 +704,7 @@ void *vmm_getphysical(void *addr, int flags) { physical = arch_mmu_getphysical(current_vmm_context()->pagetable, aligned_addr); if (flags & VMM_GET_PHYSICAL_FLAGS_HOLD) - pmm_hold(physical); + mm_hold_page(physical); leave: MUTEX_RELEASE(&space->lock); @@ -791,7 +791,7 @@ void *vmm_map(void *addr, volatile size_t size, int flags, mmuflags_t mmuflags, } else if (flags & VMM_FLAGS_ALLOCATE) { // allocate to virtual memory for (uintmax_t i = 0; i < size; i += PAGE_SIZE) { - void *allocated = pmm_allocpage(PMM_SECTION_DEFAULT); + void *allocated = mm_alloc_page(MEMORY_SECTION_DEFAULT); if (allocated == NULL) { retaddr = NULL; goto cleanup; @@ -803,7 +803,7 @@ void *vmm_map(void *addr, volatile size_t size, int flags, mmuflags_t mmuflags, void *physical = arch_mmu_getphysical(current_vmm_context()->pagetable, virt); if (physical) { - pmm_release(physical); + mm_release_page(physical); arch_mmu_unmap(current_vmm_context()->pagetable, virt); } } @@ -926,7 +926,7 @@ vmmcontext_t *vmm_fork(vmmcontext_t *oldcontext) { if (arch_mmu_map(newcontext->pagetable, phys, vaddr, newrange->mmuflags & ~ARCH_MMU_FLAGS_WRITE) == false) goto error; - pmm_hold(phys); + mm_hold_page(phys); arch_mmu_remap(oldcontext->pagetable, phys, vaddr, newrange->mmuflags & ~ARCH_MMU_FLAGS_WRITE); } @@ -959,7 +959,7 @@ extern void *_text_end; extern void *_data_end; extern void *_rodata_end; -extern volatile struct limine_memmap_request pmm_liminemap; +extern volatile struct limine_memmap_request mm_page_limine_map; void vmm_init() { // set up initial state @@ -976,8 +976,8 @@ void vmm_init() { vmm_switchcontext(&vmm_kernelctx); // map HHDM - for (uint64_t i = 0; i < pmm_liminemap.response->entry_count; ++i) { - struct limine_memmap_entry *e = pmm_liminemap.response->entries[i]; + for (uint64_t i = 0; i < mm_page_limine_map.response->entry_count; ++i) { + struct limine_memmap_entry *e = mm_page_limine_map.response->entries[i]; if (e->type != LIMINE_MEMMAP_USABLE && e->type != LIMINE_MEMMAP_BOOTLOADER_RECLAIMABLE && e->type != LIMINE_MEMMAP_EXECUTABLE_AND_MODULES && e->type != LIMINE_MEMMAP_FRAMEBUFFER) continue; @@ -998,7 +998,7 @@ void vmm_init() { vmm_map(MAKE_HHDM(NULL), PAGE_SIZE, VMM_FLAGS_EXACT, ARCH_MMU_FLAGS_NOEXEC, NULL); // zero page - zeropage = pmm_allocpage(PMM_SECTION_DEFAULT); + zeropage = mm_alloc_page(MEMORY_SECTION_DEFAULT); memset(MAKE_HHDM(zeropage), 0, PAGE_SIZE); printspace(&kernelspace); diff --git a/kernel-src/mm/vmmcache.c b/kernel-src/mm/vmmcache.c index 9a5f8988..44b66549 100644 --- a/kernel-src/mm/vmmcache.c +++ b/kernel-src/mm/vmmcache.c @@ -114,12 +114,12 @@ int vmmcache_getpage(vnode_t *vnode, uintmax_t offset, page_t **res) { retry: if (page) { // page is present in the page cache - pmm_hold(pmm_getpageaddress((page_t *)page)); + mm_hold_page(mm_get_page_address((page_t *)page)); RELEASE_LOCK(); // in the case of a retry, release the allocated page here if (newpage) - pmm_release(pmm_getpageaddress(newpage)); + mm_release_page(mm_get_page_address(newpage)); eventlistener_t listener; EVENT_INITLISTENER(&listener); @@ -133,7 +133,7 @@ int vmmcache_getpage(vnode_t *vnode, uintmax_t offset, page_t **res) { if (page->flags & PAGE_FLAGS_ERROR) { // the thread handling the page in failed to read it, we should retry it and see whats up - pmm_release(pmm_getpageaddress((page_t *)page)); + mm_release_page(mm_get_page_address((page_t *)page)); goto retry_err; } @@ -142,11 +142,11 @@ int vmmcache_getpage(vnode_t *vnode, uintmax_t offset, page_t **res) { // page is not present in the cache, we will have to load it in RELEASE_LOCK(); - void *address = pmm_allocpage(PMM_SECTION_DEFAULT); + void *address = mm_alloc_page(MEMORY_SECTION_DEFAULT); if (address == NULL) return ENOMEM; - newpage = pmm_getpage(address); + newpage = mm_get_page(address); HOLD_LOCK(); @@ -180,7 +180,7 @@ int vmmcache_getpage(vnode_t *vnode, uintmax_t offset, page_t **res) { newpage->offset = 0; RELEASE_LOCK(); - pmm_release(pmm_getpageaddress(newpage)); + mm_release_page(mm_get_page_address(newpage)); EVENT_SIGNAL(&pagereadyevent); return error; } @@ -289,7 +289,7 @@ int vmmcache_truncate(vnode_t *vnode, uintmax_t offset) { page_t *page = pagelist; pagelist = pagelist->vnodenext; if (page->flags & PAGE_FLAGS_PINNED) - pmm_release(pmm_getpageaddress(page)); + mm_release_page(mm_get_page_address(page)); } return 0; @@ -318,7 +318,7 @@ static int syncpage(page_t *page, bool backinglock) { VOP_RELEASE(page->backing); } - pmm_release(pmm_getpageaddress((page_t *)page)); + mm_release_page(mm_get_page_address((page_t *)page)); return e; } @@ -427,7 +427,7 @@ int vmmcache_makedirty(page_t *page) { dirtylist = page; } - pmm_hold(pmm_getpageaddress(page)); + mm_hold_page(mm_get_page_address(page)); __assert(page->backing); VOP_HOLD(page->backing); } diff --git a/kernel-src/sys/syscalls/sysinfo.c b/kernel-src/sys/syscalls/sysinfo.c index e1957f10..9d42bfd3 100644 --- a/kernel-src/sys/syscalls/sysinfo.c +++ b/kernel-src/sys/syscalls/sysinfo.c @@ -1,6 +1,6 @@ #include #include -#include +#include #include #include @@ -26,7 +26,7 @@ syscallret_t syscall_sysinfo(context_t *, sysinfo_t *usysinfo) { }; size_t total_pages, free_pages; - pmm_getinfo(&total_pages, &free_pages); + mm_get_page_statistics(&total_pages, &free_pages); sysinfo_t sysinfo = { .uptime = timekeeper_timefromboot().s,