Merge branch 'rk3568_dev' of https://gitlink.org.cn/tuyuyang/xiuos into rk3568_dev

Ubiquitous/XiZi_AIoT/services/app/simple_server.c

@@ -31,7 +31,6 @@ int IPC_DO_SERVE_FUNC(Ipc_hello_string)(char* buf, int* len)
 }
 
 IPC_SERVER_INTERFACE(Ipc_add, 2);
-//IPC_SERVER_THREAD_INTERFACE(Ipc_add, 2);
 IPC_SERVER_INTERFACE(Ipc_hello_string, 2);
 IPC_SERVER_REGISTER_INTERFACES(IpcSimpleServer, 2, Ipc_hello_string, Ipc_add);
 

Ubiquitous/XiZi_AIoT/services/drivers/3568/Makefile

@@ -1,3 +1,4 @@
-SRC_DIR := 
+
+SRC_DIR := hal
 
 include $(KERNEL_ROOT)/compiler.mk

Ubiquitous/XiZi_AIoT/services/drivers/Makefile

@@ -1,4 +1,4 @@
 
-SRC_DIR :=  $(BOARD) rk-3568
+SRC_DIR :=  $(BOARD) 
 
 include $(KERNEL_ROOT)/compiler.mk

Ubiquitous/XiZi_AIoT/services/drivers/imx6q-sabrelite/enet/Makefile

@@ -9,14 +9,8 @@ ld = ${toolchain}g++
 objdump = ${toolchain}objdump
 user_ldflags = -N -Ttext 0
 
-cflags = -std=c11 -march=armv7-a -mcpu=cortex-a9 -mtune=cortex-a9 -g \
+cflags = -std=c11 -march=armv7-a -mtune=cortex-a9 -nostdlib -nodefaultlibs -mfloat-abi=soft -fno-pic \
-	-Wno-unused -Wno-format -fno-common -ffreestanding -fno-builtin -static \
+	-static -fno-builtin -fno-strict-aliasing -Wall -ggdb -Wno-unused -Werror -fno-omit-frame-pointer -fno-stack-protector -fno-pie 
-	-Wno-unaligned-access -fdce -Wall -Werror -Wno-uninitialized -Wno-strict-aliasing -fdiagnostics-show-option \
-	-mapcs -marm -mfpu=neon -ftree-vectorize -fno-math-errno -funsafe-math-optimizations -fno-signed-zeros -mfloat-abi=softfp \
-	-fno-omit-frame-pointer -fno-stack-protector -fno-pie 
-
-# cflags = -std=c11 -march=armv7-a -mtune=cortex-a9 -nostdlib -nodefaultlibs -mfloat-abi=soft -fno-pic \
-# 	-static -fno-builtin -fno-strict-aliasing -Wall -ggdb -Wno-unused -Werror -fno-omit-frame-pointer -fno-stack-protector -fno-pie 
 
 c_useropts = -O0
 

Ubiquitous/XiZi_AIoT/services/drivers/rk-3568/Makefile

@@ -1,4 +0,0 @@
-
-SRC_DIR := hal
-
-include $(KERNEL_ROOT)/compiler.mk

Ubiquitous/XiZi_AIoT/services/lib/ipc/libipc.c

@@ -182,7 +182,6 @@ void ipc_server_loop(struct IpcNode* ipc_node)
         /* handle each session */
         for (int i = 0; i < NR_MAX_SESSION; i++) {
             if (session_list[i].buf == NULL) {
-                yield(SYS_TASK_YIELD_NO_REASON);
                 break;
             }
             cur_sess_id = session_list[i].id;

Ubiquitous/XiZi_AIoT/services/lib/usyscall/usyscall.c

@@ -101,9 +101,18 @@ int show_cpu()
     return syscall(SYSCALL_SYS_STATE, SYS_STATE_SHOW_CPU_INFO, 0, 0, 0);
 }
 
-int mmap(uintptr_t vaddr, uintptr_t paddr, int len, bool is_dev)
+uintptr_t mmap(uintptr_t vaddr, uintptr_t paddr, int len, bool is_dev)
 {
-    return syscall(SYSCALL_MMAP, vaddr, paddr, (intptr_t)len, (intptr_t)is_dev);
+    uintptr_t vaddr_inner = vaddr, paddr_inner = paddr;
+    if (syscall(SYSCALL_MMAP, (intptr_t)&vaddr_inner, (intptr_t)&paddr_inner, (intptr_t)len, (intptr_t)is_dev) < 0) {
+        return (uintptr_t)NULL;
+    }
+    return vaddr_inner;
+}
+
+int naive_mmap(uintptr_t* vaddr, uintptr_t* paddr, int len, bool is_dev)
+{
+    return syscall(SYSCALL_MMAP, (uintptr_t)vaddr, (intptr_t)paddr, (intptr_t)len, (intptr_t)is_dev);
 }
 
 int register_irq(int irq, int opcode)

Ubiquitous/XiZi_AIoT/services/lib/usyscall/usyscall.h

@@ -44,6 +44,8 @@ typedef enum {
     SYS_STATE_SHOW_TASKS,
     SYS_STATE_SHOW_MEM_INFO,
     SYS_STATE_SHOW_CPU_INFO,
+    SYS_STATE_GET_CURRENT_TICK,
+    SYS_STATE_GET_CURRENT_SECOND,
 } sys_state_option;
 
 typedef enum {
@@ -58,6 +60,8 @@ typedef union {
         uintptr_t memblock_end;
     } memblock_info;
     int priority;
+    uintptr_t current_tick;
+    uintptr_t current_second;
 } sys_state_info;
 
 typedef enum {
@@ -85,7 +89,8 @@ int poll_session(struct Session* userland_session_arr, int arr_capacity);
 int close_session(struct Session* session);
 int register_irq(int irq, int opcode);
 
-int mmap(uintptr_t vaddr, uintptr_t paddr, int len, bool is_dev);
+uintptr_t mmap(uintptr_t vaddr, uintptr_t paddr, int len, bool is_dev);
+int naive_mmap(uintptr_t* vaddr, uintptr_t* paddr, int len, bool is_dev);
 
 int task_heap_base();
 int get_memblock_info(sys_state_info* info);

Ubiquitous/XiZi_AIoT/softkernel/include/memspace.h

@@ -27,8 +27,12 @@ Author: AIIT XUOS Lab
 Modification:
 1. first version
 *************************************************/
+#pragma once
 
-#include "task.h"
+#include "bitmap64.h"
+#include "buddy.h"
+#include "list.h"
+#include "share_page.h"
 
 struct ThreadStackPointer {
     int argc;
@@ -37,6 +41,22 @@ struct ThreadStackPointer {
     uintptr_t user_stack_vaddr;
 };
 
+struct MemSpace {
+    /* task memory resources */
+    struct TopLevelPageDirectory pgdir; // [phy] vm pgtbl base address
+    uintptr_t heap_base; // mem size of proc used(allocated by kernel)
+    uintptr_t mem_size;
+    /* task communication mem resources */
+    struct KBuddy* massive_ipc_allocator;
+
+    /* thread using this memspace */
+    struct bitmap64 thread_stack_idx_bitmap;
+    struct double_list_node thread_list_guard;
+
+    // thread to notify when sub-thread exit
+    struct Thread* thread_to_notify;
+};
+
 struct MemSpace* alloc_memspace();
 void free_memspace(struct MemSpace* pmemspace);
 uintptr_t* load_memspace(struct MemSpace* pmemspace, char* img_start);

Ubiquitous/XiZi_AIoT/softkernel/include/syscall.h

@@ -64,6 +64,8 @@ typedef enum {
     SYS_STATE_SHOW_TASKS,
     SYS_STATE_SHOW_MEM_INFO,
     SYS_STATE_SHOW_CPU_INFO,
+    SYS_STATE_GET_CURRENT_TICK,
+    SYS_STATE_GET_CURRENT_SECOND,
 } sys_state_option;
 
 typedef enum {
@@ -78,6 +80,8 @@ typedef union {
         uintptr_t memblock_end;
     } memblock_info;
     int priority;
+    uintptr_t current_tick;
+    uintptr_t current_second;
 } sys_state_info;
 
 typedef enum {
@@ -102,7 +106,7 @@ int sys_close_session(struct Thread* task, struct Session* session);
 
 int sys_exec(char* img_start, char* name, char** argv);
 int sys_state(sys_state_option option, sys_state_info* info);
-int sys_mmap(uintptr_t vaddr, uintptr_t paddr, int len, int is_dev);
+int sys_mmap(uintptr_t* vaddr, uintptr_t* paddr, int len, int is_dev);
 
 int sys_register_irq(int irq_num, int irq_opcode);
 int sys_unbind_irq_all(struct Thread* task);

Ubiquitous/XiZi_AIoT/softkernel/include/task.h

@@ -31,10 +31,10 @@ Modification:
 
 #include "core.h"
 
-#include "bitmap64.h"
 #include "buddy.h"
 #include "ksemaphore.h"
 #include "list.h"
+#include "memspace.h"
 #include "object_allocator.h"
 #include "pagetable.h"
 #include "share_page.h"
@@ -54,19 +54,6 @@ enum ProcState {
     NEVER_RUN,
 };
 
-struct MemSpace {
-    /* task memory resources */
-    struct TopLevelPageDirectory pgdir; // [phy] vm pgtbl base address
-    uintptr_t heap_base; // mem size of proc used(allocated by kernel)
-    uintptr_t mem_size;
-    /* task communication mem resources */
-    struct KBuddy* massive_ipc_allocator;
-
-    /* thread using this memspace */
-    struct bitmap64 thread_stack_idx_bitmap;
-    struct double_list_node thread_list_guard;
-};
-
 /* Thread Control Block */
 struct ThreadContext {
     struct Thread* task; // process of current thread
@@ -105,8 +92,8 @@ struct Thread {
     /* task communication resources */
     struct double_list_node cli_sess_listhead;
     struct double_list_node svr_sess_listhead;
-    bool current_ipc_handled;
     struct TraceTag server_identifier;
+    bool advance_unblock;
 
     /* task schedule attributes */
     struct double_list_node node;

Ubiquitous/XiZi_AIoT/softkernel/syscall/sys_mmap.c

@@ -36,34 +36,36 @@ Modification:
 #include "syscall.h"
 #include "task.h"
 
-int sys_mmap(uintptr_t vaddr, uintptr_t paddr, int len, int is_dev)
+int sys_mmap(uintptr_t* vaddr, uintptr_t* paddr, int len, int is_dev)
 {
     struct Thread* cur_task = cur_cpu()->task;
     assert(cur_task != NULL);
 
     int true_len = ALIGNUP(len, PAGE_SIZE);
 
-    if (paddr != (uintptr_t)NULL) {
+    if (*paddr != (uintptr_t)NULL) {
-        if (xizi_share_page_manager.task_map_pages(cur_task, vaddr, paddr, true_len / PAGE_SIZE, is_dev) == (uintptr_t)NULL) {
+        if (xizi_share_page_manager.task_map_pages(cur_task, *vaddr, *paddr, true_len / PAGE_SIZE, is_dev) == (uintptr_t)NULL) {
             return -1;
         }
     } else {
         int load_len = 0;
-        uintptr_t load_vaddr = vaddr;
+        uintptr_t load_vaddr = *vaddr;
         while (load_len < true_len) {
-            char* paddr = raw_alloc(PAGE_SIZE);
+            char* new_paddr = raw_alloc(PAGE_SIZE);
-            if (paddr == NULL) {
+            if (new_paddr == NULL) {
                 return -1;
             }
-            if (xizi_share_page_manager.task_map_pages(cur_task, load_vaddr, (uintptr_t)paddr, 1, false) == (uintptr_t)NULL) {
+            if (xizi_share_page_manager.task_map_pages(cur_task, load_vaddr, (uintptr_t)new_paddr, 1, false) == (uintptr_t)NULL) {
-                raw_free(paddr);
+                raw_free(new_paddr);
                 return -1;
             }
             load_vaddr += PAGE_SIZE;
             load_len += PAGE_SIZE;
+            *paddr = (uintptr_t)new_paddr;
         }
     }
 
     cur_task->memspace->mem_size += true_len;
-    return vaddr + true_len;
+    *vaddr = *vaddr + true_len;
+    return 0;
 }

Ubiquitous/XiZi_AIoT/softkernel/syscall/sys_poll_session.c

@@ -70,7 +70,7 @@ int sys_poll_session(struct Session* userland_session_arr, int arr_capacity)
             if (client->state == BLOCKED) {
                 xizi_task_manager.task_unblock(client);
             } else {
-                client->current_ipc_handled = true;
+                client->advance_unblock = true;
             }
         }
         server_session->head = userland_session_arr[i].head;
@@ -120,8 +120,12 @@ int sys_poll_session(struct Session* userland_session_arr, int arr_capacity)
     if (session_idx < arr_capacity) {
         userland_session_arr[session_idx].buf = NULL;
         if (!has_middle_delete && nr_sessions_need_to_handle == 0) {
-            xizi_task_manager.task_yield_noschedule(cur_task, false);
+            if (cur_task->advance_unblock) {
-            xizi_task_manager.task_block(&xizi_task_manager.task_blocked_list_head, cur_task);
+                cur_task->advance_unblock = false;
+            } else {
+                xizi_task_manager.task_yield_noschedule(cur_task, false);
+                xizi_task_manager.task_block(&xizi_task_manager.task_blocked_list_head, cur_task);
+            }
         }
     }
 

Ubiquitous/XiZi_AIoT/softkernel/syscall/sys_state.c

@@ -151,19 +151,39 @@ void show_cpu(void)
 
 int sys_state(sys_state_option option, sys_state_info* info)
 {
-    if (option == SYS_STATE_MEMBLOCK_INFO) {
+    switch (option) {
+    case SYS_STATE_MEMBLOCK_INFO: {
         info->memblock_info.memblock_start = (uintptr_t)V2P(_binary_fs_img_start);
         info->memblock_info.memblock_end = (uintptr_t)V2P(_binary_fs_img_end);
-    } else if (option == SYS_STATE_GET_HEAP_BASE) {
+        break;
+    }
+    case SYS_STATE_GET_HEAP_BASE:
         return cur_cpu()->task->memspace->heap_base;
-    } else if (option == SYS_STATE_SET_TASK_PRIORITY) {
+    case SYS_STATE_SET_TASK_PRIORITY:
         xizi_task_manager.set_cur_task_priority(info->priority);
-    } else if (option == SYS_STATE_SHOW_TASKS) {
+        break;
+    case SYS_STATE_SHOW_TASKS:
         show_tasks();
-    } else if (option == SYS_STATE_SHOW_MEM_INFO) {
+        break;
+    case SYS_STATE_SHOW_MEM_INFO:
         show_mem();
-    } else if (option == SYS_STATE_SHOW_CPU_INFO) {
+        break;
+    case SYS_STATE_SHOW_CPU_INFO:
         show_cpu();
+        break;
+    case SYS_STATE_GET_CURRENT_TICK: {
+        extern void hw_current_tick(uintptr_t * tick);
+        hw_current_tick(&info->current_tick);
+        break;
+    }
+    case SYS_STATE_GET_CURRENT_SECOND: {
+        extern void hw_current_second(uintptr_t * tick);
+        hw_current_second(&info->current_second);
+        break;
+    }
+    case SYS_STATE_TEST:
+    default:
+        break;
     }
 
     return 0;

Ubiquitous/XiZi_AIoT/softkernel/syscall/sys_thread.c

@@ -65,6 +65,11 @@ int sys_new_thread(struct MemSpace* pmemspace, struct Thread* task, uintptr_t en
     // init pcb schedule attributes
     xizi_task_manager.task_set_default_schedule_attr(task);
 
+    // thread init done by here
+    if (pmemspace->thread_to_notify == NULL) {
+        pmemspace->thread_to_notify = task;
+    }
+
     return task->tid;
 }
 

Ubiquitous/XiZi_AIoT/softkernel/syscall/sys_yield.c

@@ -40,8 +40,8 @@ int sys_yield(task_yield_reason reason)
 
     // handle ipc block
     if ((reason & SYS_TASK_YIELD_BLOCK_IPC) != 0) {
-        if (cur_task->current_ipc_handled) {
+        if (cur_task->advance_unblock) {
-            cur_task->current_ipc_handled = false;
+            cur_task->advance_unblock = false;
         } else {
             xizi_task_manager.task_block(&xizi_task_manager.task_blocked_list_head, cur_task);
         }

Ubiquitous/XiZi_AIoT/softkernel/syscall/syscall.c

@@ -69,7 +69,7 @@ int syscall(int sys_num, uintptr_t param1, uintptr_t param2, uintptr_t param3, u
         ret = sys_state(param1, (sys_state_info*)param2);
         break;
     case SYSCALL_MMAP:
-        ret = sys_mmap(param1, param2, (int)param3, (int)param4);
+        ret = sys_mmap((uintptr_t*)param1, (uintptr_t*)param2, (int)param3, (int)param4);
         break;
     case SYSCALL_REGISTER_IRQ:
         ret = sys_register_irq((int)param1, (int)param2);

Ubiquitous/XiZi_AIoT/softkernel/task/memspace.c

@@ -55,6 +55,7 @@ struct MemSpace* alloc_memspace()
     pmemspace->heap_base = 0;
     pmemspace->mem_size = 0;
     pmemspace->pgdir.pd_addr = 0;
+    pmemspace->thread_to_notify = NULL;
     return pmemspace;
 }
 

Ubiquitous/XiZi_AIoT/softkernel/task/task.c

@@ -179,6 +179,19 @@ static void _dealloc_task_cb(struct Thread* task)
 
     /* free memspace if needed to */
     if (task->memspace != NULL) {
+        // awake deamon in this memspace
+        if (task->memspace->thread_to_notify != NULL) {
+            if (task->memspace->thread_to_notify != task) {
+                if (task->memspace->thread_to_notify->state == BLOCKED) {
+                    xizi_task_manager.task_unblock(task->memspace->thread_to_notify);
+                } else {
+                    task->memspace->thread_to_notify->advance_unblock = true;
+                }
+            } else if (task->memspace->thread_to_notify == task) {
+                task->memspace->thread_to_notify = NULL;
+            }
+        }
+
         doubleListDel(&task->memspace_list_node);
         /* free memspace if thread is the last one using it */
         if (IS_DOUBLE_LIST_EMPTY(&task->memspace->thread_list_guard)) {

Ubiquitous/XiZi_AIoT/softkernel/trap/clock_irq_handler.c

@@ -44,6 +44,24 @@ bool clock_intr_handler_init(struct TraceTag* p_clock_driver_tag)
     return p_clock_driver != NULL;
 }
 
+void hw_current_tick(uintptr_t* tick)
+{
+    if (p_clock_driver == NULL) {
+        *tick = 0;
+        return;
+    }
+    *tick = p_clock_driver->get_tick();
+}
+
+void hw_current_second(uintptr_t* second)
+{
+    if (p_clock_driver == NULL) {
+        *second = 0;
+        return;
+    }
+    *second = p_clock_driver->get_second();
+}
+
 uint64_t global_tick = 0;
 int xizi_clock_handler(int irq, void* tf, void* arg)
 {