kernel - whatever

kernel/src/fs/vfs.c

@@ -0,0 +1,19 @@
+#include "fs/vfs.h"
+#include "mm/liballoc/liballoc.h"
+#include "mm/memop.h"
+#include "lib/string.h"
+
+vnode_t *vfs_create_node(char *name, vnode_type_t type) {
+    vnode_t *node = (vnode_t *)malloc(sizeof(vnode_t));
+    if (!node) {
+        return NULL;
+    }
+    memset(node, 0, sizeof(vnode_t));
+    strncpy(node->name, name, sizeof(node->name) - 1);
+    node->type = type;
+    node->ops = NULL;
+    //node->parent = NULL;
+    //node->child = NULL;
+    //node->next = NULL;
+    return node;
+}

kernel/src/fs/vfs.h

@@ -11,27 +11,36 @@ struct vnode;
 typedef uint32_t vnode_type_t;
 
 typedef struct vnode_ops {
-    int (*read)(struct vnode* vn, void* buf, size_t size);
+    int (*read)(struct vnode* vn, void* buf, size_t off, size_t size);
+    struct vnode* (*lookup)(struct vnode* vn, const char* name);
 } vnode_ops_t;
 
 typedef struct vnode {
     char name[256];
     vnode_type_t type;
-    struct vnode* parent;
-    struct vnode* child;
-    struct vnode* next;
+    uint32_t refcount;
+    //struct vnode* parent;
+    //struct vnode* child;
+    //struct vnode* next;
 
     struct vnode_ops* ops;
     void* internal;
 } vnode_t;
 
+typedef struct mountpoint {
+    char name[32];
+    struct fs* fs;
+    vnode_t* mountpoint;
+} mountpoint_t;
+
 typedef struct fs {
     char name[32];
-    int (*mount)(struct vnode** root);
+    struct vnode* root;
+    int (*mount)(struct vnode* mountpoint);
 } fs_t;
 
 void vfs_init(void);
 int vfs_mount(char *path, fs_t* fs);
 int vfs_unmount(char *path);
 int vfs_open(const char* path, vnode_t** result);
-int vfs_read(vnode_t* vn, void* buf, size_t size);
+int vfs_read(vnode_t* vn, void* buf, size_t off, size_t size);

kernel/src/fs/vnodes.md

@@ -0,0 +1,2 @@
+# Soaplin vnodes
+...

kernel/src/lib/string.c

@@ -69,3 +69,13 @@ char *strdup(const char *str) {
   strcpy(dup, str);
   return dup;
 }
+
+char *strncpy(char *dest, const char *src, size_t n) {
+  size_t i;
+  for (i = 0; i < n && src[i] != '\0'; i++)
+    dest[i] = src[i];
+  for (; i < n; i++)
+    dest[i] = '\0';
+  return dest;
+}
+

kernel/src/lib/string.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <stddef.h>
 
 int strlen(const char *str);
 int strcmp(const char *s1, const char *s2);
@@ -7,3 +8,4 @@ char *strcpy(char *dest, const char *src);
 char *strrchr(const char *s, int c);
 int oct2bin(unsigned char *str, int size);
 char *strdup(const char *str);
+char *strncpy(char *dest, const char *src, size_t n);

kernel/src/sys/arch/x86_64/interrupts.c

@@ -8,6 +8,7 @@
 #include <stdint.h>
 #include <sys/arch/x86_64/idt.h>
 #include <sys/arch/x86_64/io.h>
+#include <sys/errhnd/panic.h>
 
 int pit_millis = 0;
 int pit_secs = 0;
@@ -19,22 +20,25 @@ void exception_handler(registers_t *regs) {
   vmm_load_pagemap(vmm_kernel_pm);
 
   if (regs->int_no < 32) {
-    log("ints - %d (RIP: %p, ERR: %d)\n", regs->int_no, regs->rip,
-        regs->err_code);
 
-    if (regs->int_no == 0xe && vmm_kernel_pm_exists) {
-      uint64_t cr2;
-      asm("mov %%cr2, %0" : "=r"(cr2));
-      log("ints - PF: Faulting location: %p (%p)\n", cr2,
-          virt_to_phys(vmm_current_pm, cr2));
-      log("ints - PF: Faulting page flags: %p\n",
-          vmm_get_flags(vmm_current_pm, cr2));
-      log("ints - PF: Faulting page map: %p\n", PHYSICAL(vmm_current_pm));
-    }
+    // Should only be called if the exception is unrecoverable.
+    panic_ctx("A CPU exception occured.", regs);
+    //log("ints - %d (RIP: %p, ERR: %d)\n", regs->int_no, regs->rip,
+    //    regs->err_code);
 
-    asm("cli");
-    while (1)
-      asm("hlt");
+    //if (regs->int_no == 0xe && vmm_kernel_pm_exists) {
+    //  uint64_t cr2;
+    //  asm("mov %%cr2, %0" : "=r"(cr2));
+    //  log("ints - PF: Faulting location: %p (%p)\n", cr2,
+    //      virt_to_phys(vmm_current_pm, cr2));
+    //  log("ints - PF: Faulting page flags: %p\n",
+    //      vmm_get_flags(vmm_current_pm, cr2));
+    //  log("ints - PF: Faulting page map: %p\n", PHYSICAL(vmm_current_pm));
+    //}
+
+    //asm("cli");
+    //while (1)
+    //  asm("hlt");
   }
 
   if (regs->int_no == 1 + 32) {

kernel/src/sys/errhnd/panic.c

@@ -1,9 +1,12 @@
 #include "sys/arch/x86_64/idt.h"
+#include <mm/memop.h>
 #include <sys/log.h>
 
 static registers_t __panic_regdump;
 
 static void __panic_dump_regs() {
+  memset(&__panic_regdump, 0, sizeof(registers_t));
+
   asm volatile(
       // Save general purpose registers
       "movq %%r15, %0\n\t"
@@ -44,15 +47,22 @@ static void __panic_dump_regs() {
   __panic_regdump.rflags = 0;
   __panic_regdump.rsp = 0;
   __panic_regdump.ss = 0;
+}
+
+static void __panic_display_regs(registers_t *regs) {
   log("-- REGISTER DUMP --\n");
   log("RDI: %p, RSI: %p, RDX: %p, RCX: %p, R8: %p, R9: %p\n",
-      __panic_regdump.rdi, __panic_regdump.rsi, __panic_regdump.rdx,
-      __panic_regdump.rcx, __panic_regdump.r8, __panic_regdump.r9);
+      regs->rdi, regs->rsi, regs->rdx,
+      regs->rcx, regs->r8, regs->r9);
   log("RAX: %p, RBP: %p, RBX: %p, R10: %p, R11: %p, R12: %p\n",
-      __panic_regdump.rax, __panic_regdump.rbp, __panic_regdump.rbx,
-      __panic_regdump.r10, __panic_regdump.r11, __panic_regdump.r12);
-  log("R13: %p, R14: %p, R15: %p\n", __panic_regdump.r13, __panic_regdump.r14,
-      __panic_regdump.r15);
+      regs->rax, regs->rbp, regs->rbx,
+      regs->r10, regs->r11, regs->r12);
+  log("R13: %p, R14: %p, R15: %p\n", regs->r13, regs->r14,
+      regs->r15);
+  log("RIP: %p, CS: %d, SS: %d, RFLAGS: %d, INTERRUPT: %d, ERROR CODE: %d\n",
+      regs->rip, regs->cs, regs->ss,
+      regs->rflags, regs->int_no, regs->err_code);
+  log("RSP: %p\n", regs->rsp);
 }
 
 void __panic_display_ascii_art() {
@@ -73,6 +83,26 @@ void panic(char *msg) {
   log("\n");
 
   __panic_dump_regs();
+  __panic_display_regs(&__panic_regdump);
+
+  log("System halted: Please restart your computer manually.\n");
+
+  asm("cli");
+  for (;;)
+    asm("hlt");
+}
+
+void panic_ctx(char *msg, registers_t *regs) {
+  __panic_display_ascii_art();
+
+  log("\n");
+  log("%s\n", msg);
+  log("\n");
+
+  if (regs)
+    __panic_display_regs(regs);
+  else
+    log("No register context provided.\n");
 
   log("System halted: Please restart your computer manually.\n");
 

kernel/src/sys/errhnd/panic.h

@@ -1 +1,5 @@
+#pragma once
+
+#include "sys/arch/x86_64/idt.h"
 void panic(char *msg);
+void panic_ctx(char *msg, registers_t *regs);

kernel/src/sys/log.c

@@ -27,7 +27,7 @@ void log(char *format, ...) {
   if (ft_ctx)
     flanterm_write(ft_ctx, buf, strlen(buf));
 
-  /*for (int i = 0;; i++) {
+  for (int i = 0;; i++) {
     if (date[i] == '\0')
       break;
 
@@ -39,7 +39,7 @@ void log(char *format, ...) {
       break;
 
     outb(0xE9, buf[i]);
-  }*/
+  }
 
   // spinlock_release(&log_lock);
 }

kernel/src/sys/syscalls/syscalls_proc.c

@@ -1,6 +1,6 @@
 #include <sched/sched.h>
 
 int syscall_exit(int exit_code) {
-  // sched_exit(exit_code);
+  sched_exit(exit_code);
   return 0;
 }