add injection targets

targets/grub.cfg

@@ -0,0 +1,7 @@
+set timeout=0
+set default=0
+
+menuentry "CoRedOS" {
+	multiboot /boot/system.elf
+	boot
+}

targets/linker.ld

@@ -0,0 +1,82 @@
+/* Kernel entry function */
+ENTRY(_start)
+
+OUTPUT_FORMAT(elf32-i386)
+
+SECTIONS {
+
+    /DISCARD/ : {
+        *(".text.inlined*")
+        *(.comment)
+        *(.eh_frame)
+        *(.note.gnu.build-id)
+    }
+
+    /* Set kernel start address */
+    . = 0x100000;
+
+    /* Code and readonly data */
+    .text : {
+        /* fill gaps with int3 opcode to detect invalid jumps */
+        /* TODO: Crashes */
+        FILL(0xcc)
+
+        /* multiboot header */
+        multiboot_header = .;
+        KEEP (*(".rodata.multiboot"))
+
+        /* /\* fixed address for IRQ handlers *\/ */
+        /* . = 0x1000; */
+
+        /* /\* start of interrupt handlers *\/ */
+        /* _stext_irqs = .; */
+
+        /* /\* IRQ Handlers *\/ */
+        /* KEEP (*(".text.irqhandlers*")) /\* ASM *\/ */
+        /* KEEP (*(".text.irq_handler*")) /\* C *\/ */
+        /* *(".text.isrs*") /\* C *\/ */
+        /* *(".text.isr_*") /\* C *\/ */
+        /* KEEP (*(".text.OSEKOS_ISR*")) */
+        /* KEEP (*(".text.idt")) /\* ASM *\/ */
+
+        /* /\* sysenter handler *\/ */
+        /* KEEP (*(".text.sysenter_syscall")) */
+
+        /* _etext_irqs = .; */
+        /* . += 16; /\* padding after data, workaround for import-trace *\/ */
+
+        KEEP (*(".text.startup"))
+        *(".text*")
+        *(".rodata*")
+    }
+
+    /* Data and Stacks */
+    . = 0x200000;
+    .data : {
+        KEEP (*(".startup_stack"))
+        KEEP (*(".kernel_stack"))
+        *(".data*")
+    }
+
+    /* Uninitialized data */
+    .bss : {
+        _sbss = .;
+        *(.bss*)
+        *(COMMON)
+        _ebss = .;
+    }
+
+    /* Align and mark end of all sections — heap starts here */
+    . = ALIGN(4096);
+    _end = .;
+
+    /* Memory-mapped I/O APIC */
+    _sioapic = 0xFEC00000;
+    ioapic = 0xFEC00000;
+    _eioapic = 0xFEC00FFF;
+
+    /* Memory-mapped Local APIC */
+    _slapic = 0xFEE00000;
+    lapic = 0xFEE00000;
+    _elapic = 0xFEE00FFF;
+}

targets/startup.s

@@ -0,0 +1,110 @@
+## Bare bone boot.s from wiki.osdev.org
+
+# multiboot header
+.section .rodata.multiboot
+.align 4
+
+# magic number
+.long 0x1BADB002
+
+# flags: align, meminfo
+.long 0x3
+
+# checksum: -(magic+flags)
+.long -(0x1BADB002 + 0x3)
+
+# the initial kernel stack
+.section .kernel_stack
+.global os_stack
+.size os_stack, 4096
+
+# NOTE: New Start
+
+# .section .gdt
+# gdt_start:
+#     .quad 0x0000000000000000 # null descriptor
+#     .quad 0x00cf9a000000ffff # code segment descriptor: base=0, limit=4GB, 32-bit code
+#     .quad 0x00cf92000000ffff # data segment descriptor: base=0, limit=4GB, 32-bit data
+# gdt_end:
+#
+# gdt_descriptor:
+#     .word gdt_end - gdt_start - 1 # limit
+#     .long gdt_start # base
+#
+# .section .idt
+# idt_table:
+#     .space 256*8 # 256 entries x 8 bytes each
+# idt_descriptor:
+#     .word 256*8-1 # limit
+#     .long idt_table # base
+
+# NOTE: New End
+
+#.Lstack_bottom:
+os_stack:
+    .byte 0
+    .skip 65565 # 64 KiB
+    # .skip 16384 # 16 KiB
+    # .skip 4094 # 4 KiB
+    .byte 0
+    .Lstack_top:
+
+
+# The linker script specifies _start as the entry point to the kernel and the
+# bootloader will jump to this position once the kernel has been loaded. It
+# doesn't make sense to return from this function as the bootloader is gone.
+.section .text.startup
+.global _start
+.type _start, @function
+_start:
+# NOTE: Old Start
+
+	# Welcome to kernel mode!
+	# To set up a stack, we simply set the esp register to point to the top of
+	# our stack (as it grows downwards).
+	movl $.Lstack_top, %esp
+	# We are now ready to actually execute C code. (see ./startup.cc)
+	call os_main
+
+	# In case the function returns, we'll want to put the computer into an
+	# infinite loop. To do that, we use the clear interrupt ('cli') instruction
+	# to disable interrupts, the halt instruction ('hlt') to stop the CPU until
+	# the next interrupt arrives, and jumping to the halt instruction if it ever
+	# continues execution, just to be safe. We will create a local label rather
+	# than real symbol and jump to there endlessly.
+	cli
+	hlt
+.Lhang:
+	jmp .Lhang
+
+# NOTE: Old End
+
+# NOTE: New Start
+
+#     cli
+#
+#     lgdt gdt_descriptor # GDT
+#     lidt idt_descriptor # IDT Stub
+#
+#     # set up segment registers (flat 32-bit)
+#     movw $0x10, %ax
+#     movw %ax, %ds
+#     movw %ax, %es
+#     movw %ax, %fs
+#     movw %ax, %gs
+#     movw %ax, %ss
+#     movl $.Lstack_top, %esp # set stack
+#
+#     # call main C function
+#     call os_main
+#
+#     cli
+#     hlt
+# .Lhang:
+#     jmp .Lhang
+
+# NOTE: New End
+
+# Set the size of the _start symbol to the current location '.' minus its start.
+# This is useful when debugging or when you implement call tracing.
+.size _start, . - _start

targets/syscalls.c

@@ -0,0 +1,35 @@
+#include <errno.h>
+#include <sys/stat.h>
+
+extern char _end; /* provided by linker script */
+static char *heap_ptr = &_end;
+
+void *sbrk(int incr) {
+  char *prev = heap_ptr;
+  heap_ptr += incr;
+  return prev;
+}
+
+int write(int fd, const char *buf, int len) { return len; }
+
+int read(int fd, char *buf, int len) { return 0; }
+int close(int fd) { return -1; }
+int fstat(int fd, struct stat *st) {
+  st->st_mode = S_IFCHR;
+  return 0;
+}
+int isatty(int fd) { return 1; }
+int lseek(int fd, int offset, int whence) { return 0; }
+void _exit(int status) {
+  while (1)
+    ;
+}
+void exit(int status) {
+  while (1)
+    ;
+}
+int kill(int pid, int sig) {
+  errno = EINVAL;
+  return -1;
+}
+int getpid(void) { return 1; }

targets/wasm-host/baremetal.c

@@ -0,0 +1,74 @@
+#include "bh_platform.h"
+#include "wasm_export.h"
+
+#include "__WASM_ARRAY_FILE__"
+
+#define STACK_SIZE (4 * 1024)
+#define HEAP_SIZE STACK_SIZE
+#define RUNTIME_POOL_SIZE (4 * STACK_SIZE)
+
+int main(int argc, char *argv[]) {
+  char error_buf[128];
+  wasm_module_t module;
+  wasm_module_inst_t module_inst;
+  wasm_function_inst_t func;
+  wasm_exec_env_t exec_env;
+
+  /* initialize the wasm runtime */
+  static char global_heap_buf[RUNTIME_POOL_SIZE];
+  static RuntimeInitArgs init_args;
+  memset(&init_args, 0, sizeof(RuntimeInitArgs));
+
+  init_args.mem_alloc_type = Alloc_With_Pool;
+  init_args.mem_alloc_option.pool.heap_buf = global_heap_buf;
+  init_args.mem_alloc_option.pool.heap_size = sizeof(global_heap_buf);
+  init_args.max_thread_num = 1;
+  if (!wasm_runtime_full_init(&init_args)) {
+    return 1;
+  }
+
+  /* parse the WASM file from buffer and create a WASM module */
+  module = wasm_runtime_load(__WASM_ARRAY__, __WASM_ARRAY_LEN__, error_buf,
+                             sizeof(error_buf));
+
+  if (!module) {
+    return 1;
+  }
+
+  /* create an instance of the WASM module (WASM linear memory is ready) */
+  module_inst = wasm_runtime_instantiate(module, STACK_SIZE, HEAP_SIZE,
+                                         error_buf, sizeof(error_buf));
+
+  if (!module_inst) {
+    return 1;
+  }
+
+  /* lookup a WASM function by its name, the function signature can NULL here */
+  func = wasm_runtime_lookup_function(module_inst, "wasm_module");
+
+  /* create an execution environment to execute arbitrary WASM functions */
+  exec_env = wasm_runtime_create_exec_env(module_inst, STACK_SIZE);
+
+  /* arguments are always transferred in 32-bit element */
+  uint32_t args[1] = {0};
+
+  /* call an arbitrary WASM function */
+  if (!wasm_runtime_call_wasm(exec_env, func, 0, args)) {
+    /* function wasn't called correctly */
+    return 1;
+  }
+
+  /* the return value is stored in args[0] */
+  uint32_t result = args[0];
+
+  wasm_runtime_destroy_exec_env(exec_env);
+  wasm_runtime_deinstantiate(module_inst);
+  wasm_runtime_unload(module);
+  wasm_runtime_destroy();
+
+  if (result == 100) {
+    return 0;
+  } else {
+    return 1;
+  }
+}

targets/wasm-host/fail.c

@@ -0,0 +1,79 @@
+#include "lib.h"
+
+#include "bh_platform.h"
+#include "wasm_export.h"
+
+#include "__WASM_ARRAY_FILE__"
+
+#define STACK_SIZE (4 * 1024)
+#define HEAP_SIZE STACK_SIZE
+#define RUNTIME_POOL_SIZE 4 * STACK_SIZE
+
+MAIN() {
+  char error_buf[128];
+  wasm_module_t module;
+  wasm_module_inst_t module_inst;
+  wasm_function_inst_t func;
+  wasm_exec_env_t exec_env;
+
+  /* initialize the wasm runtime */
+  static char global_heap_buf[RUNTIME_POOL_SIZE];
+  static RuntimeInitArgs init_args;
+  memset(&init_args, 0, sizeof(RuntimeInitArgs));
+
+  init_args.mem_alloc_type = Alloc_With_Pool;
+  init_args.mem_alloc_option.pool.heap_buf = global_heap_buf;
+  init_args.mem_alloc_option.pool.heap_size = sizeof(global_heap_buf);
+  init_args.max_thread_num = 1;
+  if (!wasm_runtime_full_init(&init_args)) {
+    return;
+  }
+
+  /* parse the WASM file from buffer and create a WASM module */
+  module = wasm_runtime_load(__WASM_ARRAY__, __WASM_ARRAY_LEN__, error_buf,
+                             sizeof(error_buf));
+
+  if (!module) {
+    return;
+  }
+
+  /* create an instance of the WASM module (WASM linear memory is ready) */
+  module_inst = wasm_runtime_instantiate(module, STACK_SIZE, HEAP_SIZE,
+                                         error_buf, sizeof(error_buf));
+
+  if (!module_inst) {
+    return;
+  }
+
+  /* lookup a WASM function by its name, the function signature can NULL here */
+  func = wasm_runtime_lookup_function(module_inst, "wasm_module");
+
+  /* create an execution environment to execute arbitrary WASM functions */
+  exec_env = wasm_runtime_create_exec_env(module_inst, STACK_SIZE);
+
+  /* arguments are always transferred in 32-bit element */
+  uint32_t args[1] = {0};
+
+  /* call an arbitrary WASM function */
+  MARKER(start_trace);
+  if (!wasm_runtime_call_wasm(exec_env, func, 0, args)) {
+    /* function wasn't called correctly */
+  }
+  MARKER(stop_trace);
+
+  uint32_t result = args[0];
+
+  /* the return value is stored in args[0] */
+  if (result == 100) {
+    MARKER(ok_marker);
+  } else {
+    MARKER(fail_marker);
+  }
+
+  wasm_runtime_destroy_exec_env(exec_env);
+  wasm_runtime_deinstantiate(module_inst);
+  wasm_runtime_unload(module);
+  wasm_runtime_destroy();
+
+  return;
+}

targets/wasm-host/lib.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#define INLINE __attribute__((always_inline)) inline
+#define NOINLINE __attribute__((noinline))
+
+#define __QUOTE(x) #x
+#define QUOTE(x) __QUOTE(x)
+
+#ifndef ARCH_ASM_CLOBBER_ALL
+#define ARCH_ASM_CLOBBER_ALL "eax", "ebx", "ecx", "edx", "esi", "edi", "ebp"
+#endif
+
+#ifndef MARKER
+#define MARKER(str)                                                            \
+  __asm__ volatile(QUOTE(str) ":"                                              \
+                   : /* no inputs */                                           \
+                   : /* no outputs */                                          \
+                   : "memory", ARCH_ASM_CLOBBER_ALL)
+#endif
+
+#ifndef MAIN
+#define MAIN() void os_main(void)
+#endif
+
+#ifndef POSIX_PRINTF
+#define POSIX_PRINTF(...)
+#endif
+
+typedef __UINT8_TYPE__ uint8_t;
+typedef __UINT16_TYPE__ uint16_t;
+typedef __UINT32_TYPE__ uint32_t;
+
+typedef __INT8_TYPE__ int8_t;
+typedef __INT16_TYPE__ int16_t;
+typedef __INT32_TYPE__ int32_t;

targets/wasm-host/linux.c

@@ -0,0 +1,80 @@
+#include "bh_platform.h"
+#include "wasm_export.h"
+
+#include "__WASM_ARRAY_FILE__"
+#include <stdio.h>
+
+#define STACK_SIZE (4 * 1024)
+#define HEAP_SIZE STACK_SIZE
+#define RUNTIME_POOL_SIZE 4 * STACK_SIZE
+
+int main(int argc, char *argv[]) {
+  char error_buf[128];
+  wasm_module_t module;
+  wasm_module_inst_t module_inst;
+  wasm_function_inst_t func;
+  wasm_exec_env_t exec_env;
+
+  /* initialize the wasm runtime */
+  static char global_heap_buf[RUNTIME_POOL_SIZE];
+  static RuntimeInitArgs init_args;
+  memset(&init_args, 0, sizeof(RuntimeInitArgs));
+
+  // init_args.mem_alloc_type = Alloc_With_System_Allocator;
+  init_args.mem_alloc_type = Alloc_With_Pool;
+  init_args.mem_alloc_option.pool.heap_buf = global_heap_buf;
+  init_args.mem_alloc_option.pool.heap_size = sizeof(global_heap_buf);
+  init_args.max_thread_num = 1;
+  if (!wasm_runtime_full_init(&init_args)) {
+    return 1;
+  }
+
+  /* parse the WASM file from buffer and create a WASM module */
+  module = wasm_runtime_load(__WASM_ARRAY__, __WASM_ARRAY_LEN__, error_buf,
+                             sizeof(error_buf));
+
+  if (!module) {
+    printf("Load failed: %s\n", error_buf);
+    return 1;
+  }
+
+  /* create an instance of the WASM module (WASM linear memory is ready) */
+  module_inst = wasm_runtime_instantiate(module, STACK_SIZE, HEAP_SIZE,
+                                         error_buf, sizeof(error_buf));
+
+  if (!module_inst) {
+    printf("Inst failed: %s\n", error_buf);
+    return 1;
+  }
+
+  /* lookup a WASM function by its name, the function signature can NULL here */
+  func = wasm_runtime_lookup_function(module_inst, "wasm_module");
+
+  /* create an execution environment to execute arbitrary WASM functions */
+  exec_env = wasm_runtime_create_exec_env(module_inst, STACK_SIZE);
+
+  /* arguments are always transferred in 32-bit element */
+  uint32_t args[1] = {0};
+
+  /* call an arbitrary WASM function */
+  if (!wasm_runtime_call_wasm(exec_env, func, 0, args)) {
+    /* function wasn't called correctly */
+    printf("Failed to call function 'wasm_module'!\n");
+  }
+
+  /* the return value is stored in args[0] */
+  uint32_t result = args[0];
+
+  wasm_runtime_destroy_exec_env(exec_env);
+  wasm_runtime_deinstantiate(module_inst);
+  wasm_runtime_unload(module);
+  wasm_runtime_destroy();
+
+  if (result == 100) {
+    printf("OK Marker\n");
+    return 0;
+  } else {
+    printf("FAIL Marker\n");
+    return 1;
+  }
+}

targets/wasm-module/sum.c

@@ -0,0 +1,7 @@
+int wasm_module(void) {
+  int sum = 0;
+  for (int i = 0; i < 100; ++i) {
+    sum += 1;
+  }
+  return sum;
+}