System services in userspace

Makefile

@@ -11,7 +11,7 @@ endif
 
 .PHONY: all shared user kernel clean raspi virt run debug dump prepare-fs help install
 
-all: kshared modules kernel shared user tools libs docs
+all: kshared modules kernel shared user tools libs services docs
 	@echo "Build complete."
 	./createfs
 
@@ -33,6 +33,9 @@ kernel: kshared modules
 tools: shared libs prepare-fs
 	$(MAKE) -C tools
 
+services: shared libs prepare-fs
+	$(MAKE) -C services
+
 libs: shared
 	$(MAKE) -C libs
 
@@ -50,6 +53,7 @@ clean:
 	$(MAKE) -C tools  $@
 	$(MAKE) -C modules $@
 	$(MAKE) -C libs $@
+	$(MAKE) -C services $@
 	@echo "removing images"
 	$(RM) kernel.img kernel.elf dump
 
@@ -72,6 +76,7 @@ dump:
 	$(ARCH)objdump -S -D kernel.elf > dump
 	$(MAKE) -C user $@
 	$(MAKE) -C tools $@
+	$(MAKE) -C services $@
 
 install:
 	$(MAKE) clean

kernel/filesystem/fat32.cpp

@@ -402,7 +402,7 @@ u32 FAT32FS::alloc_fat(){
 
 f32_walk_result FAT32FS::read_entry_handler(FAT32FS *instance, f32file_entry *entry, char *filename, const char *seek) {
     if (entry->flags.volume_id) return {};
-    
+
     size_t name_len = strlen_max(filename, 0);
     int matched = strstart_case(seek, filename, true);
     if (matched != (int)name_len) return {};
@@ -417,7 +417,7 @@ f32_walk_result FAT32FS::read_entry_handler(FAT32FS *instance, f32file_entry *en
     uint32_t bpc = bps * spc;
     uint32_t count = entry->filesize > 0 ? ((entry->filesize + bpc - 1) / bpc) : instance->count_FAT(filecluster);
 
-    if (entry->flags.directory) return instance->walk_directory(count, filecluster, next, read_entry_handler);
+    if (entry->flags.directory && *next) return instance->walk_directory(count, filecluster, next, read_entry_handler);
     if (*next != '\0') return {};
     return {.entry = *entry, .cluster = 0, .offset = 0, .found = true};
 }
@@ -703,6 +703,7 @@ system_module boot_fs_module = (system_module){
     .truncate = boot_truncate,
     .getstat = boot_stat,
     .readdir = boot_partition_readdir,
+    .transform = 0,
     .alias_info = {}
 };
 

kernel/filesystem/filesystem.c

@@ -57,9 +57,11 @@ FS_RESULT open_file_global(module_root *root, const char* path, file* descriptor
     FS_RESULT result = FS_RESULT_DRIVER_ERROR;
     if (mod->owner != get_kernel_proc()->id){
         job_make(job_open, mod, {
+            //TODO: here, out_mod is in the stack, and we're referencing it through a pointer, which we of course lose as we move the stack the first time.
             job_serialize_str(&app, 0, search_path);
             job_serialize_fd(&app, 1, descriptor, copy_on_end);
         });
+        *out_mod = mod;
         return j_ret;
     } else {
         result = mod->open(search_path, descriptor);
@@ -141,6 +143,28 @@ size_t read_file(file *descriptor, char* buf, size_t size){
     return amount_read;
 }
 
+size_t transform_file(module_root *root, const char* path, void* buf, size_t size){
+    const char *search_path = path;
+    if (*search_path == '/') search_path++;
+    if (!*search_path) return FS_RESULT_NOTFOUND;
+    system_module *mod = get_module_from(root, &search_path);
+    if (!mod) return FS_RESULT_NOTFOUND;
+    if (!mod->transform) return FS_RESULT_NOTFOUND;
+    FS_RESULT result = FS_RESULT_DRIVER_ERROR;
+    if (mod->owner != get_kernel_proc()->id){
+        job_make(job_transform, mod, {
+            job_serialize_str(&app, 0, search_path);
+            job_serialize_buf(&app, 1, true, (void*)buf, size, copy_on_start | copy_on_end);
+        });
+        return j_ret;
+    } else {
+        result = mod->transform(search_path, buf, size);
+    }
+    if (result != FS_RESULT_SUCCESS) return result;
+    if (!open_files) return FS_RESULT_DRIVER_ERROR;
+    return FS_RESULT_SUCCESS;
+}
+
 void close_file(file *descriptor){
     if (!open_files || !descriptor) return;
     open_file_descriptors *ofile = 0;

kernel/filesystem/filesystem.h

@@ -13,6 +13,7 @@ FS_RESULT open_file_global(module_root *root, const char* path, file* descriptor
 FS_RESULT open_file(module_root *root, const char* path, file* descriptor);
 FS_RESULT instance_local_fd(system_module *mod, file *descriptor);
 size_t read_file(file *descriptor, char* buf, size_t size);
+size_t transform_file(module_root *root, const char* path, void* buf, size_t size);
 size_t write_file(file *descriptor, const char* buf, size_t size);
 void close_file_global(file *descriptor, system_module *mod);
 void close_file(file *descriptor);

kernel/filesystem/virtio_9p_pci.cpp

@@ -606,6 +606,7 @@ system_module p9_fs_module = (system_module){
     .truncate = shared_truncate,
     .getstat = shared_stat,
     .readdir = shared_readdir,
+    .transform = 0,
     .alias_info = {}
 };
 

kernel/kernel_processes/boot/bootprocess.c

@@ -6,16 +6,17 @@
 #include "input/input_dispatch.h"
 #include "usb/usb.h"
 #include "graph/graphics.h"
-#include "exceptions/exception_handler.h"
 #include "kernel_processes/boot/screensaver.h"
 #include "kernel_processes/boot/login_screen.h"
 #include "kernel_processes/windows/dos.h"
 #include "tools/tools.h"
+#include "files/helpers.h"
 
 enum {
     bsm_none,
     bsm_screensaver,
     bsm_login,
+    bsm_services,
     bsm_userland
 } boot_state;
 
@@ -27,12 +28,25 @@ void visual_init(){
     mouse_config((gpu_point){(i32)screen_size.width/2,(i32)screen_size.height/2}, screen_size);
 }
 
+void load_service(const char *directory, const char *service){
+    if (strlen(service) && *service == '.') return;
+    string full_name = string_format("%s/%s",directory,service);
+    process_t *proc = execute(full_name.data, 0, 0, EXEC_MODE_KEEP_FOCUS);
+    string_free(full_name);
+    if (!proc) print("[BOOT error] failed to load service %s",service);
+}
+
 void bootsm_transition(int new_state){
     boot_state = new_state;
     switch (boot_state) {
         case bsm_none: break;
         case bsm_screensaver: current_proc = start_screensaver(); break;
         case bsm_login: current_proc = present_login(); break;
+        case bsm_services: {
+            traverse_directory("/boot/redos/services", false, load_service);
+            current_proc = 0;
+            break;
+        }
         case bsm_userland: {
             if (system_config.headless || !system_config.use_windows){
                 const char *argv = system_config.headless ? "headless" : "";
@@ -55,9 +69,10 @@ void bootsm_advance(){
                 bootsm_transition(bsm_screensaver);
                 break;
             }
-            bootsm_transition(bsm_userland); break;
-        case bsm_screensaver: bootsm_transition(bsm_userland); break;
-        case bsm_login: bootsm_transition(system_config.headless ? bsm_userland : bsm_screensaver); break;
+            bootsm_transition(bsm_services); break;
+        case bsm_screensaver: bootsm_transition(bsm_services); break;
+        case bsm_login: bootsm_transition(system_config.headless ? bsm_services : bsm_screensaver); break;
+        case bsm_services: bootsm_transition(bsm_userland); break;
         case bsm_userland: bootsm_transition(bsm_none); break;
     }
 }

kernel/memory/mmu.c

@@ -38,8 +38,6 @@ static uintptr_t *kernel_ttbr1;
 static uint64_t kernel_ttbr0_hw;
 
 static bool mmu_verbose;
-static inline void mmu_flush_icache();
-static inline void mmu_flush_all();
 
 
 static uint64_t asid_shift;
@@ -296,24 +294,6 @@ void mmu_map_4kb(uint64_t *table, uint64_t va, uint64_t pa, uint64_t attr_index,
     l3[l3_index] = want;
 }
 
-static inline void mmu_flush_all() {
-    asm volatile (
-        "dsb ishst\n"        // Ensure all memory accesses complete
-        "tlbi vmalle1is\n"   // Invalidate all EL1 TLB entries (Inner Shareable)
-        "dsb ish\n"          // Ensure completion of TLB invalidation
-        "isb\n"              // Synchronize pipeline
-        ::: "memory"
-    );
-}
-
-static inline void mmu_flush_icache() {
-    asm volatile (
-        "ic iallu\n"         // Invalidate all instruction caches to PoU
-        "isb\n"              // Ensure completion before continuing
-        ::: "memory"
-    );
-}
-
 uintptr_t* mmu_default_ttbr(){
     return kernel_ttbr1;
 }
@@ -503,10 +483,7 @@ void mmu_init() {
     page_alloc_enable_high_va();
     kernel_ttbr0_hw = pt_va_to_pa(kernel_ttbr0) & PTE_ADDR_MASK;
 
-    uint64_t ttbr1_pa = pt_va_to_pa(kernel_ttbr1) & PTE_ADDR_MASK;
-    asm volatile("msr ttbr1_el1, %0" :: "r"(ttbr1_pa));
-    asm volatile("dsb ish");
-    asm volatile("isb");
+    mmu_swap_kttbr(0);
 
     mmu_swap_ttbr(0);
 
@@ -538,6 +515,12 @@ void mmu_copy(uintptr_t *new_ttbr, uintptr_t *old_ttbr, int level){
     }
 }
 
+bool mmu_replace(uptr *table, uptr va, uptr new_pa){
+    mmu_unmap_and_get_pa(table, va, 0);
+    mmu_map_4kb(table, va, new_pa, MAIR_IDX_NORMAL, MEM_RW | MEM_NORM, MEM_PRIV_KERNEL);
+    return true;
+}
+
 typedef struct {
     uintptr_t *table;
     int level;
@@ -722,6 +705,44 @@ uintptr_t mmu_translate(uint64_t *root, uintptr_t va, int *status){
     return (uintptr_t)((e3 & PTE_ADDR_MASK) | ((uint64_t)va & (GRANULE_4KB - 1)));
 }
 
+//TODO: let's use this everywhere, to make code more readable
+typedef union {
+    struct {
+        u64 vb: 1;//Validity descriptor
+        u64 tb: 1;//Table descriptor
+        u64 indx: 2;//Index into MAIR
+        u64 ns: 1;
+        u64 ap: 2;
+        u64 sh: 2;
+        u64 af: 1;
+        u64 rsvd3: 2;
+        u64 addr: 36;
+        u64 rsvd2: 5;
+        u64 pxn: 1;
+        u64 uxn: 1;
+        u64 sw: 4;
+        u64 rsvd: 5;
+    };
+    u64 entry;
+}
+mmu_entry_t;
+
+void mmu_print_entry(mmu_entry_t entry){
+    print("=========");
+    print("MMU entry %llb",entry);
+    print("UXN: %b",entry.uxn);
+    print("PXN: %b",entry.pxn);    
+    print("ADDR: %llx",entry.addr);
+    print("AF: %b",entry.af);
+    print("SH: %b",entry.sh);
+    print("AP: %b",entry.ap);
+    print("NS: %b",entry.ns);
+    print("INDX: %i",entry.indx);
+    print("TB: %b",entry.tb);
+    print("VB: %b",entry.vb);
+    print("=========");
+}
+
 void debug_mmu_address(uint64_t va){
     int tr = 0;
     uintptr_t pa = mmu_translate(0, (uintptr_t)va, &tr);
@@ -771,7 +792,7 @@ void debug_mmu_address(uint64_t va){
 
     if ((e2 & 0b11) == PD_BLOCK) {
         kprintf("Mapped as 2MB memory in L3");
-        kprintf("Entry: %b", (uint64_t)e2);
+        mmu_print_entry((mmu_entry_t){ .entry = e2 });
         return;
     }
 
@@ -786,7 +807,7 @@ void debug_mmu_address(uint64_t va){
         kprintf("L4 Table entry missing");
         return;
     }
-    kprintf("Entry: %b", e3);
+    mmu_print_entry((mmu_entry_t){.entry = e3});
     return;
 }
 
@@ -803,6 +824,11 @@ void mmu_ttbr0_enable_user() {
     asm volatile("dsb ish\n\tisb" ::: "memory");
 }
 
+void mmu_swap_kttbr(uptr *ttbr){
+    uint64_t ttbr1_pa = pt_va_to_pa(ttbr ?: kernel_ttbr1);
+    asm volatile("msr ttbr1_el1, %0" :: "r"(ttbr1_pa));
+}
+
 void mmu_swap_ttbr(mm_struct *mm){
     if (mm && mm->ttbr0) {
         pttbr = mm->ttbr0;

kernel/memory/mmu.h

@@ -45,6 +45,7 @@ void mmu_map_4kb(uint64_t *table, uint64_t va, uint64_t pa, uint64_t attr_index,
 void mmu_unmap_table(uint64_t *table, uint64_t va, uint64_t pa);
 void debug_mmu_address(uint64_t va);
 void mmu_enable_verbose();
+void mmu_swap_kttbr(uptr *ttbr);
 void mmu_swap_ttbr(mm_struct *mm);
 void mmu_ttbr0_disable_user();
 void mmu_ttbr0_enable_user();
@@ -53,6 +54,8 @@ void mmu_asid_ensure(mm_struct *mm);
 void mmu_asid_release(mm_struct *mm);
 bool mmu_unmap_and_get_pa(uint64_t *table, uint64_t va, uint64_t *pa);
 bool mmu_set_access_flag(uint64_t *table, uint64_t va);
+void mmu_copy(uintptr_t *new_ttbr, uintptr_t *old_ttbr, int level);
+bool mmu_replace(uptr *ttbr, uptr va, uptr new_pa);
 uintptr_t* mmu_default_ttbr();
 void mmu_free_ttbr(uintptr_t *ttbr);
 uintptr_t mmu_translate(uint64_t *root, uintptr_t va, int *status);
@@ -63,4 +66,22 @@ void mmu_map_all(paddr_t pa);
 
 
 void mmu_unmap(uint64_t va, uint64_t pa);
-void mmu_init_kernel();
+void mmu_init_kernel();
+
+static inline void mmu_flush_all() {
+    asm volatile (
+        "dsb ishst\n"        // Ensure all memory accesses complete
+        "tlbi vmalle1is\n"   // Invalidate all EL1 TLB entries (Inner Shareable)
+        "dsb ish\n"          // Ensure completion of TLB invalidation
+        "isb\n"              // Synchronize pipeline
+        ::: "memory"
+    );
+}
+
+static inline void mmu_flush_icache() {
+    asm volatile (
+        "ic iallu\n"         // Invalidate all instruction caches to PoU
+        "isb\n"              // Ensure completion before continuing
+        ::: "memory"
+    );
+}

kernel/networking/network.cpp

@@ -100,5 +100,6 @@ system_module net_module = (system_module){
     .truncate = 0,
     .getstat = 0,
     .readdir = 0,
+    .transform = 0,
     .alias_info = {}
 };