fix some calloc bug

1. some calloc fix
2. fix some document error
3. refactor kv API, to be compatible with ota API

board/TencentOS_tiny_EVB_MX_Plus/BSP/Hardware/ONCHIP_FLASH/onchip_flash_kv.c

@@ -7,9 +7,6 @@
 #define SECTOR_SIZE                 2048         // sector size for stm32l431RCTX
 #define SECTOR_SIZE_LOG2            11  // 2 ^ 11 = 2048
 
-#define FOR_KV_FLASH_SIZE           (2 * SECTOR_SIZE)  // storage for kv
-#define FOR_KV_FLASH_START          0x803d000
-
 kv_flash_drv_t stm32l4_norflash_onchip_drv = {
     .write  = stm32l4_norflash_onchip_write,
     .read   = stm32l4_norflash_onchip_read,
@@ -19,7 +16,5 @@ kv_flash_drv_t stm32l4_norflash_onchip_drv = {
 kv_flash_prop_t stm32l4_norflash_onchip_prop = {
     .sector_size_log2   = SECTOR_SIZE_LOG2,
     .pgm_type           = KV_FLASH_PROGRAM_TYPE_DOUBLEWORD,
-    .flash_start        = FOR_KV_FLASH_START,
-    .flash_size         = FOR_KV_FLASH_SIZE,
 };
 

board/TencentOS_tiny_EVB_MX_Plus/BSP/Hardware/QSPI_FLASH/qspi_flash_kv.c

@@ -4,9 +4,6 @@
 #define SECTOR_SIZE                 4096    // sector size for qspiflash
 #define SECTOR_SIZE_LOG2            12  // 2 ^ 12 = 4096
 
-#define FOR_KV_FLASH_SIZE           (2 * SECTOR_SIZE)
-#define FOR_KV_FLASH_START          0x0
-
 int stm32l4_qspiflash_read(uint32_t addr, void *buf, size_t len)
 {
     return hal_spi_flash_read(buf, len, addr);
@@ -33,8 +30,6 @@ kv_flash_drv_t stm32l4_qspiflash_drv = {
 kv_flash_prop_t stm32l4_qspiflash_prop = {
     .sector_size_log2   = SECTOR_SIZE_LOG2,
     .pgm_type           = KV_FLASH_PROGRAM_TYPE_BYTE,
-    .flash_start        = FOR_KV_FLASH_START,
-    .flash_size         = FOR_KV_FLASH_SIZE,
 };
 
 

components/connectivity/Eclipse-Paho-MQTT/wrapper/src/mqtt_wrapper.c

 #include "mqtt_wrapper.h"
 
 #define BUFFER_LEN      256
+static unsigned char buffer[BUFFER_LEN];
 
 static MQTTPacket_connectData mqtt_form_connect_packet(mqtt_con_opt_t *opt)
 {
@@ -20,7 +21,6 @@ int tos_mqtt_connect(char *host, const char *port, mqtt_con_opt_t *opt)
     int sock = 0;
     int serialize_len = 0;
     unsigned char session_present, connack_rc;
-    unsigned char buffer[BUFFER_LEN];
     MQTTPacket_connectData connect_packet;
 
     sock = transport_open(host, port);
@@ -61,7 +61,6 @@ errout:
 int tos_mqtt_publish(int sock, mqtt_pub_opt_t*opt)
 {
     int serialize_len;
-    unsigned char buffer[BUFFER_LEN];
     MQTTString pub_topic;
 
     pub_topic.cstring = opt->topic;
@@ -93,7 +92,6 @@ int tos_mqtt_subscribe(int sock, mqtt_sub_opt_t *opt)
     unsigned short packet_id;
     int max_count, granted_qos;
     int serialize_len;
-    unsigned char buffer[BUFFER_LEN];
     MQTTString sub_topic;
 
     sub_topic.cstring = opt->topic;
@@ -129,7 +127,6 @@ int tos_mqtt_receive(char *topic, int topic_len, unsigned char *payload, int pay
     unsigned char *incoming_data;
     int incoming_data_len, payload_copy_len;
     MQTTString incoming_topic;
-    unsigned char buffer[BUFFER_LEN];
 
     if (MQTTPacket_read(buffer, sizeof(buffer), transport_getdata) != PUBLISH)	 {
         return -1;
@@ -151,7 +148,7 @@ int tos_mqtt_receive(char *topic, int topic_len, unsigned char *payload, int pay
         strncpy(topic, incoming_topic.lenstring.data, topic_copy_len);
         if (topic_copy_len <= topic_len - 1) {
             topic[topic_copy_len] = '\0';
-        }   
+        }
     }
 
     return incoming_data_len;

components/connectivity/mqttclient/common/log/arch/tencentos-tiny/arch.c

@@ -14,6 +14,10 @@ void *salof_alloc(unsigned int size)
     return tos_mmheap_alloc(size);
 }
 
+void *salof_calloc(size_t num, size_t size)
+{
+    return tos_mmheap_calloc(num, size);
+}
 
 void salof_free(void *mem)
 {
@@ -30,13 +34,13 @@ salof_tcb salof_task_create(const char *name,
     salof_tcb task;
     k_err_t err;
     k_stack_t *task_stack;
-    task = salof_alloc(sizeof(k_task_t));
+    task = salof_calloc(1, sizeof(k_task_t));
     task_stack = salof_alloc(stack_size);
-    err = tos_task_create(task, 
-                          (char*)name, 
+    err = tos_task_create(task,
+                          (char*)name,
                           task_entry,
-                          param, 
-                          priority, 
+                          param,
+                          priority,
                           task_stack,
                           stack_size,
                           tick);
@@ -53,7 +57,7 @@ salof_mutex salof_mutex_create(void)
 {
     salof_mutex mutex;
     mutex = salof_alloc(sizeof(k_mutex_t));
-	tos_mutex_create((salof_mutex)mutex);	
+	tos_mutex_create((salof_mutex)mutex);
     return mutex;
 }
 
@@ -83,7 +87,7 @@ salof_sem salof_sem_create(void)
 {
     salof_sem sem;
     sem = salof_alloc(sizeof(k_sem_t));
-	tos_sem_create((salof_sem)sem, 0);	
+	tos_sem_create((salof_sem)sem, 0);
     return sem;
 }
 
@@ -120,4 +124,4 @@ char *salof_get_task_name(void)
     return k_curr_task->name;
 }
 
-#endif 
+#endif

components/connectivity/mqttclient/platform/TencentOS-tiny/platform_thread.c

@@ -18,18 +18,18 @@ platform_thread_t *platform_thread_init( const char *name,
     platform_thread_t *thread;
     k_err_t err;
     k_stack_t *thread_stack;
-    thread = platform_memory_alloc(sizeof(platform_thread_t));
+    thread = platform_memory_calloc(1, sizeof(platform_thread_t));
     thread_stack = (k_stack_t*) platform_memory_alloc(stack_size);
-    
-    err = tos_task_create(&(thread->thread), 
-                          (char*)name, 
+
+    err = tos_task_create(&(thread->thread),
+                          (char*)name,
                           entry,
-                          param, 
-                          priority, 
+                          param,
+                          priority,
                           thread_stack,
                           stack_size,
                           tick);
-    
+
     if(err != K_ERR_NONE) {
         platform_memory_free(thread);
         platform_memory_free(thread_stack);

components/fs/kv/include/tos_kv.h

@@ -53,8 +53,8 @@ typedef uint64_t    kv_dword_t; // double word
 #define KV_BLK_FLAG_HANGING                         0x10    /* index building failed, we mark a hanging flag here, and will give another chance to do a retry */
 
 #define KV_FLASH_START                              (kv_ctl.flash_ctl.flash_start)
-#define KV_FLASH_SIZE                               (kv_ctl.flash_ctl.flash_size)
-#define KV_FLASH_END                                (KV_FLASH_START + KV_FLASH_SIZE)
+#define KV_FLASH_END                                (kv_ctl.flash_ctl.flash_end)
+#define KV_FLASH_SIZE                               (KV_FLASH_END - KV_FLASH_START)
 #define KV_FLASH_SECTOR_SIZE_LOG2                   (kv_ctl.flash_ctl.sector_size_log2)
 #define KV_FLASH_SECTOR_SIZE                        (1 << KV_FLASH_SECTOR_SIZE_LOG2)
 #define KV_FLASH_WRITE_ALIGN                        (kv_ctl.flash_ctl.flash_write_align)
@@ -126,7 +126,7 @@ typedef struct kv_flash_control_st {
     uint8_t         sector_size_log2;
     uint8_t         flash_write_align;
     uint32_t        flash_start;
-    uint32_t        flash_size;
+    uint32_t        flash_end;
 
     kv_flash_drv_t  flash_drv;
 } kv_flash_ctl_t;
@@ -313,7 +313,7 @@ __STATIC_INLINE__ void kv_blk_reset_hanging(uint32_t blk_start)
 
 typedef kv_err_t (*kv_item_walker_t)(kv_item_t *item, const void *patten);
 
-__API__ kv_err_t    tos_kv_init(kv_flash_drv_t *flash_drv, kv_flash_prop_t *flash_prop);
+__API__ kv_err_t    tos_kv_init(uint32_t flash_start, uint32_t flash_end, kv_flash_drv_t *flash_drv, kv_flash_prop_t *flash_prop);
 
 __API__ kv_err_t    tos_kv_deinit(void);
 

components/fs/kv/include/tos_kv_flash.h

@@ -38,8 +38,6 @@ typedef struct kv_flash_drv_st {
 typedef struct kv_flash_property_st {
     uint8_t             sector_size_log2;
     kv_flash_pgm_type_t pgm_type;
-    uint32_t            flash_start;
-    uint32_t            flash_size;
 } kv_flash_prop_t;
 
 #endif /* _TOS_KV_FLASH_H_ */

components/fs/kv/tos_kv.c

@@ -91,12 +91,12 @@ __STATIC__ kv_err_t  kv_flash_blk_erase(uint32_t blk_start)
     return kv_flash_erase(blk_start, KV_BLK_SIZE);
 }
 
-__STATIC__ void kv_flash_ctl_init(kv_flash_drv_t *flash_drv, kv_flash_prop_t *flash_prop)
+__STATIC__ void kv_flash_ctl_init(uint32_t flash_start, uint32_t flash_end, kv_flash_drv_t *flash_drv, kv_flash_prop_t *flash_prop)
 {
     memcpy(&kv_ctl.flash_ctl.flash_drv, flash_drv, sizeof(kv_flash_drv_t));
 
-    KV_FLASH_START              = flash_prop->flash_start;
-    KV_FLASH_SIZE               = flash_prop->flash_size;
+    KV_FLASH_START              = flash_start;
+    KV_FLASH_END                = flash_end;
     KV_FLASH_SECTOR_SIZE_LOG2   = flash_prop->sector_size_log2;
 
     if (flash_prop->pgm_type == KV_FLASH_PROGRAM_TYPE_BYTE) {
@@ -866,17 +866,17 @@ __STATIC__ kv_err_t kv_item_update(kv_item_t *item, const char *key, const void
     return kv_item_delete(item);
 }
 
-__STATIC__ kv_err_t kv_param_verify(kv_flash_drv_t *flash_drv, kv_flash_prop_t *flash_prop)
+__STATIC__ kv_err_t kv_param_verify(uint32_t flash_start, uint32_t flash_end, kv_flash_drv_t *flash_drv, kv_flash_prop_t *flash_prop)
 {
     if (!flash_drv || !flash_prop) {
         return KV_ERR_INVALID_PARAM;
     }
 
-    if (!KV_IS_ALINGED_LOG2(flash_prop->flash_start, flash_prop->sector_size_log2)) {
+    if (!KV_IS_ALINGED_LOG2(flash_start, flash_prop->sector_size_log2)) {
         return KV_ERR_INVALID_PARAM;
     }
 
-    if (!KV_IS_ALINGED_LOG2(flash_prop->flash_size, flash_prop->sector_size_log2)) {
+    if (!KV_IS_ALINGED_LOG2(flash_end, flash_prop->sector_size_log2)) {
         return KV_ERR_INVALID_PARAM;
     }
 
@@ -1196,17 +1196,17 @@ __DEBUG__ kv_err_t tos_kv_walkthru(void)
     return KV_ERR_NONE;
 }
 
-__API__ kv_err_t tos_kv_init(kv_flash_drv_t *flash_drv, kv_flash_prop_t *flash_prop)
+__API__ kv_err_t tos_kv_init(uint32_t flash_start, uint32_t flash_end, kv_flash_drv_t *flash_drv, kv_flash_prop_t *flash_prop)
 {
     kv_err_t err;
 
-    if (kv_param_verify(flash_drv, flash_prop) != KV_ERR_NONE) {
+    if (kv_param_verify(flash_start, flash_end, flash_drv, flash_prop) != KV_ERR_NONE) {
         return KV_ERR_INVALID_PARAM;
     }
 
     memset(&kv_ctl, 0, sizeof(kv_ctl));
 
-    kv_flash_ctl_init(flash_drv, flash_prop);
+    kv_flash_ctl_init(flash_start, flash_end, flash_drv, flash_prop);
 
     err = kv_mgr_ctl_init();
     if (err != KV_ERR_NONE) {

doc/04.Development_Manual.md

@@ -779,11 +779,7 @@ int main(void)
 
 ##### 编程实例
 
-1、在tos_config.h中，配置完成量组件开关TOS_CFG_COMPLETION_EN：
-
-`#define TOS_CFG_COMPLETION_EN		1u`
-
-2、编写main.c示例代码：
+1、编写main.c示例代码：
 
 ```c
 /*
@@ -898,11 +894,11 @@ void entry_task_wizard(void *arg)
     printf("wizard: I will set 3 warriors to find the fragments\n");
     tos_countdownlatch_create(&countdownlatch, 3);
     (void)tos_task_create(&task_warrior_0, "warrior_0", entry_task_warrior_0, NULL,
-                                4, stack_task_warrior_0, STK_SIZE_TASK_WIZARD, 0);
+                                4, stack_task_warrior_0, STK_SIZE_TASK_WARRIOR, 0);
     (void)tos_task_create(&task_warrior_1, "warrior_1", entry_task_warrior_1, NULL,
-                                4, stack_task_warrior_1, STK_SIZE_TASK_WIZARD, 0);
+                                4, stack_task_warrior_1, STK_SIZE_TASK_WARRIOR, 0);
     (void)tos_task_create(&task_warrior_2, "warrior_2", entry_task_warrior_2, NULL,
-                                4, stack_task_warrior_2, STK_SIZE_TASK_WIZARD, 0);
+                                4, stack_task_warrior_2, STK_SIZE_TASK_WARRIOR, 0);
     printf("wizard: now warriors are on their way, I will wait here until they all done the job\n");
     tos_countdownlatch_pend(&countdownlatch);
     printf("wizard: the warriors all have done their jobs, let's make the weapon\n");
@@ -949,7 +945,6 @@ int main(void)
 #include "tos_k.h"
 #include "mcu_init.h"
 
-#define STK_SIZE_TASK_WIZARD    512
 #define STK_SIZE_TASK_WARRIOR   512
 
 k_stack_t stack_task_warrior_0[STK_SIZE_TASK_WARRIOR];
@@ -996,11 +991,11 @@ int main(void)
     tos_barrier_create(&barrier, 3);
 
     (void)tos_task_create(&task_warrior_0, "warrior_0", entry_task_warrior_0, NULL,
-                                4, stack_task_warrior_0, STK_SIZE_TASK_WIZARD, 0);
+                                4, stack_task_warrior_0, STK_SIZE_TASK_WARRIOR, 0);
     (void)tos_task_create(&task_warrior_1, "warrior_1", entry_task_warrior_1, NULL,
-                                4, stack_task_warrior_1, STK_SIZE_TASK_WIZARD, 0);
+                                4, stack_task_warrior_1, STK_SIZE_TASK_WARRIOR, 0);
     (void)tos_task_create(&task_warrior_2, "warrior_2", entry_task_warrior_2, NULL,
-                                4, stack_task_warrior_2, STK_SIZE_TASK_WIZARD, 0);
+                                4, stack_task_warrior_2, STK_SIZE_TASK_WARRIOR, 0);
     tos_knl_start();
 }
 ```

doc/20.In_Application_Programming_based_EVB_MX_Plus.md

@@ -137,7 +137,7 @@ board\TencentOS_tiny_EVB_MX_Plus\KEIL\iap\application\TencentOS_tiny.bin
 
    ![4](image/IAP/mini_program/4.jpg)
 
-6. 等待镜像传输并烧写完毕后，在BootLoader的菜单选项下，点击菜单选项“4”执行刚才烧录的APP：
+6. 等待镜像传输并烧写完毕后，在BootLoader的菜单选项下，点击菜单选项“3”执行刚才烧录的APP：
 
    ![5](image/IAP/mini_program/5.jpg)
 

examples/kv/kv_sample.c

@@ -42,10 +42,10 @@ void task(void *arg)
 #endif
 
 #ifdef USING_ONCHIP_FLASH
-    err = tos_kv_init(&stm32l4_norflash_onchip_drv, &stm32l4_norflash_onchip_prop);
+    err = tos_kv_init(0x803d000, 0x803d000 + 2 * 2048, &stm32l4_norflash_onchip_drv, &stm32l4_norflash_onchip_prop);
     printf("kv init, rc: %d\n", err);
 #else
-    err = tos_kv_init(&stm32l4_qspiflash_drv, &stm32l4_qspiflash_prop);
+    err = tos_kv_init(0, 2 * 4096, &stm32l4_qspiflash_drv, &stm32l4_qspiflash_prop);
     printf("kv init, rc: %d\n", err);
 #endif
 

examples/wifi_ln882x/tcp_client_echo.c

@@ -25,14 +25,14 @@ void tcp_client_echo_task_entry(void *arg)
     struct sockaddr_in target_sockaddr;
     ip4_addr_t target_ser_ip;
 
-    int optval = 0;           
-    int len = sizeof(int); 
+    int optval = 0;
+    int len = sizeof(int);
     struct timeval tv;
 
     target_ser_t target_ser = *(target_ser_t*)arg;
 
-    
-    if(!ipaddr_aton((const char *)target_ser.ip, &target_ser_ip)) 
+
+    if(!ipaddr_aton((const char *)target_ser.ip, &target_ser_ip))
     {
         LOG(LOG_LVL_ERROR, "[%s, %d]Convert target server ip addr failed.\r\n", __func__, __LINE__);
         return;
@@ -58,23 +58,25 @@ void tcp_client_echo_task_entry(void *arg)
 
     while (1)
     {
-    
+
         if(connect(conn, (struct sockaddr *)&target_sockaddr, sizeof(struct sockaddr)) == -1)
         {
             LOG(LOG_LVL_ERROR, "[%s, %d]Connect target tcp server faild!\r\n", __func__, __LINE__);
             OS_MsDelay(3000);
             continue;
         }
-        
+
         LOG(LOG_LVL_ERROR, "[%s, %d]Connect target tcp server successful!\r\n", __func__, __LINE__);
-        
+
         while (1)
         {
+            ret = send(conn, "hello", strlen("hello"), 0);
+
             //---------------recv data-----------------------//
             memset(recv_data,0,sizeof(recv_data));
-            
+
             ret = recv(conn, recv_data, BUFSZ-1, 0);
-            getsockopt(conn, SOL_SOCKET, SO_ERROR, &optval, (socklen_t *)&len);        
+            getsockopt(conn, SOL_SOCKET, SO_ERROR, &optval, (socklen_t *)&len);
             if (ret < 0)
             {
                 if(optval == EWOULDBLOCK){
@@ -99,26 +101,18 @@ void tcp_client_echo_task_entry(void *arg)
                     LOG(LOG_LVL_ERROR, "[%s, %d] recv = 0 (err optval = %d)\r\n", __func__, __LINE__,  optval);
                     closesocket(conn);
                     break;
-                }            
+                }
             }
             else
             {
                 cli_recv_count += ret;
                 LOG(LOG_LVL_ERROR, "client_recv_count = %u\r\n", cli_recv_count);
             }
-            
+
             //---------------send data-----------------------//
-            if(!strstr(recv_data,"TencentOS tiny"))
-            {
-                ret = send(conn, "tcp client push massage!", strlen("tcp client push massage!"), 0);
-                OS_MsDelay(2000);
-            }
-            else
-            {
-                ret = send(conn, recv_data, ret, 0);                
-            }
+            LOG(LOG_LVL_INFO, "received: %s\r\n", recv_data);
 
-            getsockopt(conn, SOL_SOCKET, SO_ERROR, &optval, (socklen_t *)&len);        
+            getsockopt(conn, SOL_SOCKET, SO_ERROR, &optval, (socklen_t *)&len);
             if (ret < 0)
             {
                 if(optval == EWOULDBLOCK){
@@ -132,7 +126,7 @@ void tcp_client_echo_task_entry(void *arg)
                     LOG(LOG_LVL_ERROR, "[%s, %d] send < 0 (err optval = %d)\r\n", __func__, __LINE__, optval);
                     closesocket(conn);
                     break;
-                }                
+                }
             }
             else if(ret == 0)
             {
@@ -143,11 +137,13 @@ void tcp_client_echo_task_entry(void *arg)
                     LOG(LOG_LVL_ERROR, "[%s, %d] send = 0 (err optval = %d)\r\n", __func__, __LINE__, optval);
                     closesocket(conn);
                     break;
-                }            
+                }
             }
+
+            OS_MsDelay(3000);
         }
     }
-    
+
     closesocket(conn);
     LOG(LOG_LVL_ERROR, "[%s, %d]tcp client sock closed.\r\n", __func__, __LINE__);
 }
@@ -158,7 +154,7 @@ void tcp_client_echo_task_creat(uint8_t * ser_ip, uint32_t port)
     target_ser_t ser = {0};
     ser.ip   = ser_ip;
     ser.port = port;
-    
+
     osThreadCreate(osThread(tcp_client_echo_task_entry), &ser);
 }
 

examples/wifi_ln882x/wifi_app_ln882x.c

@@ -26,8 +26,8 @@ void wifi_init_sta(void)
     uint8_t macaddr[6] = {0}, macaddr_default[6] = {0};
     wifi_config_t wifi_config = {
         .sta = {
-            .ssid     = "LN882x-AP",
-            .password = "",
+            .ssid     = "SheldonDai",
+            .password = "srnr6x9xbhmb0",
             0,
         },
     };
@@ -198,7 +198,7 @@ void application_entry(void *arg)
     };
     
     tcp_server_echo_task_creat(8087);
-    tcp_client_echo_task_creat((uint8_t *)"120.76.100.197", 10002);//ͨè(IP:120.76.100.197) 10002˿
+    tcp_client_echo_task_creat((uint8_t *)"39.108.190.129", 8000);//ͨè(IP:120.76.100.197) 10002˿
     
     while(1)
     {

kernel/core/include/tos_task.h

@@ -293,7 +293,7 @@ __API__ void    tos_task_yield(void);
  * @brief Get current running task.
  * Get current running task.
  *
- * @attention is kernel is not running, you'll get K_NULL
+ * @attention if kernel is not running, you'll get K_NULL
  *
  * @param   None
  *

kernel/core/tos_ring_queue.c

@@ -220,7 +220,7 @@ __API__ int tos_ring_q_is_empty(k_ring_q_t *ring_q)
     TOS_OBJ_VERIFY_RC(ring_q, KNL_OBJ_TYPE_RING_QUEUE, K_FALSE);
 
     TOS_CPU_INT_DISABLE();
-    is_empty = (ring_q->total == 0);
+    is_empty = (ring_q->total == 0 ? K_TRUE : K_FALSE);
     TOS_CPU_INT_ENABLE();
 
     return is_empty;
@@ -235,7 +235,7 @@ __API__ int tos_ring_q_is_full(k_ring_q_t *ring_q)
     TOS_OBJ_VERIFY_RC(ring_q, KNL_OBJ_TYPE_RING_QUEUE, K_FALSE);
 
     TOS_CPU_INT_DISABLE();
-    is_full = (ring_q->total == ring_q->item_cnt);
+    is_full = (ring_q->total == ring_q->item_cnt ? K_TRUE : K_FALSE);
     TOS_CPU_INT_ENABLE();
 
     return is_full;

kernel/core/tos_task.c

@@ -250,7 +250,7 @@ __API__ k_err_t tos_task_create_dyn(k_task_t **task,
         return K_ERR_TASK_PRIO_INVALID;
     }
 
-    the_task = tos_mmheap_alloc(sizeof(k_task_t));
+    the_task = tos_mmheap_calloc(1, sizeof(k_task_t));
     if (!the_task) {
         return K_ERR_TASK_OUT_OF_MEMORY;
     }

kernel/pm/tos_tickless.c

@@ -142,6 +142,9 @@ __KNL__ void tickless_proc(void)
     lpwr_mode = pm_cpu_lpwr_mode_get();
 
     time_sleep = tickless_cpu_sleep_time_get(lpwr_mode); /* in millisecond */
+    if (unlikely(time_sleep == (k_time_t)0)) {
+        return;
+    }
 
     tickless_enter();
     tickless_wkup_alarm_setup(lpwr_mode, time_sleep);

osal/posix/pthread.c

@@ -565,6 +565,7 @@ __API__ int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *
     the_ctl->stackaddr      = (is_stk_need_free ? stackaddr : K_NULL);
     the_ctl->start_routine  = start_routine;
     the_ctl->arg            = arg;
+    memset(&the_ctl->ktask, 0, sizeof(k_task_t));
 
     stackaddr               = (void *)((cpu_addr_t)stackaddr + PTHREAD_INFO_SIZE);
     stacksize              -= PTHREAD_INFO_SIZE;