Add schedule node midway

Ubiquitous/XiZi_AIoT/softkernel/syscall/sys_close_session.c

@@ -70,8 +70,8 @@ int sys_close_session(struct Thread* cur_task, struct Session* session)
             // @todo fix memory leak
         } else {
             assert(!queue_is_empty(&server_to_info->sessions_to_be_handle));
-            if (server_to_info->state == BLOCKED) {
-                xizi_task_manager.task_unblock(session_backend->server);
+            if (server_to_info->snode.state == BLOCKED) {
+                task_into_ready(session_backend->server);
             }
         }
     }

Ubiquitous/XiZi_AIoT/softkernel/syscall/sys_exit.c

@@ -41,11 +41,11 @@ int sys_exit(struct Thread* ptask)
     assert(ptask != NULL);
     ptask->dead = true;
     // free that task straightly if it's a blocked task
-    if (ptask->state == BLOCKED) {
+    if (ptask->snode.state == BLOCKED) {
         struct TaskLifecycleOperations* tlo = GetSysObject(struct TaskLifecycleOperations, &xizi_task_manager.task_lifecycle_ops_tag);
         tlo->free_pcb(ptask);
     }
     // yield current task in case it wants to exit itself
-    xizi_task_manager.task_yield_noschedule(cur_cpu()->task, false);
+    task_yield(cur_cpu()->task);
     return 0;
 }

Ubiquitous/XiZi_AIoT/softkernel/syscall/sys_poll_session.c

@@ -112,7 +112,7 @@ int sys_poll_session(struct Session* userland_session_arr, int arr_capacity)
     }
 
     if (queue_is_empty(&cur_task->sessions_in_handle) && queue_is_empty(&cur_task->sessions_to_be_handle)) {
-        xizi_task_manager.task_yield_noschedule(cur_task, false);
+        task_yield(cur_task);
         // @todo support blocking(now bug at 4 cores running)
         // xizi_task_manager.task_block(&xizi_task_manager.task_blocked_list_head, cur_task);
     }

Ubiquitous/XiZi_AIoT/softkernel/syscall/sys_register_irq.c

@@ -76,8 +76,8 @@ static void send_irq_to_user(int irq_num)
         buf->header.magic = IPC_MSG_MAGIC;
         buf->header.valid = 1;
 
-        if (irq_forward_table[irq_num].handle_task->state == BLOCKED) {
-            xizi_task_manager.task_unblock(irq_forward_table[irq_num].handle_task);
+        if (irq_forward_table[irq_num].handle_task->snode.state == BLOCKED) {
+            task_into_ready(irq_forward_table[irq_num].handle_task);
         }
 
         /* add session head */
@@ -92,7 +92,7 @@ int user_irq_handler(int irq, void* tf, void* arg)
 
         next_task_emergency = irq_forward_table[irq].handle_task;
         if (cur_cpu()->task != NULL) {
-            xizi_task_manager.task_yield_noschedule(cur_cpu()->task, false);
+            task_yield(cur_cpu()->task);
         }
     }
     return 0;
@@ -126,7 +126,7 @@ int sys_register_irq(int irq_num, int irq_opcode)
 
         struct TaskLifecycleOperations* tlo = GetSysObject(struct TaskLifecycleOperations, &xizi_task_manager.task_lifecycle_ops_tag);
         kernel_irq_proxy = tlo->new_thread(pmemspace);
-        kernel_irq_proxy->state = NEVER_RUN;
+        kernel_irq_proxy->snode.state = NEVER_RUN;
     }
 
     // bind irq to session

Ubiquitous/XiZi_AIoT/softkernel/syscall/sys_sleep.c

@@ -36,10 +36,11 @@ Modification:
 int sys_sleep(intptr_t ms)
 {
     struct Thread* cur_task = cur_cpu()->task;
-    xizi_task_manager.task_yield_noschedule(cur_task, false);
-    xizi_task_manager.task_block(&xizi_task_manager.task_sleep_list_head, cur_task);
-    cur_task->state = SLEEPING;
-    cur_task->sleep_context.remain_ms = ms;
+    task_yield(cur_task);
+    cur_task->snode.sleep_context.remain_ms = ms;
+    task_trans_sched_state(&cur_task->snode, //
+        &g_scheduler.snode_state_pool[READY], //
+        &g_scheduler.snode_state_pool[SLEEPING], SLEEPING);
 
     return 0;
 }

Ubiquitous/XiZi_AIoT/softkernel/syscall/sys_thread.c

@@ -64,7 +64,7 @@ int sys_new_thread(struct MemSpace* pmemspace, struct Thread* task, uintptr_t en
     strncpy(task->name, last, sizeof(task->name) - 1);
 
     // init pcb schedule attributes
-    xizi_task_manager.task_set_default_schedule_attr(task);
+    task_into_ready(task);
 
     // thread init done by here
     if (pmemspace->thread_to_notify == NULL) {

Ubiquitous/XiZi_AIoT/softkernel/syscall/sys_wait_session.c

@@ -60,8 +60,8 @@ int sys_wait_session(struct Session* userland_session)
     assert(!queue_is_empty(&server_to_call->sessions_to_be_handle));
 
     ksemaphore_wait(&xizi_task_manager.semaphore_pool, cur_task, session_backend->client_sem_to_wait);
-    if (server_to_call->state == BLOCKED) {
-        xizi_task_manager.task_unblock(session_backend->server);
+    if (server_to_call->snode.state == BLOCKED) {
+        task_into_ready(session_backend->server);
     }
 
     return 0;

Ubiquitous/XiZi_AIoT/softkernel/syscall/sys_yield.c

@@ -36,6 +36,6 @@ Modification:
 int sys_yield(task_yield_reason reason)
 {
     struct Thread* cur_task = cur_cpu()->task;
-    xizi_task_manager.task_yield_noschedule(cur_task, false);
+    task_yield(cur_task);
     return 0;
 }

Ubiquitous/XiZi_AIoT/softkernel/syscall/syscall.c

@@ -39,7 +39,7 @@ int syscall(int sys_num, uintptr_t param1, uintptr_t param2, uintptr_t param3, u
 
     switch (sys_num) {
     case SYSCALL_TEST:
-        ret = arch_curr_tick();
+        ret = 0;
         break;
     case SYSCALL_SPAWN:
         ret = sys_spawn((char*)param1, (char*)param2, (char**)param3);