A102039 lab5

.vscode/settings.json

@@ -1,6 +1,16 @@
 {
     "files.associations": {
         "utils.h": "c",
-        "algorithm": "c"
+        "algorithm": "c",
+        "thread.h": "c",
+        "array": "c",
+        "string_view": "c",
+        "initializer_list": "c",
+        "utility": "c",
+        "*.tcc": "cpp",
+        "functional": "cpp",
+        "fstream": "cpp",
+        "istream": "cpp",
+        "streambuf": "cpp"
     }
 }

Makefile

@@ -21,8 +21,8 @@ clean:
 	rm kernel8.elf kernel8.img src/*.o *.o>/dev/null 2>/dev/null || true
 
 run:
-	qemu-system-aarch64 -M raspi3 -kernel kernel8.img --display none -serial null -serial stdio -s -initrd initramfs.cpio -dtb bcm2710-rpi-3-b-plus.dtb
-
+	# qemu-system-aarch64 -M raspi3 -kernel kernel8.img --display none -serial null -serial stdio -s -initrd initramfs.cpio -dtb bcm2710-rpi-3-b-plus.dtb
+	qemu-system-aarch64 -M raspi3 -kernel kernel8.img -serial null -serial stdio -s -initrd initramfs.cpio -dtb bcm2710-rpi-3-b-plus.dtb
 
 flash:
 	sudo dd if=kernel8.img of=/dev/sdb

a.S

@@ -50,7 +50,7 @@ main_loop:
 	b busy_loop
 
 .macro save_all
-    sub sp, sp, 32 * 9
+    sub sp, sp, 16 * 17
     stp x0, x1, [sp ,16 * 0]
     stp x2, x3, [sp ,16 * 1]
     stp x4, x5, [sp ,16 * 2]
@@ -66,20 +66,30 @@ main_loop:
     stp x24, x25, [sp ,16 * 12]
     stp x26, x27, [sp ,16 * 13]
     stp x28, x29, [sp ,16 * 14]
-    str x30,      [sp, 16 * 15]
+
+    mrs x9, sp_el0
+    stp x30,x9,  [sp, 16 * 15]
     // for nested interrupt
-    mrs x0, spsr_el1
-    mrs x1, elr_el1
-    stp x0,x1, [sp, 16 * 16]
-    ldp x0, x1, [sp ,16 * 0]
+    mrs x9, spsr_el1
+    mrs x10, elr_el1
+    stp x9,x10, [sp, 16 * 16]
+
+    // ldp x0, x1, [sp ,16 * 0]
+
+    // for el0 user stack pointer
+
 
 .endm
 
 // load general registers from stack
 .macro load_all
-    ldp x0,x1,[sp, 16 * 16]
-    msr spsr_el1,x0
-    msr elr_el1,x1
+
+    ldp x30,x9, [sp, 16 * 15]
+    msr sp_el0,x9
+
+    ldp x9,x10,[sp, 16 * 16]
+    msr spsr_el1,x9
+    msr elr_el1,x10
 
     ldp x0, x1, [sp ,16 * 0]
     ldp x2, x3, [sp ,16 * 1]
@@ -96,19 +106,26 @@ main_loop:
     ldp x24, x25, [sp ,16 * 12]
     ldp x26, x27, [sp ,16 * 13]
     ldp x28, x29, [sp ,16 * 14]
-    ldr x30, [sp, 16 * 15]
+    // ldr x30, [sp, 16 * 15]
 
-    add sp, sp, 32 * 9
+    add sp, sp, 16 * 17
 .endm
 
+.global load_eret
+load_eret:
+    load_all
+    eret
+
 exception_handler:
     save_all
+    mov x0,sp
     bl exception_entry
     load_all
     eret
 
 irq_handler:
     save_all
+    mov x0,sp
     bl irq_entry
     load_all
     eret
@@ -188,4 +205,55 @@ core_timer_handler:
   add x0,x0,x0
   // add x0,x0,x1
   msr cntp_tval_el0, x0
-  ret
+  ret
+
+.global switch_to
+switch_to:
+    stp x19, x20, [x0, 16 * 0]
+    stp x21, x22, [x0, 16 * 1]
+    stp x23, x24, [x0, 16 * 2]
+    stp x25, x26, [x0, 16 * 3]
+    stp x27, x28, [x0, 16 * 4]
+    stp fp, lr, [x0, 16 * 5]
+    mov x9, sp
+    str x9, [x0, 16 * 6]
+
+    ldp x19, x20, [x1, 16 * 0]
+    ldp x21, x22, [x1, 16 * 1]
+    ldp x23, x24, [x1, 16 * 2]
+    ldp x25, x26, [x1, 16 * 3]
+    ldp x27, x28, [x1, 16 * 4]
+    ldp fp, lr, [x1, 16 * 5]
+    ldr x9, [x1, 16 * 6]
+    mov sp,  x9
+    msr tpidr_el1, x1
+    ret
+
+.global get_current
+get_current:
+    mrs x0, tpidr_el1
+    ret
+
+.global save_cpu_context
+save_cpu_context:
+    stp x19, x20, [x0, 16 * 0]
+    stp x21, x22, [x0, 16 * 1]
+    stp x23, x24, [x0, 16 * 2]
+    stp x25, x26, [x0, 16 * 3]
+    stp x27, x28, [x0, 16 * 4]
+    stp fp, lr, [x0, 16 * 5]
+    mov x9, sp
+    str x9, [x0, 16 * 6]
+    ret
+
+.global load_cpu_context
+load_cpu_context:
+    ldp x19, x20, [x0, 16 * 0]
+    ldp x21, x22, [x0, 16 * 1]
+    ldp x23, x24, [x0, 16 * 2]
+    ldp x25, x26, [x0, 16 * 3]
+    ldp x27, x28, [x0, 16 * 4]
+    ldp fp, lr, [x0, 16 * 5]
+    ldr x9, [x0, 16 * 6]
+    mov sp,  x9
+    ret

include/cpio.h

@@ -5,7 +5,7 @@
 extern uint32_t* cpio_addr;
 void cpio_ls();
 void cpio_cat();
-unsigned long long cpio_get_addr();
+unsigned long cpio_get_addr(char** filedata,unsigned long* filesize);
 //void* initramfs_callback(fdt_prop* prop,char * name,uint32_t len_prop);
 void* initramfs_start_callback(fdt_prop* prop,char * name,uint32_t len_prop);
 void* initramfs_end_callback(fdt_prop* prop,char * name,uint32_t len_prop);

include/mini_uart.h

@@ -59,6 +59,7 @@ char uart_buf_write_pop();
 void busy_wait_writes(char *s,bool newline);
 void busy_wait_writec(char s);
 void busy_wait_writeint(int i,bool newline);
+void busy_wait_writehex(unsigned long long h,bool newline);
 int is_empty_write();
 int is_empty_read();
 

include/sched.h

@@ -0,0 +1,69 @@
+#ifndef _SCHEDULE_HEADER_
+#define _SCHEDULE_HEADER_
+#define THREAD_STACK_SIZE 4096//4096
+#include "signal.h"
+enum task_state
+{
+    EMPTY,
+    RUNNABLE,
+    WAITING,
+    RUNNING,
+    FINISHED,
+    ZOMBIE,
+};
+typedef struct cpu_context
+{
+    unsigned long x19;
+    unsigned long x20;
+    unsigned long x21;
+    unsigned long x22;
+    unsigned long x23;
+    unsigned long x24;
+    unsigned long x25;
+    unsigned long x26;
+    unsigned long x27;
+    unsigned long x28;
+    unsigned long fp;
+    unsigned long lr;
+    unsigned long sp;
+}cpu_context;
+typedef struct Thread_struct
+{
+    cpu_context cpu_context;
+    enum task_state state;
+    unsigned int id;
+    void* user_stack;
+    void* kernel_stack;
+    struct Thread_struct *next,*prev;
+    // void (*singal_handler[10])();
+    void (*signal_handler[20])();
+    unsigned int signal_count[20];
+    void* signal_ustack;
+    void (*run_handler)();
+    cpu_context saved_context;
+
+}Thread_struct;
+typedef struct task_queue
+{
+    Thread_struct* task;
+    struct task_queue *next,*prev;
+}task_queue;
+
+int thread_create(void (*f)());
+Thread_struct current_thread();
+void schedule();
+void idle();
+void kill_zombie();
+void init_sched();
+void push_thread(Thread_struct*);
+void iter_runqueue();
+void exec_thread();
+void context_switch(Thread_struct* next);
+Thread_struct* pop_thread();
+void thread_exit();
+void thread_exec();
+Thread_struct* get_thread(int);
+void kill_thread(int);
+extern Thread_struct* get_current();
+void raise_signal(int pid,int signal);
+#endif

include/signal.h

@@ -0,0 +1,9 @@
+#ifndef _SIGNAL_HEADER_
+#define _SIGNAL_HEADER_
+#include "syscall.h"
+
+void run_signal(trap_frame*);
+void signal_default_handler(int);
+void sigreturn();
+void signal_registed_handler(void (*handler)());
+#endif

include/syscall.h

@@ -0,0 +1,30 @@
+#ifndef _SYSCALL_HEADER_
+#define _SYSCALL_HEADER_
+
+#define SYS_GETPID          0
+#define SYS_UART_READ       1
+#define SYS_UART_WRITE      2
+#define SYS_EXEC            3
+#define SYS_FORK            4
+#define SYS_EXIT            5
+#define SYS_MBOX_CALL       6
+#define SYS_KILL            7
+
+typedef struct trap_frame{
+    unsigned long long x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
+                       x11, x12, x13, x14, x15, x16, x17, x18, x19, x20,
+                       x21, x22, x23, x24, x25, x26, x27, x28, x29, x30;
+    unsigned long long sp_el0, spsr_el1, elr_el1;
+}trap_frame;
+
+int sys_getpid(trap_frame*);
+unsigned int sys_uart_read(trap_frame*,char buf[],unsigned long long size);
+unsigned int sys_uart_write(trap_frame*,const char* name,unsigned long long size);
+int sys_exec(trap_frame*,const char* name, char *const argv[]);
+int sys_fork(trap_frame*);
+void sys_exit(trap_frame*);
+int sys_mbox_call(trap_frame*,unsigned char ch, unsigned int *mbox);
+void sys_kill(trap_frame*,int pid);
+void signal_register(int signal,void (*handler)());
+void signal_kill(int pid,int signal);
+#endif

include/utils.h

@@ -54,5 +54,14 @@ static inline unsigned int powOf2ToExponent(int n){
     }
     return exp;
 }
+static inline void *
+memcpy (void *dest, const void *src, size_t len)
+{
+  char *d = dest;
+  const char *s = src;
+  while (len--)
+    *d++ = *s++;
+  return dest;
+}
 
 #endif

src/allocator.c

@@ -104,10 +104,10 @@ void* get_freeframe_addr(unsigned int size){
     for (i = 0; i <= MAX_CONTIBLOCK_SIZE; i++)
     {
         if(frame_freelist[i]!=nullptr && BLOCK_SIZE*power(2,i)>=size){
-            writes_uart("Require ");
-            write_int_uart(size,FALSE);
-            writes_uart(" ,Min free block size: ");
-            write_int_uart(BLOCK_SIZE *power(2,i),TRUE);
+            // writes_uart("Require ");
+            // write_int_uart(size,FALSE);
+            // writes_uart(" ,Min free block size: ");
+            // write_int_uart(BLOCK_SIZE *power(2,i),TRUE);
             break;
         }
     }
@@ -154,8 +154,8 @@ void* get_freeframe_addr(unsigned int size){
 
     // frame_freelist[i] = frame_freelist[i]->next;
 
-    writes_uart("Got block size: ");
-    write_int_uart(-frame_array[node->_index]->size,TRUE);
+    // writes_uart("Got block size: ");
+    // write_int_uart(-frame_array[node->_index]->size,TRUE);
     unsigned long long freeframe_addr = ALLOCATOR_START + node->_index*BLOCK_SIZE;
     return (void*)freeframe_addr;
 
@@ -406,10 +406,10 @@ void* get_freechunk_addr(int size){
 void* my_malloc(unsigned int size){
     void* malloc_addr = nullptr;
     if(size<=chunk_size_arr[chunk_arr_len-1]){
-        writes_uart("Chunk malloc ");
+        // writes_uart("Chunk malloc ");
 
         int chunk_size = getBestChunkSize(size);
-        write_int_uart(chunk_size,TRUE);
+        // write_int_uart(chunk_size,TRUE);
         malloc_addr = get_freechunk_addr(chunk_size);
 
         // unsigned int chunk_frame_idx = frameAddrToIdx(malloc_addr);