NJU-ProjectN/abstract-machine ics2023 initialized

NJU-ProjectN/abstract-machine 3348db971fd860be5cb28e21c18f9d0e65d0c96a Merge pull request #8 from Jasonyanyusong/master

abstract-machine/am/src/x86/nemu/cte.c

@@ -0,0 +1,67 @@
+#include <am.h>
+#include <x86/x86.h>
+#include <klib.h>
+
+#define NR_IRQ         256     // IDT size
+#define SEG_KCODE      1
+#define SEG_KDATA      2
+
+static Context* (*user_handler)(Event, Context*) = NULL;
+
+void __am_irq0();
+void __am_vecsys();
+void __am_vectrap();
+void __am_vecnull();
+
+
+Context* __am_irq_handle(Context *c) {
+  if (user_handler) {
+    Event ev = {0};
+    switch (c->irq) {
+      default: ev.event = EVENT_ERROR; break;
+    }
+
+    c = user_handler(ev, c);
+    assert(c != NULL);
+  }
+
+  return c;
+}
+
+bool cte_init(Context*(*handler)(Event, Context*)) {
+  static GateDesc32 idt[NR_IRQ];
+
+  // initialize IDT
+  for (unsigned int i = 0; i < NR_IRQ; i ++) {
+    idt[i]  = GATE32(STS_TG, KSEL(SEG_KCODE), __am_vecnull, DPL_KERN);
+  }
+
+  // ----------------------- interrupts ----------------------------
+  idt[32]   = GATE32(STS_IG, KSEL(SEG_KCODE), __am_irq0,    DPL_KERN);
+  // ---------------------- system call ----------------------------
+  idt[0x80] = GATE32(STS_TG, KSEL(SEG_KCODE), __am_vecsys,  DPL_USER);
+  idt[0x81] = GATE32(STS_TG, KSEL(SEG_KCODE), __am_vectrap, DPL_KERN);
+
+  set_idt(idt, sizeof(idt));
+
+  // register event handler
+  user_handler = handler;
+
+  return true;
+}
+
+
+Context* kcontext(Area kstack, void (*entry)(void *), void *arg) {
+  return NULL;
+}
+
+void yield() {
+  asm volatile("int $0x81");
+}
+
+bool ienabled() {
+  return false;
+}
+
+void iset(bool enable) {
+}

abstract-machine/am/src/x86/nemu/start.S

@@ -0,0 +1,8 @@
+.section entry, "ax"
+.globl _start
+.type _start, @function
+
+_start:
+  mov $0, %ebp
+  mov $_stack_pointer, %esp
+  call _trm_init                 # never return

abstract-machine/am/src/x86/nemu/trap.S

@@ -0,0 +1,22 @@
+#----|------------entry------------|---irq id---|-----handler-----|
+.globl __am_vecsys;    __am_vecsys: pushl $0x80; jmp __am_asm_trap
+.globl __am_vectrap;  __am_vectrap: pushl $0x81; jmp __am_asm_trap
+.globl __am_irq0;        __am_irq0: pushl   $32; jmp __am_asm_trap
+.globl __am_vecnull;  __am_vecnull: pushl   $-1; jmp __am_asm_trap
+
+
+__am_asm_trap:
+  pushal
+
+  pushl $0
+
+  pushl %esp
+  call __am_irq_handle
+
+  addl $4, %esp
+
+  addl $4, %esp
+  popal
+  addl $4, %esp
+
+  iret

abstract-machine/am/src/x86/nemu/vme.c

@@ -0,0 +1,64 @@
+#include <am.h>
+#include <nemu.h>
+#include <klib.h>
+
+static AddrSpace kas = {};
+static void* (*pgalloc_usr)(int) = NULL;
+static void (*pgfree_usr)(void*) = NULL;
+static int vme_enable = 0;
+
+static Area segments[] = {      // Kernel memory mappings
+  NEMU_PADDR_SPACE
+};
+
+#define USER_SPACE RANGE(0x40000000, 0xc0000000)
+
+bool vme_init(void* (*pgalloc_f)(int), void (*pgfree_f)(void*)) {
+  pgalloc_usr = pgalloc_f;
+  pgfree_usr = pgfree_f;
+
+  kas.ptr = pgalloc_f(PGSIZE);
+
+  int i;
+  for (i = 0; i < LENGTH(segments); i ++) {
+    void *va = segments[i].start;
+    for (; va < segments[i].end; va += PGSIZE) {
+      map(&kas, va, va, 0);
+    }
+  }
+
+  set_cr3(kas.ptr);
+  set_cr0(get_cr0() | CR0_PG);
+  vme_enable = 1;
+
+  return true;
+}
+
+void protect(AddrSpace *as) {
+  PTE *updir = (PTE*)(pgalloc_usr(PGSIZE));
+  as->ptr = updir;
+  as->area = USER_SPACE;
+  as->pgsize = PGSIZE;
+  // map kernel space
+  memcpy(updir, kas.ptr, PGSIZE);
+}
+
+void unprotect(AddrSpace *as) {
+}
+
+void __am_get_cur_as(Context *c) {
+  c->cr3 = (vme_enable ? (void *)get_cr3() : NULL);
+}
+
+void __am_switch(Context *c) {
+  if (vme_enable && c->cr3 != NULL) {
+    set_cr3(c->cr3);
+  }
+}
+
+void map(AddrSpace *as, void *va, void *pa, int prot) {
+}
+
+Context* ucontext(AddrSpace *as, Area kstack, void *entry) {
+  return NULL;
+}