Mmu

bin/cat/cat.c

@@ -2,14 +2,14 @@
 
 int main(int argc, const char* argv[]){
     file fd2 = { .id = 2 };
-    if (argc != 2){
-        string err_msg = string_from_literal("Usage cat <path> <size>");
+    if (argc < 1 || argc > 2){
+        string err_msg = string_from_literal("Usage cat <path> [size]");
         fwrite(&fd2, err_msg.data, err_msg.length);
         free(err_msg.data, err_msg.mem_length);
         return 2;
     }
     const char* path = argv[0];
-    size_t size = parse_int_u64(argv[1], UINT32_MAX);
+    size_t size = argc < 2 ? 0 : parse_int_u64(argv[1], UINT32_MAX);
     file fd = {};
     fopen(path, &fd);
     if (fd.size == 0){

kernel/audio/virtio_audio_pci.cpp

@@ -206,7 +206,7 @@ bool VirtioAudioDriver::config_streams(uint32_t streams){
 
 void VirtioAudioDriver::send_buffer(sizedptr buf){
     virtio_add_buffer(&audio_dev, cmd_index % audio_dev.common_cfg->queue_size, buf.ptr, buf.size, true);
-    struct virtq_used* u = (struct virtq_used*)(uintptr_t)audio_dev.common_cfg->queue_device;
+    volatile virtq_used* u = (virtq_used*)audio_dev.common_cfg->queue_device;
     while (u->idx < cmd_index-2)
         yield();
     cmd_index++;

kernel/bin/bin_mod.c

@@ -51,17 +51,30 @@ process_t* execute(const char* prog_name, int argc, const char* argv[]){
                     }
                     process_t *proc = load_elf_file(prog_name, 0, program, fd.size);
                     string_free(path);
-                    free(full_name,name_len);
+                    free(full_name, name_len);
                     if (!proc){
                         kprintf("Failed to create process for %s",prog_name);
                     }
                     proc->PROC_X0 = argc;
-                    size_t total = 0;
-                    for (int i = 0; i < argc; i++)
-                        total += strlen(argv[i], 0);
-                    char **nargv = (char **)kalloc((void*)proc->heap, total, ALIGN_16B, MEM_PRIV_USER);
-                    memcpy(nargv, argv, total);
-                    proc->PROC_X1 = (uintptr_t)nargv;
+                    if (argc > 0){
+                        uintptr_t start = (uintptr_t)argv[0];
+                        uintptr_t end = (uintptr_t)argv;
+                        size_t total = end-start;
+                        size_t argvs = argc * sizeof(uintptr_t);
+                        char *nargvals = (char*)(proc->stack_phys-total-argvs);
+                        char *vnargvals = (char*)(proc->stack-total-argvs);
+                        char** nargv = (char**)(proc->stack_phys-argvs);
+                        uintptr_t strptr = 0;
+                        for (int i = 0; i < argc; i++){
+                            size_t strsize = strlen(argv[i],0);
+                            memcpy(nargvals + strptr, argv[i], strsize);
+                            *(char*)(nargvals + strptr + strsize) = 0;
+                            nargv[i] = vnargvals + strptr;
+                            strptr += strsize;
+                        }
+                        proc->PROC_X1 = (uintptr_t)proc->stack-argvs;
+                        proc->sp -= total+argvs;
+                    }
                     proc->state = READY;
                     return proc;
                 }

kernel/console/serial/uart.c

@@ -3,6 +3,7 @@
 #include "gpio.h"
 #include "hw/hw.h"
 #include "mailbox/mailbox.h"
+#include "memory/mmu.h"
 
 #define UART0_DR   (UART0_BASE + 0x00)
 #define UART0_FR   (UART0_BASE + 0x18)
@@ -29,6 +30,8 @@ volatile uint32_t uart_mbox[9] __attribute__((aligned(16))) = {
 };
 
 void enable_uart() {
+    register_device_memory(UART0_CR, UART0_CR);
+
     write32(UART0_CR, 0x0);
 
     uint32_t ibrd = 1;

kernel/exceptions/irq.c

@@ -11,6 +11,7 @@
 #include "audio/audio.h"
 #include "networking/interface_manager.h"
 #include "process/syscall.h"
+#include "memory/mmu.h"
 
 #define IRQ_TIMER 30
 #define SLEEP_TIMER 27
@@ -40,6 +41,9 @@ static void gic_enable_irq(uint32_t irq, uint8_t priority, uint8_t cpu_target) {
 }
 
 void irq_init() {
+    register_device_memory(GICD_BASE, GICD_BASE);
+    register_device_memory(GICC_BASE, GICC_BASE);
+
     if (RPI_BOARD != 3){
         write32(GICD_BASE, 0); // Disable Distributor
         write32(GICC_BASE, 0); // Disable CPU Interface

kernel/filesystem/fat32.cpp

@@ -228,7 +228,7 @@ sizedptr FAT32FS::read_entry_handler(FAT32FS *instance, f32file_entry *entry, ch
     if (entry->flags.volume_id) return {0,0};
 
     bool is_last = *seek_to(seek, '/') == '\0';
-    if (!is_last && strstart(seek, filename, true) == 0) return {0, 0};
+    if (!is_last && strstart(seek, filename, true) < (int)(strlen(filename, 0)-1)) return {0, 0};
     if (is_last && strcmp(seek, filename, true) != 0) return {0, 0};
 
     uint32_t filecluster = (entry->hi_first_cluster << 16) | entry->lo_first_cluster;
@@ -265,7 +265,7 @@ size_t FAT32FS::read_file(file *descriptor, void* buf, size_t size){
 sizedptr FAT32FS::list_entries_handler(FAT32FS *instance, f32file_entry *entry, char *filename, const char *seek) {
 
     if (entry->flags.volume_id) return { 0, 0 };
-    if (strstart(seek, filename, true) == 0) return { 0, 0 };
+    if (strstart(seek, filename, true) != (int)(strlen(filename, 0)-1)) return { 0, 0 };
 
     bool is_last = *seek_to(seek, '/') == '\0';
 

kernel/filesystem/virtio_blk_pci.c

@@ -1,3 +1,4 @@
+#include "virtio_blk_pci.h"
 #include "disk.h"
 #include "std/string.h"
 #include "std/memory_access.h"
@@ -6,28 +7,16 @@
 #include "pci.h"
 #include "virtio/virtio_pci.h"
 #include "std/memory.h"
-#include "virtio_blk_pci.h"
+#include "sysregs.h"
 
 #define VIRTIO_BLK_T_IN   0
 #define VIRTIO_BLK_T_OUT  1
 
-struct virtio_blk_req {
+typedef struct {
     uint32_t type;
     uint32_t reserved;
     uint64_t sector;
-} __attribute__((packed));
-
-struct virtio_blk_config {
-    uint64_t capacity;//In number of sectors
-    uint32_t size_max;
-    uint32_t seg_max;
-    struct {
-        uint16_t cylinders;
-        uint8_t heads;
-        uint8_t sectors;
-    } geometry;
-    uint32_t blk_size;
-} __attribute__((packed));
+} __attribute__((packed)) virtio_blk_req;
 
 #define VIRTIO_BLK_SUPPORTED_FEATURES \
     ((1 << 0) | (1 << 1) | (1 << 4))
@@ -72,28 +61,28 @@ bool vblk_find_disk(){
 void* disk_cmd;
 
 void vblk_write(const void *buffer, uint32_t sector, uint32_t count) {
-    if (!disk_cmd) disk_cmd = kalloc(blk_dev.memory_page, sizeof(struct virtio_blk_req), ALIGN_64B, MEM_PRIV_KERNEL);
+    if (!disk_cmd) disk_cmd = kalloc(blk_dev.memory_page, sizeof(virtio_blk_req), ALIGN_64B, MEM_PRIV_KERNEL);
     void* data = kalloc(blk_dev.memory_page, count * 512, ALIGN_64B, MEM_PRIV_KERNEL);
 
     memcpy(data, buffer, count * 512);
 
-    struct virtio_blk_req *req = (struct virtio_blk_req *)(uintptr_t)disk_cmd;
+    virtio_blk_req *req = (virtio_blk_req *)disk_cmd;
     req->type = VIRTIO_BLK_T_OUT;
     req->reserved = 0;
     req->sector = sector;
 
-    virtio_send_3d(&blk_dev, (uintptr_t)disk_cmd, sizeof(struct virtio_blk_req), (uintptr_t)data, count * 512, 0);
+    virtio_send_3d(&blk_dev, (uintptr_t)disk_cmd, sizeof(virtio_blk_req), (uintptr_t)data, count * 512, 0);
 
     kfree((void *)data,count * 512);
 }
 
 void vblk_read(void *buffer, uint32_t sector, uint32_t count) {
-    if (!disk_cmd) disk_cmd = kalloc(blk_dev.memory_page, sizeof(struct virtio_blk_req), ALIGN_64B, MEM_PRIV_KERNEL);
+    if (!disk_cmd) disk_cmd = kalloc(blk_dev.memory_page, sizeof(virtio_blk_req), ALIGN_64B, MEM_PRIV_KERNEL);
 
-    struct virtio_blk_req *req = (struct virtio_blk_req *)disk_cmd;
+    virtio_blk_req *req = (virtio_blk_req *)disk_cmd;
     req->type = VIRTIO_BLK_T_IN;
     req->reserved = 0;
     req->sector = sector;
 
-    virtio_send_3d(&blk_dev, (uintptr_t)disk_cmd, sizeof(struct virtio_blk_req), (uintptr_t)buffer, count * 512, VIRTQ_DESC_F_WRITE);
+    virtio_send_3d(&blk_dev, VIRT_TO_PHYS((uintptr_t)disk_cmd), sizeof(virtio_blk_req), VIRT_TO_PHYS((uintptr_t)buffer), count * 512, VIRTQ_DESC_F_WRITE);
 }

kernel/fw/fw_cfg.c

@@ -2,6 +2,8 @@
 #include "console/kio.h"
 #include "std/memory_access.h"
 #include "memory/mmu.h"
+#include "async.h"
+#include "sysregs.h"
 
 #define FW_CFG_DATA  0x09020000
 #define FW_CFG_CTL   (FW_CFG_DATA + 0x8)
@@ -25,25 +27,26 @@ struct fw_cfg_dma_access {
 
 bool fw_cfg_check(){
     if (checked) return true;
+    register_device_memory(FW_CFG_DATA, FW_CFG_DATA);
     checked = read64(FW_CFG_DATA) == 0x554D4551;
-    if (checked){
-        register_device_memory(FW_CFG_DATA, FW_CFG_DATA);
-    }
+    if (!checked) mmu_unmap(FW_CFG_DATA, FW_CFG_DATA);
     return checked;
 }
 
 void fw_cfg_dma_operation(void* dest, uint32_t size, uint32_t ctrl) {
     struct fw_cfg_dma_access access = {
-        .address = __builtin_bswap64((uint64_t)dest),
+        .address = __builtin_bswap64(VIRT_TO_PHYS((uint64_t)dest)),
         .length = __builtin_bswap32(size),
         .control = __builtin_bswap32(ctrl),
     };
 
-    write64(FW_CFG_DMA, __builtin_bswap64((uint64_t)&access));
+    write64(FW_CFG_DMA, __builtin_bswap64(VIRT_TO_PHYS((uint64_t)&access)));
 
-    __asm__("ISB");
+    __asm__("isb");
 
-    while (__builtin_bswap32(access.control) & ~0x1) {}
+    if (!wait(&access.control, __builtin_bswap32(~0x1), false, 2000)){
+        kprintf("[FW_CFG error] failed to communicate with fw_cfg");
+    }
 
 }
 
@@ -67,7 +70,7 @@ bool fw_find_file(const char* search, struct fw_cfg_file *file) {
         return false;
 
     uint32_t count;
-    fw_cfg_dma_read(&count, sizeof(count), FW_LIST_DIRECTORY);
+    fw_cfg_dma_read(VIRT_TO_PHYS_P(&count), sizeof(count), FW_LIST_DIRECTORY);
 
     count = __builtin_bswap32(count);
 

kernel/graph/drivers/framebuffer_gpus/ramfb_driver/ramfb.cpp

@@ -6,6 +6,7 @@
 #include "std/memory.h"
 #include "theme/theme.h"
 #include "memory/page_allocator.h"
+#include "sysregs.h"
 
 typedef struct {
     uint64_t addr;
@@ -71,7 +72,7 @@ bool RamFBGPUDriver::init(gpu_size preferred_screen_size){
 
 void RamFBGPUDriver::update_gpu_fb(){
     ramfb_structure fb = {
-        .addr = __builtin_bswap64((uintptr_t)framebuffer),
+        .addr = __builtin_bswap64(VIRT_TO_PHYS((uintptr_t)framebuffer)),
         .fourcc = __builtin_bswap32(RGB_FORMAT_ARGB8888),
         .flags = __builtin_bswap32(0),
         .width = __builtin_bswap32(screen_size.width),

kernel/graph/drivers/virtio_gpu_pci/virtio_gpu_pci.cpp

@@ -5,6 +5,7 @@
 #include "std/std.h"
 #include "theme/theme.h"
 #include "memory/page_allocator.h"
+#include "sysregs.h"
 
 #define VIRTIO_GPU_CMD_GET_DISPLAY_INFO         0x0100
 #define VIRTIO_GPU_CMD_RESOURCE_CREATE_2D       0x0101
@@ -72,7 +73,7 @@ bool VirtioGPUDriver::init(gpu_size preferred_screen_size){
     resource_id_counter = 0;
 
     framebuffer_size = screen_size.width * screen_size.height * BPP;
-    framebuffer = (uintptr_t)kalloc(gpu_dev.memory_page, framebuffer_size, ALIGN_4KB, MEM_PRIV_KERNEL);
+    framebuffer = VIRT_TO_PHYS((uintptr_t)kalloc(gpu_dev.memory_page, framebuffer_size, ALIGN_4KB, MEM_PRIV_KERNEL));
 
     ctx = {
         .dirty_rects = {},
@@ -454,7 +455,7 @@ uint32_t VirtioGPUDriver::new_cursor(uint32_t color){
     uint32_t *cursor = (uint32_t*)kalloc(gpu_dev.memory_page, cursor_size, ALIGN_4KB, MEM_PRIV_KERNEL);
     draw_ctx ctx = {{},cursor, 64 * BPP, 64, 64, 0,0};
     fb_draw_cursor(&ctx, color);
-    attach_backing(id, (sizedptr){(uintptr_t)cursor, cursor_size});
+    attach_backing(id, (sizedptr){VIRT_TO_PHYS((uintptr_t)cursor), cursor_size});
     transfer_to_host(id, {{0,0},{64,64}});
     return id;
 }

kernel/graph/tres.cpp

@@ -6,6 +6,7 @@
 #include "syscalls/syscalls.h"
 #include "kernel_processes/windows/launcher.h"
 #include "console/kio.h"
+#include "sysregs.h"
 
 clinkedlist_t *window_list;
 window_frame *focused_window;
@@ -36,7 +37,7 @@ extern "C" void create_window(uint32_t x, uint32_t y, uint32_t width, uint32_t h
     frame->height = height;
     frame->x = x;
     frame->y = y;
-    clinkedlist_push_front(window_list, frame);
+    clinkedlist_push_front(window_list, PHYS_TO_VIRT_P(frame));
     main_gpu_driver->create_window(x,y, width, height, &frame->win_ctx);
     process_t *p = launch_launcher();
     p->win_id = frame->win_id;
@@ -45,6 +46,7 @@ extern "C" void create_window(uint32_t x, uint32_t y, uint32_t width, uint32_t h
 }
 
 int find_window(void *node, void *key){
+    if (!node || !key) return -1;
     window_frame* frame = (window_frame*)node;
     uint16_t wid = *(uint16_t*)key;
     if (frame->win_id == wid) return 0;
@@ -53,7 +55,7 @@ int find_window(void *node, void *key){
 
 void resize_window(uint32_t width, uint32_t height){
     process_t *p = get_current_proc();
-    clinkedlist_node_t *node = clinkedlist_find(window_list, &p->win_id, find_window);
+    clinkedlist_node_t *node = clinkedlist_find(window_list, PHYS_TO_VIRT_P(&p->win_id), (typeof(find_window)*)PHYS_TO_VIRT_P(find_window));
     if (node && node->data){
         window_frame* frame = (window_frame*)node->data;
         main_gpu_driver->resize_window(width, height, &frame->win_ctx);
@@ -65,7 +67,7 @@ void resize_window(uint32_t width, uint32_t height){
 
 void get_window_ctx(draw_ctx* out_ctx){
     process_t *p = get_current_proc();
-    clinkedlist_node_t *node = clinkedlist_find(window_list, &p->win_id, find_window);
+    clinkedlist_node_t *node = clinkedlist_find(window_list, PHYS_TO_VIRT_P(&p->win_id), (typeof(find_window)*)PHYS_TO_VIRT_P(find_window));
     if (node && node->data){
         window_frame* frame = (window_frame*)node->data;
         *out_ctx = frame->win_ctx;
@@ -76,7 +78,7 @@ void get_window_ctx(draw_ctx* out_ctx){
 void commit_frame(draw_ctx* frame_ctx, window_frame* frame){
     if (!frame){
         process_t *p = get_current_proc();
-        clinkedlist_node_t *node = clinkedlist_find(window_list, &p->win_id, find_window);
+        clinkedlist_node_t *node = clinkedlist_find(window_list, PHYS_TO_VIRT_P(&p->win_id), (typeof(find_window)*)PHYS_TO_VIRT_P(find_window));
         if (!node || !node->data) return;
         frame = (window_frame*)node->data;
     }
@@ -120,7 +122,7 @@ void commit_frame(draw_ctx* frame_ctx, window_frame* frame){
 }
 
 void set_window_focus(uint16_t win_id){
-    clinkedlist_node_t *node = clinkedlist_find(window_list, &win_id, find_window);
+    clinkedlist_node_t *node = clinkedlist_find(window_list, PHYS_TO_VIRT_P(&win_id), (typeof(find_window)*)PHYS_TO_VIRT_P(find_window));
     if (!node || !node->data) return;
     focused_window = (window_frame*)node->data;
     dirty_windows = true;

kernel/hw/hw.c

@@ -1,6 +1,7 @@
 #include "hw.h"
 #include "console/kio.h"
 #include "gpio.h"
+#include "sysregs.h"
 
 uint8_t BOARD_TYPE;
 uint8_t RPI_BOARD;
@@ -88,6 +89,18 @@ void detect_hardware(){
     }
 }
 
+void hw_high_va(){
+    if (UART0_BASE) UART0_BASE |= HIGH_VA;
+    if (MMIO_BASE) MMIO_BASE |= HIGH_VA;
+    if (BOARD_TYPE != 1 && PCI_BASE)//virt is probably doing some weird PCI address stuff already
+        PCI_BASE |= HIGH_VA;
+    if (GICD_BASE) GICD_BASE |= HIGH_VA;
+    if (GICC_BASE) GICC_BASE |= HIGH_VA;
+    if (MAILBOX_BASE) MAILBOX_BASE |= HIGH_VA;
+    if (SDHCI_BASE) SDHCI_BASE |= HIGH_VA;
+    if (XHCI_BASE) XHCI_BASE |= HIGH_VA;
+}
+
 void print_hardware(){
     kprintf("Board type %i",BOARD_TYPE);
 }

kernel/hw/hw.h

@@ -38,4 +38,5 @@ extern uint32_t MSI_OFFSET;
 extern uintptr_t LOWEST_ADDR;
 
 void detect_hardware();
-void print_hardware();
+void print_hardware();
+void hw_high_va();

kernel/input/dwc2.cpp

@@ -36,6 +36,8 @@ bool DWC2Driver::init() {
 
     use_interrupts = false;
 
+    register_device_memory(DWC2_BASE, DWC2_BASE);
+
     dwc2 = (dwc2_regs*)DWC2_BASE;
     host = (dwc2_host*)(DWC2_BASE + 0x400);