Merge branch 'prepare_for_master' of https://gitlink.org.cn/xuos/xiuos into prepare_for_master

APP_Framework/Applications/app_test/test_socket.c

@@ -335,10 +335,22 @@ void TestSocket(int argc, char* argv[])
     if (mode == IPERF_MODE_SERVER) {
         printf("[%s] Running iperf server at port %d.\n", __func__, iperf_param.port);
 
-        PrivTaskCreate(&thd, NULL, TestIperfServer, (void*)&iperf_param);
+#ifdef ADD_XIZI_FEATURES
+        char task_name[] = "test_iperf_server";
+        pthread_args_t args;
+        args.pthread_name = task_name;
+        args.arg = (void *)&iperf_param;
+        PrivTaskCreate(&thd, NULL, TestIperfServer, (void*)&args);
+#endif
     } else if (mode == IPERF_MODE_CLIENT) {
         printf("[%s] Running iperf client to server at %s:%d.\n", __func__, iperf_param.host, iperf_param.port);
-        PrivTaskCreate(&thd, NULL, TestIperfClient, (void*)&iperf_param);
+#ifdef ADD_XIZI_FEATURES
+        char task_name[] = "test_iperf_client";
+        pthread_args_t args;
+        args.pthread_name = task_name;
+        args.arg = (void *)&iperf_param;
+        PrivTaskCreate(&thd, NULL, TestIperfClient, (void*)&args);
+#endif
     }
 
     PrivTaskStartup(&thd);

APP_Framework/Applications/general_functions/circular_area/circular_area_app.c

@@ -272,7 +272,7 @@ CircularAreaAppType CircularAreaAppInit(uint32_t circular_area_length)
     circular_area->p_tail = circular_area->data_buffer + circular_area_length;
     circular_area->area_length = circular_area_length;
 
-    printf("CircularAreaAppInit done p_head %8p p_tail %8p length %u\n",
+    printf("CircularAreaAppInit done p_head %8p p_tail %8p length %lu\n",
         circular_area->p_head, circular_area->p_tail, circular_area->area_length);
 
     circular_area->CircularAreaAppOperations = &CircularAreaAppOperations;

APP_Framework/Framework/connection/adapter_agent.c

@@ -549,13 +549,19 @@ static int ATAgentInit(ATAgentType agent)
     attr.priority = 18;
     attr.stacksize = 8192;
 
+    PrivTaskCreate(&agent->at_handler, &attr, ATAgentReceiveProcess, agent);
 #else
     pthread_attr_t attr;
     attr.schedparam.sched_priority = 25;
     attr.stacksize = 4096;
-#endif
 
-    PrivTaskCreate(&agent->at_handler, &attr, ATAgentReceiveProcess, agent);
+    char task_name[] = "at_agent";
+    pthread_args_t args;
+    args.pthread_name = task_name;
+    args.arg = (void *)agent;
+
+    PrivTaskCreate(&agent->at_handler, &attr, ATAgentReceiveProcess, (void *)&args);
+#endif
 
     return result;
 

APP_Framework/Framework/connection/lora/adapter_lora.c

@@ -848,8 +848,10 @@ static int AdapterLoraRegister(struct Adapter *adapter)
     ret = AdapterDeviceRegister(adapter);
     if (ret < 0) {
         printf("Adapter4G register error\n");
+#ifdef AS_LORA_GATEWAY_ROLE
         if (lora_gateway)
             PrivFree(lora_gateway);
+#endif
         if (lora_client)
             PrivFree(lora_client);
 
@@ -952,22 +954,32 @@ int AdapterLoraTest(void)
     pthread_attr_t lora_gateway_attr = PTHREAD_ATTR_INITIALIZER;
     lora_gateway_attr.priority = 20;
     lora_gateway_attr.stacksize = 2048;
+    PrivTaskCreate(&lora_recv_data_task, &lora_gateway_attr, &LoraReceiveTask, (void *)adapter);
 #else
     pthread_attr_t lora_gateway_attr;
     lora_gateway_attr.schedparam.sched_priority = 20;
     lora_gateway_attr.stacksize = 2048;
+
+    char task_name_1[] = "adapter_lora_recv";
+    pthread_args_t args;
+    args.pthread_name = task_name_1;
+    args.arg = (void *)adapter;
+    PrivTaskCreate(&lora_recv_data_task, &lora_gateway_attr, &LoraReceiveTask, (void *)&args);
 #endif
 
-    PrivTaskCreate(&lora_recv_data_task, &lora_gateway_attr, &LoraReceiveTask, (void *)adapter);
     PrivTaskStartup(&lora_recv_data_task);
 
 #ifdef ADD_NUTTX_FEATURES
     lora_gateway_attr.priority = 20;
+    PrivTaskCreate(&lora_gateway_task, &lora_gateway_attr, &LoraGatewayTask, (void *)adapter);
 #else   
     lora_gateway_attr.schedparam.sched_priority = 20;
+    char task_name_2[] = "adapter_lora_gateway";
+    args.pthread_name = task_name_2;
+    args.arg = (void *)adapter;
+    PrivTaskCreate(&lora_recv_data_task, &lora_gateway_attr, &LoraReceiveTask, (void *)&args);
 #endif
 
-    PrivTaskCreate(&lora_gateway_task, &lora_gateway_attr, &LoraGatewayTask, (void *)adapter);
     PrivTaskStartup(&lora_gateway_task);
 
 #else //AS_LORA_CLIENT_ROLE
@@ -975,22 +987,34 @@ int AdapterLoraTest(void)
     pthread_attr_t lora_client_attr = PTHREAD_ATTR_INITIALIZER;
     lora_client_attr.priority = 20;
     lora_client_attr.stacksize = 2048;
+
+    PrivTaskCreate(&lora_recv_data_task, &lora_client_attr, &LoraReceiveTask, (void *)adapter);
 #else
     pthread_attr_t lora_client_attr;
     lora_client_attr.schedparam.sched_priority = 20;
     lora_client_attr.stacksize = 2048;
+
+    char task_name_1[] = "adapter_lora_recv";
+    pthread_args_t args;
+    args.pthread_name = task_name_1;
+    args.arg = (void *)adapter;
+    PrivTaskCreate(&lora_recv_data_task, &lora_client_attr, &LoraReceiveTask, (void *)&args);
 #endif
-    PrivTaskCreate(&lora_recv_data_task, &lora_client_attr, &LoraReceiveTask, (void *)adapter);
+
     PrivTaskStartup(&lora_recv_data_task);
 
 #ifdef ADD_NUTTX_FEATURES
     lora_client_attr.priority = 20;
+    PrivTaskCreate(&lora_client_data_task, &lora_client_attr, &LoraClientDataTask, (void *)adapter);
 #else   
     lora_client_attr.schedparam.sched_priority = 20;
+    char task_name_2[] = "adapter_lora_client";
+    args.pthread_name = task_name_2;
+    args.arg = (void *)adapter;
+    PrivTaskCreate(&lora_client_data_task, &lora_client_attr, &LoraClientDataTask, (void *)&args);
 #endif
 
     //create lora client task
-    PrivTaskCreate(&lora_client_data_task, &lora_client_attr, &LoraClientDataTask, (void *)adapter);
     PrivTaskStartup(&lora_client_data_task);
 
 #endif

APP_Framework/Framework/control/shared/control_def.c

@@ -322,7 +322,12 @@ int ControlProtocolOpenDef(struct ControlProtocol *control_protocol)
     attr.schedparam.sched_priority = 19;
     attr.stacksize = 2048;
 
-    PrivTaskCreate(&recv_plc_data_task, &attr, &ReceivePlcDataTask, control_protocol);
+    char task_name[] = "control_recv_data";
+    pthread_args_t args;
+    args.pthread_name = task_name;
+    args.arg = (void *)control_protocol;
+
+    PrivTaskCreate(&recv_plc_data_task, &attr, &ReceivePlcDataTask, (void *)&args);
     PrivTaskStartup(&recv_plc_data_task);
 }
 

APP_Framework/Framework/sensor/pm/ps5308/ps5308.c

@@ -80,7 +80,12 @@ static int SensorDeviceOpen(struct SensorDevice *sdev)
 
     result = PrivIoctl(sdev->fd, OPE_INT, &cfg);
 
-    PrivTaskCreate(&active_task_id, NULL, &ReadTask, sdev);
+    char task_name[] = "ps5308_recv_data";
+    pthread_args_t args;
+    args.pthread_name = task_name;
+    args.arg = (void *)sdev;
+
+    PrivTaskCreate(&active_task_id, NULL, &ReadTask, (void *)&args);
     PrivTaskStartup(&active_task_id);
 
     return result;

APP_Framework/Framework/sensor/voice/d124/d124.c

@@ -116,7 +116,12 @@ static int SensorDeviceOpen(struct SensorDevice *sdev)
     attr.schedparam.sched_priority = 20;
     attr.stacksize = 2048;
 
-    PrivTaskCreate(&active_task_id, &attr, &ReadTask, sdev);
+    char task_name[] = "d124_recv_data";
+    pthread_args_t args;
+    args.pthread_name = task_name;
+    args.arg = (void *)sdev;
+
+    PrivTaskCreate(&active_task_id, &attr, &ReadTask, (void *)&args);
     PrivTaskStartup(&active_task_id);
 
     return result;

APP_Framework/Framework/transform_layer/xizi/user_api/posix_support/include/pthread.h

@@ -72,6 +72,11 @@ extern "C" {
 
 typedef int   pid_t;
 // typedef int pthread_mutex_t ;
+typedef struct pthread_args
+{
+    void *arg;
+    const char *pthread_name;
+}pthread_args_t;
 
 /* scheduling algorithms */
 #define SCHED_OTHER		0

APP_Framework/Framework/transform_layer/xizi/user_api/posix_support/pthread.c

@@ -29,28 +29,40 @@
 int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
                    void *(*start_routine)(void *), void *arg)
 {
-    int ret ;
+    int ret;
-    int pid ;
+    int pid;
     char task_name[32] = {0};
     static int utask_id = 0;
-    UtaskType task ;
+    UtaskType task;
+    pthread_args_t *pthread_args = (pthread_args_t *)arg;
 
     if (NULL == attr) {
         task.prio = KTASK_PRIORITY_MAX / 2;
-        task.stack_size = 4096 ;
+        task.stack_size = 4096;
     } else {
-        task.prio = attr->schedparam.sched_priority ;
+        task.prio = attr->schedparam.sched_priority;
-        task.stack_size = attr->stacksize ;
+        task.stack_size = attr->stacksize;
+    }
+
+    task.func_entry = start_routine;
+
+    if (NULL == pthread_args) {
+        task.func_param = NULL;
+        snprintf(task_name, sizeof(task_name) - 1, "utask%02d", utask_id++);
+    } else {
+        task.func_param = pthread_args->arg;
+        if (NULL == pthread_args->pthread_name) {
+            snprintf(task_name, sizeof(task_name) - 1, "utask%02d", utask_id++);
+        } else {
+            snprintf(task_name, sizeof(task_name) - 1, pthread_args->pthread_name);
+        } 
     }
 
-    task.func_entry = start_routine ;
-    task.func_param = arg;
-    snprintf(task_name, sizeof(task_name) - 1, "utask%02d",utask_id++);
     memcpy(task.name , task_name, sizeof(task_name) - 1);
 
     pid = UserTaskCreate(task);
     if (pid < 0)
-      return -1 ;
+        return -1;
     
     ret = UserTaskStartup(pid);
     *thread = (pthread_t)(long)pid;

APP_Framework/Framework/transform_layer/xizi/user_api/posix_support/timer.c

@@ -25,8 +25,11 @@
 #include "include/semaphore.h"
 #include "include/pthread.h"
 
-static sem_t timer_sem;
+#define TIMER_NUM 20
-static pthread_t timer_task;
+
+static sem_t timer_sem[TIMER_NUM];
+static pthread_t timer_task[TIMER_NUM];
+static char timer_idx[TIMER_NUM];
 
 struct timer_func {
     union sigval value;
@@ -34,16 +37,17 @@ struct timer_func {
     void (* user_timer_function)(union sigval val);
 };
 
-struct timer_func g_timer_func;
+struct timer_func g_timer_func[TIMER_NUM];
 
 static void *timer_callback(void *args) 
 {
-    struct sigevent *evp = (struct sigevent *)args;
+    clockid_t clockid = *((clockid_t *)args);
 
     while (1) {
-        if (g_timer_func.user_timer_function != NULL) {
+        if (g_timer_func[clockid].user_timer_function != NULL) {
-            if (0 == sem_timedwait(&timer_sem, NULL)) {
+            if (0 == sem_timedwait(&(timer_sem[clockid]), NULL)) {
-                g_timer_func.user_timer_function(g_timer_func.value);
+                g_timer_func[clockid].value.sival_ptr = &clockid;
+                g_timer_func[clockid].user_timer_function(g_timer_func[clockid].value);
             }
         }
     }
@@ -68,30 +72,37 @@ int timer_create(clockid_t clockid, struct sigevent * evp, timer_t * timerid)
     memset(timer_name, 0, sizeof(timer_name));
     snprintf(timer_name, sizeof(timer_name), "timer_%ld", clockid);
 
-    sem_init(&timer_sem, 0, 0);
+    sem_init(&(timer_sem[clockid]), 0, 0);
 
-    g_timer_func.value = evp->sigev_value;
+    g_timer_func[clockid].value = evp->sigev_value;
-    g_timer_func.user_timer_function = evp->sigev_notify_function;
+    g_timer_func[clockid].user_timer_function = evp->sigev_notify_function;
-    g_timer_func.timer_flags = *(int *)(evp->sigev_notify_attributes);
+    g_timer_func[clockid].timer_flags = *(int *)(evp->sigev_notify_attributes);
 
     pthread_attr_t attr;
     attr.schedparam.sched_priority = 22;
     attr.stacksize = 2048;
 
-    pthread_create(&timer_task, &attr, &timer_callback, (void *)evp);
+    pthread_args_t args;
-    
+    args.pthread_name = timer_name;
-    timer_id = UserTimerCreate(timer_name, NULL, (void *)&timer_sem, 1000, g_timer_func.timer_flags);
+    args.arg = &clockid;
+
+    pthread_create(&(timer_task[clockid]), &attr, &timer_callback, (void *)&args);
+
+    timer_id = UserTimerCreate(timer_name, NULL, (void *)&(timer_sem[clockid]), clockid, g_timer_func[clockid].timer_flags);
     *timerid = timer_id;
     return timer_id;
 }
 
 int timer_delete(timer_t timerid)
 {
-    pthread_kill(timer_task, 0);
+    sem_t sem;
+    int timer_id = timerid;
+    pthread_kill(timer_task[timer_id], 0);
     
     UserTimerQuitRun(timerid);
 
-    sem_destroy(&timer_sem);
+    sem = timer_sem[timer_id];
+    sem_destroy(&sem);
 
     return 0;
 }

APP_Framework/lib/lorawan/README.md

@@ -20,10 +20,14 @@ xiuos/APP_Framework/lib/lorawan
 
 ```
 # 下载代码
-# 进入APP_Framework/lib/lorawan目录下载更新子模块
+# 进入APP_Framework/lib/lorawan目录下载更新子模块，首先执行以下命令：
 git submodule init
+# 若需要使用lora_radio_driver子模块，执行以下命令：
 git submodule update APP_Framework/lib/lorawan/lora_radio_driver
+# 若需要使用lorawan_devicenode子模块，执行以下命令：
 git submodule update APP_Framework/lib/lorawan/lorawan_devicenode
+# 若需要使用lorawan_gateway_single_channel子模块，执行以下命令：
+git submodule update APP_Framework/lib/lorawan/lorawan_gateway_single_channel
 
 # 进入 APP_Framework/lib/lorawan/Kconfig 配置，增加子模块source路径，从而编译时可找到相应lib的配置
 menuconfig LIB_USING_LORAWAN_GATEWAY_SC

APP_Framework/lib/lorawan/lora_radio_driver

@@ -1 +1 @@
-Subproject commit a94c007cb4ee726cc29b10626f8bbfc19c989b89
+Subproject commit 0ced8f47f86ea96a414479424d7f534426a818eb

APP_Framework/lib/lorawan/lorawan_devicenode

@@ -1 +1 @@
-Subproject commit 254754bc7d06011cbec4655cd229c8ccfb95240b
+Subproject commit 4c543f77fcc639696939098a31145fdc1654f0f6

APP_Framework/lib/lorawan/lorawan_gateway_single_channel

@@ -1 +1 @@
-Subproject commit ac1c6516ec9b2998c0c50796a4e5a8b78781dc8c
+Subproject commit 986318f686df3e77eb3dc6cc690b3d1da3a32359

Ubiquitous/XiZi_IIoT/Makefile

@@ -5,7 +5,7 @@ MAKEFLAGS += --no-print-directory
 .PHONY:COMPILE_APP COMPILE_KERNEL
 
 
-riscv_support := kd233 maix-go hifive1-rev-B gapuino gd32vf103-rvstar rv32m1-vega aiit-riscv64-board xidatong-riscv64 edu-riscv64
+riscv_support := kd233 maix-go hifive1-rev-B gapuino gd32vf103-rvstar rv32m1-vega aiit-riscv64-board xidatong-riscv64 edu-riscv64 ch32v307vct6
 arm_support += stm32f407-st-discovery stm32f407zgt6 stm32f103-nano nuvoton-m2354 ok1052-c imxrt1176-sbc aiit-arm32-board xidatong-arm32 xiwangtong-arm32 edu-arm32
 emulator_support += hifive1-emulator k210-emulator cortex-m0-emulator cortex-m3-emulator cortex-m4-emulator cortex-m7-emulator
 

Ubiquitous/XiZi_IIoT/board/edu-arm32/config.mk

@@ -1,6 +1,6 @@
 export CROSS_COMPILE ?=/usr/bin/arm-none-eabi-
 
-export CFLAGS := -mcpu=cortex-m4 -mthumb -mfpu=fpv4-sp-d16 -mfloat-abi=softfp -ffunction-sections -fdata-sections -Dgcc -O0 -fgnu89-inline -Wa,-mimplicit-it=thumb -Werror
+export CFLAGS := -mcpu=cortex-m4 -mthumb -mfpu=fpv4-sp-d16 -mfloat-abi=softfp -ffunction-sections -fdata-sections -Dgcc -O0 -fgnu89-inline -Wa,-mimplicit-it=thumb -Werror -Wuninitialized
 # export CFLAGS := -mcpu=cortex-m4 -mthumb -mfpu=fpv4-sp-d16 -mfloat-abi=softfp -ffunction-sections -fdata-sections -Dgcc -O0 -gdwarf-2 -g -fgnu89-inline -Wa,-mimplicit-it=thumb -Werror
 export AFLAGS := -c -mcpu=cortex-m4 -mthumb -mfpu=fpv4-sp-d16 -mfloat-abi=softfp -ffunction-sections -fdata-sections -x assembler-with-cpp -Wa,-mimplicit-it=thumb  -gdwarf-2
 export LFLAGS := -mcpu=cortex-m4 -mthumb -mfpu=fpv4-sp-d16 -mfloat-abi=softfp -ffunction-sections -fdata-sections -Wl,--gc-sections,-Map=XiZi-edu-arm32.map,-cref,-u,Reset_Handler -T $(BSP_ROOT)/link.lds

Ubiquitous/XiZi_IIoT/board/edu-arm32/third_party_driver/sdio/connect_sdio.c

@@ -281,6 +281,7 @@ static void SdCardTask(void* parameter)
                 sd_card_status = 0;
             }
         }
+        MdelayKTask(500);
     }
 }
 

Ubiquitous/XiZi_IIoT/kernel/include/xs_assign.h

@@ -55,8 +55,8 @@ struct smp_assign_done
 };
 struct Assign
 {
-    struct OsAssignReadyVector os_assign_read_vector;
+    struct OsAssignReadyVector os_assign_ready_vector;
-    struct OsAssignReadyVector smp_os_assign_ready_rector[CPU_NUMBERS];
+    struct OsAssignReadyVector smp_os_assign_ready_vector[CPU_NUMBERS];
     struct TaskDescriptor *smp_os_running_task[CPU_NUMBERS];
 
     struct PriorityReadyVectorDone *ready_vector_done;
@@ -73,7 +73,7 @@ void HwInterruptcontextSwitch( x_ubase from, x_ubase to,struct TaskDescriptor *t
 #else
 struct Assign
 {
-    struct OsAssignReadyVector os_assign_read_vector;
+    struct OsAssignReadyVector os_assign_ready_vector;
     struct TaskDescriptor *os_running_task;
 
     struct PriorityReadyVectorDone *ready_vector_done;

Ubiquitous/XiZi_IIoT/kernel/include/xs_ktask.h

@@ -183,6 +183,7 @@ x_err_t KTaskDelete(int32 id);
 x_err_t YieldOsAssign(void);
 x_err_t DelayKTask(x_ticks_t tick);
 x_err_t MdelayKTask(uint32 ms);
+// KTaskPrioSet is bugged, dont use this
 x_err_t KTaskPrioSet(int32 id, uint8 prio);
 x_err_t KTaskCoreCombine(int32 id, uint8 coreid);
 x_err_t KTaskCoreUnCombine(int32 id);

Ubiquitous/XiZi_IIoT/kernel/kernel_service/xs_service.c

@@ -775,19 +775,24 @@ uint8_t UserGetTaskPriority(int32_t id)
 }
 
 #ifdef KERNEL_SOFTTIMER
-static int32 timer_sem;
+#define TIMER_NUM 20
+static int32 timer_sem[TIMER_NUM];
+static uint32_t timer_id[TIMER_NUM];
 static void UserTimerCallback(void *parameter)
 {
-   KSemaphoreAbandon(timer_sem);
+   uint32_t timer_id = *((uint32_t *)parameter);
+   KSemaphoreAbandon(timer_sem[timer_id]);
 }
 
 int32 UserTimerCreate(const char *name, void (*timeout)(void *parameter), void *parameter, uint32_t time, uint8_t trigger_mode)
 {
    int32 ret;
 
-   timer_sem = *((int *)parameter);
+   timer_id[time] = time;
+   timer_sem[time] = *((int *)parameter);
+
+   ret = KCreateTimer(name, UserTimerCallback, (void *)&(timer_id[time]), 1000, trigger_mode);
 
-   ret = KCreateTimer(name, UserTimerCallback, NONE, time, trigger_mode);
    return ret;
 }
 

Ubiquitous/XiZi_IIoT/kernel/kernel_test/test_threadsched.c

@@ -47,12 +47,12 @@ static void Task1Entry(void *parameter)
 
 	#ifdef ARCH_SMP
 	if (0 == strncmp(parameter,"-b",strlen("-b"))) { ///< if tasks bind to cpu 0
-		head = &(Assign.smp_os_assign_ready_rector[0].priority_ready_vector[PRIORITY]);
+		head = &(Assign.smp_os_assign_ready_vector[0].priority_ready_vector[PRIORITY]);
 	} else {
-		head = &(Assign.os_assign_read_vector.priority_ready_vector[PRIORITY]);
+		head = &(Assign.os_assign_ready_vector.priority_ready_vector[PRIORITY]);
 	}
 	#else
-		head = &(Assign.os_assign_read_vector.priority_ready_vector[PRIORITY]);
+		head = &(Assign.os_assign_ready_vector.priority_ready_vector[PRIORITY]);
 	#endif
 	while(cnt--) {
 #ifdef TOOL_SHELL

Ubiquitous/XiZi_IIoT/kernel/thread/assign.c

@@ -39,28 +39,27 @@ static struct PriorityReadyVectorDone SingleReadyVectorDone =
  */
 void KTaskOsAssign(void)
 {
-    
     x_ubase highest_prio = 0;
     int need_insert_from_task = 0;
     struct TaskDescriptor *new_task = NONE;
     struct TaskDescriptor *from_task = NONE;
 
     if(GetOsAssignLockLevel() >= 1) {
-        return;
+        goto exit;
     }
 
     if( isrManager.done->isInIsr() ){
         isrManager.done->setSwitchTrigerFlag();
-        return;
+        goto exit;
     }
 
     /* if the bitmap is empty then do not switch */
-    if(RET_TRUE == JudgeAssignReadyBitmapIsEmpty(&Assign.os_assign_read_vector)) {
+    if (RET_TRUE == JudgeAssignReadyBitmapIsEmpty(&Assign.os_assign_ready_vector)) {
-        return;
+        goto exit;
     }
 
-    highest_prio = Assign.os_assign_read_vector.highest_prio;
+    highest_prio = Assign.os_assign_ready_vector.highest_prio;
-    new_task = ChooseTaskWithHighestPrio(&Assign.os_assign_read_vector);
+    new_task = ChooseTaskWithHighestPrio(&Assign.os_assign_ready_vector);
 
     if(RET_TRUE != JudgeKTaskStatIsRunning(Assign.os_running_task)) {
         CHECK(NONE != new_task);
@@ -69,7 +68,7 @@ void KTaskOsAssign(void)
 
     /* if the running task’ priority is the highest and this task is not be yield then do not switch */
     if(highest_prio < Assign.os_running_task->task_dync_sched_member.cur_prio) {
-        return;
+        goto exit;
     } else {
         need_insert_from_task = 1;
     }
@@ -90,12 +89,12 @@ SWITCH:
         Assign.os_running_task = new_task;
 
         SYS_KDEBUG_LOG(KDBG_SCHED,
-                ("[%d]switch to priority#%d "
+            ("[%d]switch to priority#%d "
-                    "task:%.*s(sp:0x%08x), "
+             "task:%.*s(sp:0x%08x), "
-                    "from task:%.*s(sp: 0x%08x)\n",
+             "from task:%.*s(sp: 0x%08x)\n",
-                    isrManager.done->getCounter(), highest_prio,
+                isrManager.done->getCounter(), highest_prio,
-                    NAME_NUM_MAX, new_task->task_base_info.name, new_task->stack_point,
+                NAME_NUM_MAX, new_task->task_base_info.name, new_task->stack_point,
-                    NAME_NUM_MAX, from_task->task_base_info.name, from_task->stack_point));
+                NAME_NUM_MAX, from_task->task_base_info.name, from_task->stack_point));
 
 #ifdef KERNEL_STACK_OVERFLOW_CHECK
         _KTaskOsAssignStackCheck(new_task);
@@ -108,6 +107,8 @@ SWITCH:
         Assign.ready_vector_done->remove(Assign.os_running_task);
         KTaskStatSetAsRunning(Assign.os_running_task);
     }
+
+exit:
     return;
 }
 
@@ -129,12 +130,12 @@ void KTaskOsAssignDoIrqSwitch(void *context)
     
     isrManager.done->clearSwitchTrigerFlag();
     /* if the bitmap is empty then do not switch */
-    if(RET_TRUE == JudgeAssignReadyBitmapIsEmpty(&Assign.os_assign_read_vector)) {
+    if (RET_TRUE == JudgeAssignReadyBitmapIsEmpty(&Assign.os_assign_ready_vector)) {
         return;
     }
 
-    highest_prio = Assign.os_assign_read_vector.highest_prio;
+    highest_prio = Assign.os_assign_ready_vector.highest_prio;
-    new_task = ChooseTaskWithHighestPrio(&Assign.os_assign_read_vector);
+    new_task = ChooseTaskWithHighestPrio(&Assign.os_assign_ready_vector);
 
     if(RET_TRUE != JudgeKTaskStatIsRunning(Assign.os_running_task)) {
         CHECK(NONE != new_task);
@@ -165,18 +166,18 @@ SWITCH:
         Assign.os_running_task = new_task;
 
         SYS_KDEBUG_LOG(KDBG_SCHED,
-                ("[%d]switch to priority#%d "
+            ("[%s][%d]switch to priority#%d "
-                    "task:%.*s(sp:0x%08x), "
+             "task:%.*s(sp:0x%08x), "
-                    "from task:%.*s(sp: 0x%08x)\n",
+             "from task:%.*s(sp: 0x%08x)\n",
-                    isrManager.done->getCounter(), highest_prio,
+                __func__,
-                    NAME_NUM_MAX, new_task->task_base_info.name, new_task->stack_point,
+                isrManager.done->getCounter(), highest_prio,
-                    NAME_NUM_MAX, from_task->task_base_info.name, from_task->stack_point));
+                NAME_NUM_MAX, new_task->task_base_info.name, new_task->stack_point,
+                NAME_NUM_MAX, from_task->task_base_info.name, from_task->stack_point));
 
 #ifdef KERNEL_STACK_OVERFLOW_CHECK
         _KTaskOsAssignStackCheck(new_task);
 #endif
 
-
         SYS_KDEBUG_LOG(KDBG_SCHED, ("switch in interrupt\n"));
         HwInterruptcontextSwitch((x_ubase)&from_task->stack_point,
                     (x_ubase)&new_task->stack_point, new_task, context);
@@ -189,8 +190,8 @@ SWITCH:
 
 void KTaskOsAssignAfterIrq(void *context)
 {
-    x_base lock = 0;                                 
+    x_base lock = 0;
-    lock = DISABLE_INTERRUPT();                  
+    lock = DISABLE_INTERRUPT();
     KTaskOsAssignDoIrqSwitch(context);
     ENABLE_INTERRUPT(lock);
 }
@@ -204,20 +205,20 @@ void KTaskInsertToReadyVector(struct TaskDescriptor *task)
 {
     x_base lock = 0;
 
-	NULL_PARAM_CHECK(task);
+    NULL_PARAM_CHECK(task);
 
     lock = DISABLE_INTERRUPT();
 
     KTaskStatSetAsReady(task);
-	AssignPolicyInsert(task, &Assign.os_assign_read_vector);
+    AssignPolicyInsert(task, &Assign.os_assign_ready_vector);
 
     SYS_KDEBUG_LOG(KDBG_SCHED, ("insert task[%.*s], the priority: %d\n",
                                       NAME_NUM_MAX, task->task_base_info.name, task->task_dync_sched_member.cur_prio));
 
 #if KTASK_PRIORITY_MAX > 32
-    MERGE_FLAG(&Assign.os_assign_read_vector.ready_vector[task->task_dync_sched_member.bitmap_offset], task->task_dync_sched_member.bitmap_row);
+    MERGE_FLAG(&Assign.os_assign_ready_vector.ready_vector[task->task_dync_sched_member.bitmap_offset], task->task_dync_sched_member.bitmap_row);
 #endif
-    MERGE_FLAG(&Assign.os_assign_read_vector.priority_ready_group, task->task_dync_sched_member.bitmap_column);
+    MERGE_FLAG(&Assign.os_assign_ready_vector.priority_ready_group, task->task_dync_sched_member.bitmap_column);
 
     ENABLE_INTERRUPT(lock);
 }
@@ -234,29 +235,28 @@ void KTaskOsAssignRemoveKTask(struct TaskDescriptor *task)
     x_ubase number = 0;
     x_ubase highest_priority = 0;
 
-	NULL_PARAM_CHECK(task);
+    NULL_PARAM_CHECK(task);
+    ;
 
     lock = DISABLE_INTERRUPT();
 
-    SYS_KDEBUG_LOG(KDBG_SCHED, ("remove task[%.*s], the priority: %d\n",
+    SYS_KDEBUG_LOG(KDBG_SCHED, ("remove task[%.*s], the priority: %d\n", NAME_NUM_MAX, task->task_base_info.name, task->task_dync_sched_member.cur_prio));
-                                      NAME_NUM_MAX, task->task_base_info.name,
-                                      task->task_dync_sched_member.cur_prio));
 
     DoubleLinkListRmNode(&(task->task_dync_sched_member.sched_link));
-    
+
-    if (IsDoubleLinkListEmpty(&(Assign.os_assign_read_vector.priority_ready_vector[task->task_dync_sched_member.cur_prio]))) {
+    if (IsDoubleLinkListEmpty(&(Assign.os_assign_ready_vector.priority_ready_vector[task->task_dync_sched_member.cur_prio]))) {
 #if KTASK_PRIORITY_MAX > 32
-        CLEAR_FLAG(&Assign.os_assign_read_vector.ready_vector[task->task_dync_sched_member.bitmap_offset], task->task_dync_sched_member.bitmap_row);
+        CLEAR_FLAG(&Assign.os_assign_ready_vector.ready_vector[task->task_dync_sched_member.bitmap_offset], task->task_dync_sched_member.bitmap_row);
-        if (Assign.os_assign_read_vector.ready_vector[task->task_dync_sched_member.bitmap_offset] == 0) {
+        if (Assign.os_assign_ready_vector.ready_vector[task->task_dync_sched_member.bitmap_offset] == 0) {
-            CLEAR_FLAG(&Assign.os_assign_read_vector.priority_ready_group, task->task_dync_sched_member.bitmap_column);
+            CLEAR_FLAG(&Assign.os_assign_ready_vector.priority_ready_group, task->task_dync_sched_member.bitmap_column);
         }
-        number = PrioCaculate(Assign.os_assign_read_vector.priority_ready_group);
+        number = PrioCaculate(Assign.os_assign_ready_vector.priority_ready_group);
-        highest_priority = (number * 8) + PrioCaculate(Assign.os_assign_read_vector.ready_vector[number]);
+        highest_priority = (number * 8) + PrioCaculate(Assign.os_assign_ready_vector.ready_vector[number]);
 #else
-        CLEAR_FLAG(&Assign.os_assign_read_vector.priority_ready_group, task->task_dync_sched_member.bitmap_column);
+        CLEAR_FLAG(&Assign.os_assign_ready_vector.priority_ready_group, task->task_dync_sched_member.bitmap_column);
-        highest_priority = PrioCaculate(Assign.os_assign_read_vector.priority_ready_group);
+        highest_priority = PrioCaculate(Assign.os_assign_ready_vector.priority_ready_group);
 #endif
-        Assign.os_assign_read_vector.highest_prio = highest_priority;
+        Assign.os_assign_ready_vector.highest_prio = highest_priority;
     }
 
     ENABLE_INTERRUPT(lock);
@@ -305,13 +305,13 @@ x_err_t YieldOsAssign(void)
     }
 
     /* if the bitmap is empty then do not switch */
-    if(RET_TRUE == JudgeAssignReadyBitmapIsEmpty(&Assign.os_assign_read_vector)) {
+    if (RET_TRUE == JudgeAssignReadyBitmapIsEmpty(&Assign.os_assign_ready_vector)) {
         ENABLE_INTERRUPT(lock);
         return -ERROR;
     }
 
-    highest_prio = Assign.os_assign_read_vector.highest_prio;
+    highest_prio = Assign.os_assign_ready_vector.highest_prio;
-    new_task = ChooseTaskWithHighestPrio(&Assign.os_assign_read_vector);
+    new_task = ChooseTaskWithHighestPrio(&Assign.os_assign_ready_vector);
 
     from_task = Assign.os_running_task;
     
@@ -331,12 +331,13 @@ x_err_t YieldOsAssign(void)
         Assign.os_running_task = new_task;
 
         SYS_KDEBUG_LOG(KDBG_SCHED,
-                ("[%d]switch to priority#%d "
+            ("[%s][%d]switch to priority#%d "
-                    "task:%.*s(sp:0x%08x), "
+             "task:%.*s(sp:0x%08x), "
-                    "from task:%.*s(sp: 0x%08x)\n",
+             "from task:%.*s(sp: 0x%08x)\n",
-                    isrManager.done->getCounter(), highest_prio,
+                __func__,
-                    NAME_NUM_MAX, new_task->task_base_info.name, new_task->stack_point,
+                isrManager.done->getCounter(), highest_prio,
-                    NAME_NUM_MAX, from_task->task_base_info.name, from_task->stack_point));
+                NAME_NUM_MAX, new_task->task_base_info.name, new_task->stack_point,
+                NAME_NUM_MAX, from_task->task_base_info.name, from_task->stack_point));
 
 #ifdef KERNEL_STACK_OVERFLOW_CHECK
         _KTaskOsAssignStackCheck(new_task);
@@ -368,7 +369,7 @@ void StartupOsAssign(void)
 {
     struct TaskDescriptor *FirstRunningTask = NONE;
 
-    FirstRunningTask = ChooseTaskWithHighestPrio(&Assign.os_assign_read_vector);
+    FirstRunningTask = ChooseTaskWithHighestPrio(&Assign.os_assign_ready_vector);
 
     SetSystemRunningTask(FirstRunningTask);
     SwitchToFirstRunningTask(FirstRunningTask);
@@ -384,7 +385,7 @@ void SysInitOsAssign(void)
                                       KTASK_PRIORITY_MAX));
 
     Assign.ready_vector_done = &SingleReadyVectorDone;
-    Assign.ready_vector_done->init(&Assign.os_assign_read_vector);
+    Assign.ready_vector_done->init(&Assign.os_assign_ready_vector);
 
     ResetCriticalAreaLock();
 }

Ubiquitous/XiZi_IIoT/kernel/thread/assignstat.c

@@ -30,15 +30,17 @@
 void _KTaskOsAssignStackCheck(struct TaskDescriptor *task)
 {
 	NULL_PARAM_CHECK(task);
+        if ((x_ubase)task->stack_point <= (x_ubase)task->task_base_info.stack_start
+            || (x_ubase)task->stack_point > (x_ubase)task->task_base_info.stack_start + (x_ubase)task->task_base_info.stack_depth) {
 
-    if ((x_ubase)task->stack_point<= (x_ubase)task->task_base_info.stack_start ||
+            KPrintf("task name:%s id:%d stack overflow,sp %p stacktop %p stack depth 0x%x\n",
-        (x_ubase)task->stack_point >
+                task->task_base_info.name, task->id.id, task->stack_point,
-        (x_ubase)task->task_base_info.stack_start + (x_ubase)task->task_base_info.stack_depth) {
+                (uint32*)task->task_base_info.stack_start + task->task_base_info.stack_depth,
-       
+                task->task_base_info.stack_depth);
-        KPrintf("task name:%s id:%d stack overflow,sp %p stacktop %p stack depth 0x%x\n", task->task_base_info.name,task->id.id,task->stack_point,(uint32*)task->task_base_info.stack_start + task->task_base_info.stack_depth,task->task_base_info.stack_depth);
 
-        while (1);
+            while (1)
-    }
+                ;
+        }
 }
 #endif
 

Ubiquitous/XiZi_IIoT/kernel/thread/ktask.c

@@ -258,8 +258,8 @@ x_err_t _KTaskPrioSet(KTaskDescriptorType task, uint8 prio)
 #ifdef ARCH_SMP
             HwLockSpinlock(&AssignSpinLock);
 #endif
-            task->task_dync_sched_member.cur_prio = prio;
             Assign.ready_vector_done->remove(task);
+            task->task_dync_sched_member.cur_prio = prio;
             __BitmapSiteMask(task);
             Assign.ready_vector_done->insert(task);
 #ifdef ARCH_SMP

Ubiquitous/XiZi_IIoT/kernel/thread/mutex.c

@@ -109,10 +109,16 @@ static int32 _MutexObtain(struct Mutex *mutex, int32 msec)
                 SYS_KDEBUG_LOG(KDBG_IPC, ("mutex_take: suspend task: %s\n",
                                             task->task_base_info.name));
 
-                if (task->task_dync_sched_member.cur_prio > mutex->holder->task_dync_sched_member.cur_prio)
+                /* pending task is removed from ready list,
-                {
+                   so it wont affect the mutex holder;
-                    KTaskPrioSet(mutex->holder->id.id, task->task_dync_sched_member.cur_prio);
+                   if holder is stucked by others with higher priorities,
-                }
+                   try fix this by design, instead of mutex.
+                   Warning: dont use KTaskPrioSet, for it's bugged.
+                 */
+                // if (task->task_dync_sched_member.cur_prio > mutex->holder->task_dync_sched_member.cur_prio)
+                // {
+                //     KTaskPrioSet(mutex->holder->id.id, task->task_dync_sched_member.cur_prio);
+                // }
 
                 LinklistSuspend(&(mutex->pend_list), task, LINKLIST_FLAG_PRIO);
 
@@ -164,10 +170,10 @@ static int32 _MutexAbandon(struct Mutex *mutex)
 
     mutex->recursive_cnt --;
     if (mutex->recursive_cnt == 0) {
-        if (mutex->origin_prio != mutex->holder->task_dync_sched_member.cur_prio)
+        // if (mutex->origin_prio != mutex->holder->task_dync_sched_member.cur_prio)
-        {
+        // {
-            KTaskPrioSet(mutex->holder->id.id, mutex->origin_prio);
+        //     KTaskPrioSet(mutex->holder->id.id, mutex->origin_prio);
-        }
+        // }
 
         if (!IsDoubleLinkListEmpty(&mutex->pend_list)) {
             task = SYS_DOUBLE_LINKLIST_ENTRY(mutex->pend_list.node_next, struct TaskDescriptor, task_dync_sched_member.sched_link);

Ubiquitous/XiZi_IIoT/kernel/thread/smp_assign.c

@@ -40,7 +40,7 @@ static inline x_ubase SmpGetReadyVectorHighestPrio(void)
 {
     uint8 coreid = GetCpuId();
 
-    return ((Assign.os_assign_read_vector.highest_prio > Assign.smp_os_assign_ready_rector[coreid].highest_prio) ? Assign.os_assign_read_vector.highest_prio : Assign.smp_os_assign_ready_rector[coreid].highest_prio);
+    return ((Assign.os_assign_ready_vector.highest_prio > Assign.smp_os_assign_ready_vector[coreid].highest_prio) ? Assign.os_assign_ready_vector.highest_prio : Assign.smp_os_assign_ready_vector[coreid].highest_prio);
 }
 
 /*
@@ -51,13 +51,13 @@ static inline struct TaskDescriptor* SmpAssignTargetTaskSelect(void)
 
     uint8 coreid = GetCpuId();
 
-    if (Assign.os_assign_read_vector.highest_prio > Assign.smp_os_assign_ready_rector[coreid].highest_prio)
+    if (Assign.os_assign_ready_vector.highest_prio > Assign.smp_os_assign_ready_vector[coreid].highest_prio)
     {
-        return ChooseTaskWithHighestPrio(&Assign.os_assign_read_vector);
+        return ChooseTaskWithHighestPrio(&Assign.os_assign_ready_vector);
     }
     else
     {
-        return ChooseTaskWithHighestPrio(&Assign.smp_os_assign_ready_rector[coreid]);
+        return ChooseTaskWithHighestPrio(&Assign.smp_os_assign_ready_vector[coreid]);
     }
 }
 
@@ -98,7 +98,7 @@ static void SmpOsAssignInit(void)
 {
     int coreid = 0;
     while(coreid < CPU_NUMBERS) {
-        Assign.ready_vector_done->init(&Assign.smp_os_assign_ready_rector[coreid]);
+        Assign.ready_vector_done->init(&Assign.smp_os_assign_ready_vector[coreid]);
         Assign.smp_os_running_task[coreid] = NONE;
         
 #ifdef ARCH_SMP
@@ -148,8 +148,8 @@ void KTaskOsAssign(void)
     runningtask = Assign.smp_os_running_task[coreid];
 
     /* if the bitmap is empty then do not switch */
-    if((RET_TRUE == JudgeAssignReadyBitmapIsEmpty(&Assign.os_assign_read_vector)) &&
+    if((RET_TRUE == JudgeAssignReadyBitmapIsEmpty(&Assign.os_assign_ready_vector)) &&
-        (RET_TRUE == JudgeAssignReadyBitmapIsEmpty(&Assign.smp_os_assign_ready_rector[coreid]))) {
+        (RET_TRUE == JudgeAssignReadyBitmapIsEmpty(&Assign.smp_os_assign_ready_vector[coreid]))) {
         return;
     }
 
@@ -210,8 +210,8 @@ void KTaskOsAssignDoIrqSwitch(void *context)
 
     runningtask = Assign.smp_os_running_task[coreid];
 
-    if((RET_TRUE == JudgeAssignReadyBitmapIsEmpty(&Assign.os_assign_read_vector)) &&
+    if((RET_TRUE == JudgeAssignReadyBitmapIsEmpty(&Assign.os_assign_ready_vector)) &&
-        (RET_TRUE == JudgeAssignReadyBitmapIsEmpty(&Assign.smp_os_assign_ready_rector[coreid]))) {
+        (RET_TRUE == JudgeAssignReadyBitmapIsEmpty(&Assign.smp_os_assign_ready_vector[coreid]))) {
         return;
     }
 
@@ -260,10 +260,10 @@ static void UncombineInsert(struct TaskDescriptor *task)
     NULL_PARAM_CHECK(task);
 
 #if KTASK_PRIORITY_MAX > 32
-    MERGE_FLAG(&Assign.os_assign_read_vector.ready_vector[task->task_dync_sched_member.bitmap_offset], task->task_dync_sched_member.bitmap_row);
+    MERGE_FLAG(&Assign.os_assign_ready_vector.ready_vector[task->task_dync_sched_member.bitmap_offset], task->task_dync_sched_member.bitmap_row);
 #endif
-    MERGE_FLAG(&Assign.os_assign_read_vector.priority_ready_group, task->task_dync_sched_member.bitmap_column);
+    MERGE_FLAG(&Assign.os_assign_ready_vector.priority_ready_group, task->task_dync_sched_member.bitmap_column);
-    AssignPolicyInsert(task, &Assign.os_assign_read_vector);
+    AssignPolicyInsert(task, &Assign.os_assign_ready_vector);
     cpu_mask = CPU_MASK ^ (1 << GetCpuId());
     HwSendIpi(ASSIGN_IPI, cpu_mask);
 }
@@ -273,10 +273,10 @@ static void ComnbineInsert(struct TaskDescriptor *task, int coreid)
     NULL_PARAM_CHECK(task);
 
 #if KTASK_PRIORITY_MAX > 32
-    MERGE_FLAG(&Assign.smp_os_assign_ready_rector[coreid].ready_vector[task->task_dync_sched_member.bitmap_offset], task->task_dync_sched_member.bitmap_row);
+    MERGE_FLAG(&Assign.smp_os_assign_ready_vector[coreid].ready_vector[task->task_dync_sched_member.bitmap_offset], task->task_dync_sched_member.bitmap_row);
 #endif
-    MERGE_FLAG(&Assign.smp_os_assign_ready_rector[coreid].priority_ready_group, task->task_dync_sched_member.bitmap_column);
+    MERGE_FLAG(&Assign.smp_os_assign_ready_vector[coreid].priority_ready_group, task->task_dync_sched_member.bitmap_column);
-    AssignPolicyInsert(task, &Assign.smp_os_assign_ready_rector[coreid]);
+    AssignPolicyInsert(task, &Assign.smp_os_assign_ready_vector[coreid]);
     if (coreid != task->task_smp_info.combined_coreid)
     {
         uint32 cpu_mask;
@@ -324,22 +324,22 @@ static void UncombineRemove(struct TaskDescriptor *task)
 
     NULL_PARAM_CHECK(task);
 
-    if (IsDoubleLinkListEmpty(&(Assign.os_assign_read_vector.priority_ready_vector[task->task_dync_sched_member.cur_prio]))) {
+    if (IsDoubleLinkListEmpty(&(Assign.os_assign_ready_vector.priority_ready_vector[task->task_dync_sched_member.cur_prio]))) {
 #if KTASK_PRIORITY_MAX > 32
         
-        CLEAR_FLAG(&Assign.os_assign_read_vector.ready_vector[task->task_dync_sched_member.bitmap_offset], task->task_dync_sched_member.bitmap_row);
+        CLEAR_FLAG(&Assign.os_assign_ready_vector.ready_vector[task->task_dync_sched_member.bitmap_offset], task->task_dync_sched_member.bitmap_row);
-        if (Assign.os_assign_read_vector.ready_vector[task->task_dync_sched_member.bitmap_offset] == 0) {
+        if (Assign.os_assign_ready_vector.ready_vector[task->task_dync_sched_member.bitmap_offset] == 0) {
-            CLEAR_FLAG(&Assign.os_assign_read_vector.priority_ready_group, task->task_dync_sched_member.bitmap_column);
+            CLEAR_FLAG(&Assign.os_assign_ready_vector.priority_ready_group, task->task_dync_sched_member.bitmap_column);
         }
-        number = PrioCaculate(Assign.os_assign_read_vector.priority_ready_group);
+        number = PrioCaculate(Assign.os_assign_ready_vector.priority_ready_group);
-        highest_priority = (number * 8) + PrioCaculate(Assign.os_assign_read_vector.ready_vector[number]);
+        highest_priority = (number * 8) + PrioCaculate(Assign.os_assign_ready_vector.ready_vector[number]);
 #else
         
         
-        CLEAR_FLAG(&Assign.os_assign_read_vector.priority_ready_group, task->task_dync_sched_member.bitmap_column);   
+        CLEAR_FLAG(&Assign.os_assign_ready_vector.priority_ready_group, task->task_dync_sched_member.bitmap_column);   
-        highest_priority = PrioCaculate(Assign.os_assign_read_vector.priority_ready_group);
+        highest_priority = PrioCaculate(Assign.os_assign_ready_vector.priority_ready_group);
 #endif
-        Assign.os_assign_read_vector.highest_prio = highest_priority;  
+        Assign.os_assign_ready_vector.highest_prio = highest_priority;  
     }
 }
 
@@ -351,19 +351,19 @@ static void CombineRemove(struct TaskDescriptor *task)
 
     NULL_PARAM_CHECK(task);
 
-    if (IsDoubleLinkListEmpty(&(Assign.smp_os_assign_ready_rector[combined_coreid].priority_ready_vector[task->task_dync_sched_member.cur_prio]))) {
+    if (IsDoubleLinkListEmpty(&(Assign.smp_os_assign_ready_vector[combined_coreid].priority_ready_vector[task->task_dync_sched_member.cur_prio]))) {
 #if KTASK_PRIORITY_MAX > 32
-        CLEAR_FLAG(&Assign.smp_os_assign_ready_rector[combined_coreid].ready_vector[task->task_dync_sched_member.bitmap_offset], task->task_dync_sched_member.bitmap_row);
+        CLEAR_FLAG(&Assign.smp_os_assign_ready_vector[combined_coreid].ready_vector[task->task_dync_sched_member.bitmap_offset], task->task_dync_sched_member.bitmap_row);
-        if (Assign.os_assign_read_vector.ready_vector[task->task_dync_sched_member.bitmap_offset] == 0) {
+        if (Assign.os_assign_ready_vector.ready_vector[task->task_dync_sched_member.bitmap_offset] == 0) {
-            CLEAR_FLAG(&Assign.smp_os_assign_ready_rector[combined_coreid].priority_ready_group, task->task_dync_sched_member.bitmap_column);
+            CLEAR_FLAG(&Assign.smp_os_assign_ready_vector[combined_coreid].priority_ready_group, task->task_dync_sched_member.bitmap_column);
         }
-        number = PrioCaculate(Assign.smp_os_assign_ready_rector[combined_coreid].priority_ready_group);
+        number = PrioCaculate(Assign.smp_os_assign_ready_vector[combined_coreid].priority_ready_group);
-        highest_prio_on_core = (number * 8) + PrioCaculate(Assign.smp_os_assign_ready_rector[combined_coreid].ready_vector[number]);
+        highest_prio_on_core = (number * 8) + PrioCaculate(Assign.smp_os_assign_ready_vector[combined_coreid].ready_vector[number]);
 #else
-        CLEAR_FLAG(&Assign.smp_os_assign_ready_rector[combined_coreid].priority_ready_group, task->task_dync_sched_member.bitmap_column);
+        CLEAR_FLAG(&Assign.smp_os_assign_ready_vector[combined_coreid].priority_ready_group, task->task_dync_sched_member.bitmap_column);
-        highest_prio_on_core = PrioCaculate(Assign.smp_os_assign_ready_rector[combined_coreid].priority_ready_group);
+        highest_prio_on_core = PrioCaculate(Assign.smp_os_assign_ready_vector[combined_coreid].priority_ready_group);
 #endif
-        Assign.smp_os_assign_ready_rector[combined_coreid].highest_prio = highest_prio_on_core;
+        Assign.smp_os_assign_ready_vector[combined_coreid].highest_prio = highest_prio_on_core;
     }
 }
 
@@ -420,8 +420,8 @@ x_err_t YieldOsAssign(void)
         return -ERROR;
     }
     /* if the bitmap is empty then do not switch */
-    if((RET_TRUE == JudgeAssignReadyBitmapIsEmpty(&Assign.os_assign_read_vector)) &&
+    if((RET_TRUE == JudgeAssignReadyBitmapIsEmpty(&Assign.os_assign_ready_vector)) &&
-        (RET_TRUE == JudgeAssignReadyBitmapIsEmpty(&Assign.smp_os_assign_ready_rector[coreid]))) {
+        (RET_TRUE == JudgeAssignReadyBitmapIsEmpty(&Assign.smp_os_assign_ready_vector[coreid]))) {
         HwUnlockSpinlock(&AssignSpinLock);
         ENABLE_INTERRUPT(lock);
         return -ERROR;
@@ -481,7 +481,7 @@ void SysInitOsAssign(void)
 
     Assign.ready_vector_done = &ready_vector_done;
     Assign.smp_assign_done = &smp_assign_done;
-    Assign.ready_vector_done->init(&Assign.os_assign_read_vector);
+    Assign.ready_vector_done->init(&Assign.os_assign_ready_vector);
     Assign.smp_assign_done->SmpInit();
 
 }

Ubiquitous/XiZi_IIoT/kernel/thread/softtimer.c

@@ -301,7 +301,9 @@ void CheckTimerList(void)
                 ((WorkQueueDoneType *)sys_workq->done)->WorkSubmit((WorkqueueType *)sys_workq->property, t->t_work, 0);
                 lock = CriticalAreaLock();
             } else {
-                KPrintf("sortlist run unactive timer(%s), quit this timer\n", t->name);
+                // KPrintf("sortlist run unactive timer(%s), current %d deadline %d quit this timer\n", 
+                //     t->name, current_tick, t->deadline_timeslice);
+                break;
             }
         }
         else

Ubiquitous/XiZi_IIoT/resources/ethernet/cmd_lwip/Makefile

@@ -1,4 +1,4 @@
 # SRC_FILES := ping.c lwip_ping_demo.c lwip_config_demo.c lwip_dhcp_demo.c iperf.c http_test.c
-SRC_FILES := ping.c lwip_ping_demo.c lwip_tcp_demo.c lwip_udp_demo.c tcpecho_raw.c lwip_config_demo.c lwip_dhcp_demo.c iperf.c
+SRC_FILES := ping.c lwip_ping_demo.c lwip_udp_demo.c tcpecho_raw.c lwip_config_demo.c lwip_dhcp_demo.c
 
 include $(KERNEL_ROOT)/compiler.mk

Ubiquitous/XiZi_IIoT/resources/ethernet/cmd_lwip/lwip_tcp_demo.c

@@ -101,7 +101,7 @@ void LwipTcpSendTest(int argc, char *argv[])
     strcat(tcp_demo_msg, "\r\n");
 
     if(argc >= 3) {
-        if (sscanf(argv[2], "%hhd.%hhd.%hhd.%hhd:%d", &tcp_server_ip[0], &tcp_server_ip[1], &tcp_server_ip[2], &tcp_server_ip[3], &tcp_server_port) == EOK) {
+        if (sscanf(argv[2], "%hhd.%hhd.%hhd.%hhd:%hhd", &tcp_server_ip[0], &tcp_server_ip[1], &tcp_server_ip[2], &tcp_server_ip[3], &tcp_server_port) == EOK) {
             sscanf(argv[2], "%hhd.%hhd.%hhd.%hhd", &tcp_server_ip[0], &tcp_server_ip[1], &tcp_server_ip[2], &tcp_server_ip[3]);
         }
         sscanf(argv[3], "%d", &tcp_send_num);

Ubiquitous/XiZi_IIoT/resources/serial/dev_serial.c

@@ -286,6 +286,7 @@ static inline int SerialDevDMARead(struct SerialHardwareDevice *serial_dev, stru
     x_size_t read_dma_length;
     x_size_t read_dma_size = SerialGetRxFifoLength(serial_dev);
     
+    lock = CriticalAreaLock();
     if (serial_cfg->data_cfg.serial_buffer_size) {
         if(read_length < (int)read_dma_size)
             read_dma_length = read_length;

Ubiquitous/XiZi_IIoT/tool/shell/letter-shell/file_ext/tar.c

@@ -31,7 +31,7 @@ static void PrintOctal(char *str, int len, uint64_t value)
     char *cp;
     int written_len;
 
-    written_len = sprintf(buf, "%0*lo", len, value);
+    written_len = sprintf(buf, "%0*llo", len, value);
     cp = buf + written_len - len;
 
     if (*cp == '0')