fix sys_kill.

Ubiquitous/XiZi_AIoT/softkernel/include/task.h

@@ -48,6 +48,7 @@ enum ProcState {
     READY,
     RUNNING,
     DEAD,
+    BLOCKED,
     NEVER_RUN,
 };
 
@@ -118,7 +119,7 @@ struct XiziTaskManager {
     /* function that's runing by kernel thread context, schedule use tasks */
     void (*task_scheduler)(struct SchedulerRightGroup);
     /* call to yield current use task */
-    void (*cur_task_yield_noschedule)(void);
+    void (*task_yield_noschedule)(struct TaskMicroDescriptor* task, bool is_blocking);
     /* set task priority */
     void (*set_cur_task_priority)(int priority);
 };

Ubiquitous/XiZi_AIoT/softkernel/main.c

@@ -90,13 +90,14 @@ int main(void)
     struct SchedulerRightGroup scheduler_rights;
     assert(AchieveResourceTag(&scheduler_rights.mmu_driver_tag, &hardkernel_tag, "mmu-ac-resource"));
     assert(AchieveResourceTag(&scheduler_rights.intr_driver_tag, &hardkernel_tag, "intr-ac-resource"));
-
     core_init_done |= (1 << cpu_id);
     LOG_PRINTF("CPU %d init done\n", cpu_id);
     spinlock_unlock(&whole_kernel_lock);
 
     while (core_init_done != (1 << NR_CPU) - 1)
         ;
+
+    xizi_enter_kernel();
     start_smp_cache_broadcast(cpu_id);
     xizi_task_manager.task_scheduler(scheduler_rights);
 

Ubiquitous/XiZi_AIoT/softkernel/syscall/sys_exit.c

@@ -82,7 +82,7 @@ int sys_exit(struct TaskMicroDescriptor* ptask)
     }
 
     // delete task for pcb_list
-    xizi_task_manager.cur_task_yield_noschedule();
+    xizi_task_manager.task_yield_noschedule(ptask, true);
     ptask->state = DEAD;
 
     return 0;

Ubiquitous/XiZi_AIoT/softkernel/syscall/sys_register_irq.c

@@ -84,7 +84,7 @@ int user_irq_handler(int irq, void* tf, void* arg)
     p_mmu_driver->LoadPgdir((uintptr_t)V2P(cur_cpu()->task->pgdir.pd_addr));
 
     next_task_emergency = irq_forward_table[irq].handle_task;
-    xizi_task_manager.cur_task_yield_noschedule();
+    xizi_task_manager.task_yield_noschedule(cur_cpu()->task, false);
     return 0;
 }
 

Ubiquitous/XiZi_AIoT/softkernel/syscall/sys_yield.c

@@ -35,6 +35,6 @@ Modification:
 
 int sys_yield()
 {
-    xizi_task_manager.cur_task_yield_noschedule();
+    xizi_task_manager.task_yield_noschedule(cur_cpu()->task, false);
     return 0;
 }

Ubiquitous/XiZi_AIoT/softkernel/task/scheduler.c

@@ -40,7 +40,6 @@ struct TaskMicroDescriptor* max_priority_runnable_task(void)
     {
         if (task->state == READY) {
             // found a runnable task, stop this look up
-            task->state = RUNNING;
             return task;
         } else if (task->state == DEAD) {
             // found a killed task, stop this loop
@@ -61,7 +60,6 @@ struct TaskMicroDescriptor* round_robin_runnable_task(uint32_t priority)
 
         if (task->state == READY) {
             // found a runnable task, stop this look up
-            task->state = RUNNING;
             return task;
         } else if (task->state == DEAD) {
             // found a killed task, stop this loop

Ubiquitous/XiZi_AIoT/softkernel/task/task.c

@@ -171,7 +171,6 @@ struct TaskMicroDescriptor* next_task_emergency = NULL;
 extern void context_switch(struct context**, struct context*);
 static void _scheduler(struct SchedulerRightGroup right_group)
 {
-    xizi_enter_kernel();
     struct MmuCommonDone* p_mmu_driver = AchieveResource(&right_group.mmu_driver_tag);
     struct TaskMicroDescriptor* next_task;
 
@@ -182,20 +181,25 @@ static void _scheduler(struct SchedulerRightGroup right_group)
         if (next_task_emergency != NULL && next_task->state == READY) {
             next_task = next_task_emergency;
             next_task->state = RUNNING;
-            next_task_emergency = NULL;
         } else {
             next_task = xizi_task_manager.next_runnable_task();
         }
+        next_task_emergency = NULL;
+        if (next_task != NULL) {
+            assert(next_task->state == READY);
+            next_task->state = RUNNING;
+        }
         spinlock_unlock(&whole_kernel_lock);
 
         /* not a runnable task */
-        if (UNLIKELY(next_task == NULL) || UNLIKELY(next_task->state != RUNNING)) {
+        if (UNLIKELY(next_task == NULL)) {
             spinlock_lock(&whole_kernel_lock);
             continue;
         }
 
         /* a runnable task */
         spinlock_lock(&whole_kernel_lock);
+        assert(next_task->state == RUNNING);
         struct CPU* cpu = cur_cpu();
         cpu->task = next_task;
         p_mmu_driver->LoadPgdir((uintptr_t)V2P(next_task->pgdir.pd_addr));
@@ -203,34 +207,24 @@ static void _scheduler(struct SchedulerRightGroup right_group)
     }
 }
 
-static uint32_t yield_cnt = 0;
-static void _cur_task_yield_noschedule(void)
+static void _task_yield_noschedule(struct TaskMicroDescriptor* task, bool blocking)
 {
-    yield_cnt++;
-
-    struct TaskMicroDescriptor* current_task = cur_cpu()->task;
-    assert(current_task != NULL);
+    assert(task != NULL);
 
     // rearrage current task position
-    doubleListDel(&current_task->node);
-    // DEBUG("%s,%d\n", current_task->name, strcmp(current_task->name, name1));
-    if (current_task->maxium_tick <= 0) {
-        if (IS_DOUBLE_LIST_EMPTY(&xizi_task_manager.task_list_head[current_task->priority])) {
-            ready_task_priority &= ~(1 << current_task->priority);
+    doubleListDel(&task->node);
+    if (task->state == RUNNING) {
+        if (!blocking) {
+            task->state = READY;
+        } else {
+            task->state = BLOCKED;
         }
-        current_task->priority += 1;
-        current_task->maxium_tick = TASK_CLOCK_TICK * 10;
     }
-    doubleListAddOnBack(&current_task->node, &xizi_task_manager.task_list_head[current_task->priority]);
-    ready_task_priority |= (1 << current_task->priority);
-    // set current task state
-    current_task->state = READY;
-    current_task->remain_tick = TASK_CLOCK_TICK;
-    cur_cpu()->task = NULL;
-    if (yield_cnt == 50) {
-        recover_priority();
-        yield_cnt = 0;
+    task->remain_tick = TASK_CLOCK_TICK;
+    if (task == cur_cpu()->task) {
+        cur_cpu()->task = NULL;
     }
+    doubleListAddOnBack(&task->node, &xizi_task_manager.task_list_head[task->priority]);
 }
 
 static void _set_cur_task_priority(int priority)
@@ -261,7 +255,7 @@ struct XiziTaskManager xizi_task_manager = {
 
     .next_runnable_task = max_priority_runnable_task,
     .task_scheduler = _scheduler,
-    .cur_task_yield_noschedule = _cur_task_yield_noschedule,
+    .task_yield_noschedule = _task_yield_noschedule,
     .set_cur_task_priority = _set_cur_task_priority
 };
 

Ubiquitous/XiZi_AIoT/softkernel/trap/clock_irq_handler.c

@@ -58,7 +58,7 @@ int xizi_clock_handler(int irq, void* tf, void* arg)
             current_task->remain_tick--;
             current_task->maxium_tick--;
             if (current_task->remain_tick == 0) {
-                xizi_task_manager.cur_task_yield_noschedule();
+                xizi_task_manager.task_yield_noschedule(current_task, false);
             }
         }
     }