PowLu/TencentOS-tiny
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

kernel_perf: update to 2.5.1 version

Browse Source
This commit is contained in:
mculover666
2022-06-02 17:01:58 +08:00
parent e38c8775ac
commit 86bc533bb8
31 changed files with 495 additions and 91 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
kernel/core/include/tos_event.h
View File

@@ -76,6 +76,37 @@ __API__ k_err_t tos_event_create(k_event_t *event, k_event_flag_t init_flag);
*/
__API__ k_err_t tos_event_destroy(k_event_t *event);
#if TOS_CFG_OBJ_DYNAMIC_CREATE_EN > 0u
/**
* @brief Create an dynamic event.
* create an event.
*
* @attention None
*
* @param[in] event pointer to the handler of the event pointer.
* @param[in] init_flag initial flag of the event.
*
* @return errcode
* @retval #K_ERR_NONE return successfully.
*/
__API__ k_err_t tos_event_create_dyn(k_event_t **event, k_event_flag_t init_flag);
/**
* @brief Destroy an dynamic event.
* destroy an event.
*
* @attention None
*
* @param[in] event pointer to the handler of the event.
*
* @return errcode
* @retval #K_ERR_NONE return successfully.
*/
__API__ k_err_t tos_event_destroy_dyn(k_event_t *event);
#endif
/**
* @brief Pend an event.
* pend an event.

2
kernel/core/include/tos_global.h
View File

@@ -44,7 +44,7 @@ extern k_stack_t k_idle_task_stk[];
extern k_stack_t *const k_idle_task_stk_addr;
extern size_t const k_idle_task_stk_size;
#if TOS_CFG_TASK_DYNAMIC_CREATE_EN > 0u
#if TOS_CFG_OBJ_DYNAMIC_CREATE_EN > 0u
/* list to hold all the destroyed dynamic created tasks */
extern k_list_t k_dead_task_list;
#endif

5
kernel/core/include/tos_kerr.h
View File

@@ -111,7 +111,6 @@ typedef enum k_err_en {
K_ERR_TASK_SUSPEND_IDLE,
K_ERR_TASK_STK_OVERFLOW,
K_ERR_TASK_STK_SIZE_INVALID,
K_ERR_TASK_OUT_OF_MEMORY,
K_ERR_TICKLESS_WKUP_ALARM_NOT_INSTALLED = 2000u,
K_ERR_TICKLESS_WKUP_ALARM_NO_INIT,
@@ -126,10 +125,6 @@ typedef enum k_err_en {
K_ERR_TIMER_INVALID_OPT,
K_ERR_TIMER_STOPPED,
K_ERR_TIMER_RUNNING,
K_ERR_SEM_OUT_OF_MEMORY = 2200u,
K_ERR_MUTEX_OUT_OF_MEMORY = 2300u,
} k_err_t;
#endif /* _TOS_ERR_H_ */

23
kernel/core/include/tos_mutex.h
View File

@@ -45,6 +45,21 @@ typedef struct k_mutex_st {
*/
__API__ k_err_t tos_mutex_create(k_mutex_t *mutex);
/**
* @brief Destroy a mutex.
* destroy a mutex.
*
* @attention None
*
* @param[in] mutex pointer to the handler of the mutex.
*
* @return errcode
* @retval #K_ERR_NONE return successfully.
*/
__API__ k_err_t tos_mutex_destroy(k_mutex_t *mutex);
#if TOS_CFG_OBJ_DYNAMIC_CREATE_EN > 0u
/**
* @brief Create a dynamic mutex.
* create a dynamic mutex.
@@ -59,8 +74,8 @@ __API__ k_err_t tos_mutex_create(k_mutex_t *mutex);
__API__ k_err_t tos_mutex_create_dyn(k_mutex_t **mutex);
/**
* @brief Destroy a mutex.
* destroy a mutex.
* @brief Destroy a dynamic mutex.
* destroy a dynamic mutex.
*
* @attention None
*
@@ -69,7 +84,9 @@ __API__ k_err_t tos_mutex_create_dyn(k_mutex_t **mutex);
* @return errcode
* @retval #K_ERR_NONE return successfully.
*/
__API__ k_err_t tos_mutex_destroy(k_mutex_t *mutex);
__API__ k_err_t tos_mutex_destroy_dyn(k_mutex_t *mutex);
#endif
/**
* @brief Pend a mutex.

23
kernel/core/include/tos_sem.h
View File

@@ -59,6 +59,21 @@ __API__ k_err_t tos_sem_create_max(k_sem_t *sem, k_sem_cnt_t init_count, k_sem_c
*/
__API__ k_err_t tos_sem_create(k_sem_t *sem, k_sem_cnt_t init_count);
/**
* @brief Destroy a semaphore.
* destroy a semaphore.
*
* @attention None
*
* @param[in] semaphore pointer to the handler of the semaphore.
*
* @return errcode
* @retval #K_ERR_NONE return successfully.
*/
__API__ k_err_t tos_sem_destroy(k_sem_t *sem);
#if TOS_CFG_OBJ_DYNAMIC_CREATE_EN > 0u
/**
* @brief Create a dynamic semaphore with a limitation of maximum count.
* create a dynamic semaphore with a limitation of maximum count.
@@ -89,8 +104,8 @@ __API__ k_err_t tos_sem_create_max_dyn(k_sem_t **sem, k_sem_cnt_t init_count, k_
__API__ k_err_t tos_sem_create_dyn(k_sem_t **sem, k_sem_cnt_t init_count);
/**
* @brief Destroy a semaphore.
* destroy a semaphore.
* @brief Destroy a dynamic semaphore.
* destroy a dynamic semaphore.
*
* @attention None
*
@@ -99,7 +114,9 @@ __API__ k_err_t tos_sem_create_dyn(k_sem_t **sem, k_sem_cnt_t init_count);
* @return errcode
* @retval #K_ERR_NONE return successfully.
*/
__API__ k_err_t tos_sem_destroy(k_sem_t *sem);
__API__ k_err_t tos_sem_destroy_dyn(k_sem_t *sem);
#endif
/**
* @brief Pend a semaphore.

4
kernel/core/include/tos_task.h
View File

@@ -86,7 +86,7 @@ struct k_task_st {
k_stack_t *stk_base; /**< task stack base address */
size_t stk_size; /**< stack size of the task */
#if TOS_CFG_TASK_DYNAMIC_CREATE_EN > 0u
#if TOS_CFG_OBJ_DYNAMIC_CREATE_EN > 0u
k_list_t dead_list; /**< when a dynamic allocated task destroyed, we hook the task's dead_list to the k_dead_task_list */
#endif
@@ -176,7 +176,7 @@ __API__ k_err_t tos_task_create(k_task_t *task,
*/
__API__ k_err_t tos_task_destroy(k_task_t *task);
#if TOS_CFG_TASK_DYNAMIC_CREATE_EN > 0u
#if TOS_CFG_OBJ_DYNAMIC_CREATE_EN > 0u
/**
* @brief Create a task with a dynamic allocated task handler and stack.

39
kernel/core/include/tos_timer.h
View File

@@ -102,6 +102,45 @@ __API__ k_err_t tos_timer_create(k_timer_t *tmr, k_tick_t delay, k_tick_t period
*/
__API__ k_err_t tos_timer_destroy(k_timer_t *tmr);
#if TOS_CFG_OBJ_DYNAMIC_CREATE_EN > 0u
/**
* @brief Create a dynamic timer.
* Create a timer.
*
* @attention I dont't think a timer need a name. If you do, help yourself.
*
* @param[in] tmr pointer to the handler of the timer pointer.
* @param[in] delay time interval for a timer to run.
* @param[in] period period for a timer to restart to run.
* @param[in] callback callback function called when the timer expires.
* @param[in] cb_arg argument for the callback.
* @param[in] opt option for the function call.
*
* @return errcode
* @retval #K_ERR_TIMER_INVALID_PERIOD period is invalid.
* @retval #K_ERR_TIMER_INVALID_DELAY delay is invalid.
* @retval #K_ERR_NONE return successfully.
*/
__API__ k_err_t tos_timer_create_dyn(k_timer_t **tmr, k_tick_t delay, k_tick_t period,
k_timer_callback_t callback, void *cb_arg, k_opt_t opt);
/**
* @brief Delete a dynamic timer.
* Delete the timer.
*
* @attention None
*
* @param[in] tmr pointer to the handler of the timer.
*
* @return errcode
* @retval #K_ERR_TIMER_INACTIVE the timer is not active yet.
* @retval #K_ERR_NONE return successfully.
*/
__API__ k_err_t tos_timer_destroy_dyn(k_timer_t *tmr);
#endif
/**
* @brief Start a timer.
* Start the timer to run.

4
kernel/core/include/tos_version.h
View File

@@ -25,8 +25,8 @@
#define TOS_VERSION_MAJOR 0x02
#define TOS_VERSION_MINOR 0x05
#define TOS_VERSION_PATCH 0x00
#define TOS_VERSION "2.5.0"
#define TOS_VERSION_PATCH 0x01
#define TOS_VERSION "2.5.1"
#endif /* _TOS_VERSION_H_ */

70
kernel/core/tos_event.c
View File

@@ -27,6 +27,10 @@ __API__ k_err_t tos_event_create(k_event_t *event, k_event_flag_t init_flag)
pend_object_init(&event->pend_obj);
TOS_OBJ_INIT(event, KNL_OBJ_TYPE_EVENT);
#if TOS_CFG_OBJ_DYNAMIC_CREATE_EN > 0u
knl_object_alloc_set_static(&event->knl_obj);
#endif
return K_ERR_NONE;
}
@@ -37,6 +41,12 @@ __API__ k_err_t tos_event_destroy(k_event_t *event)
TOS_PTR_SANITY_CHECK(event);
TOS_OBJ_VERIFY(event, KNL_OBJ_TYPE_EVENT);
#if TOS_CFG_OBJ_DYNAMIC_CREATE_EN > 0u
if (!knl_object_alloc_is_static(&event->knl_obj)) {
return K_ERR_OBJ_INVALID_ALLOC_TYPE;
}
#endif
TOS_CPU_INT_DISABLE();
pend_wakeup_all(&event->pend_obj, PEND_STATE_DESTROY);
@@ -47,12 +57,72 @@ __API__ k_err_t tos_event_destroy(k_event_t *event)
TOS_OBJ_DEINIT(event);
#if TOS_CFG_OBJ_DYNAMIC_CREATE_EN > 0u
knl_object_alloc_reset(&event->knl_obj);
#endif
TOS_CPU_INT_ENABLE();
knl_sched();
return K_ERR_NONE;
}
#if TOS_CFG_OBJ_DYNAMIC_CREATE_EN > 0u
__API__ k_err_t tos_event_create_dyn(k_event_t **event, k_event_flag_t init_flag)
{
k_event_t *the_event;
TOS_IN_IRQ_CHECK();
TOS_PTR_SANITY_CHECK(event);
the_event = tos_mmheap_calloc(1, sizeof(k_event_t));
if (!the_event) {
return K_ERR_OUT_OF_MEMORY;
}
the_event->flag = init_flag;
pend_object_init(&the_event->pend_obj);
TOS_OBJ_INIT(the_event, KNL_OBJ_TYPE_EVENT);
knl_object_alloc_set_dynamic(&the_event->knl_obj);
*event = the_event;
return K_ERR_NONE;
}
__API__ k_err_t tos_event_destroy_dyn(k_event_t *event)
{
TOS_CPU_CPSR_ALLOC();
TOS_PTR_SANITY_CHECK(event);
TOS_OBJ_VERIFY(event, KNL_OBJ_TYPE_EVENT);
if (!knl_object_alloc_is_dynamic(&event->knl_obj)) {
return K_ERR_OBJ_INVALID_ALLOC_TYPE;
}
TOS_CPU_INT_DISABLE();
pend_wakeup_all(&event->pend_obj, PEND_STATE_DESTROY);
event->flag = (k_event_flag_t)0u;
pend_object_deinit(&event->pend_obj);
TOS_OBJ_DEINIT(event);
tos_mmheap_free(event);
TOS_CPU_INT_ENABLE();
knl_sched();
return K_ERR_NONE;
}
#endif
__STATIC__ int event_is_match(k_event_flag_t event, k_event_flag_t flag_expect, k_event_flag_t *flag_match, k_opt_t opt_pend)
{
if (opt_pend & TOS_OPT_EVENT_PEND_ALL) {

2
kernel/core/tos_global.c
View File

@@ -36,7 +36,7 @@ k_tick_t k_cpu_tick_per_second = TOS_CFG_CPU_TICK_PER_SECOND;
k_cycle_t k_cpu_cycle_per_tick = (k_cycle_t)0u;
#if TOS_CFG_TASK_DYNAMIC_CREATE_EN > 0u
#if TOS_CFG_OBJ_DYNAMIC_CREATE_EN > 0u
TOS_LIST_DEFINE(k_dead_task_list);
#endif

8
kernel/core/tos_message_queue.c
View File

@@ -34,7 +34,10 @@ __API__ k_err_t tos_msg_q_create(k_msg_q_t *msg_q, void *pool, size_t msg_cnt)
pend_object_init(&msg_q->pend_obj);
TOS_OBJ_INIT(msg_q, KNL_OBJ_TYPE_MESSAGE_QUEUE);
#if TOS_CFG_OBJ_DYNAMIC_CREATE_EN > 0u
knl_object_alloc_set_static(&msg_q->knl_obj);
#endif
return K_ERR_NONE;
}
@@ -47,9 +50,11 @@ __API__ k_err_t tos_msg_q_destroy(k_msg_q_t *msg_q)
TOS_PTR_SANITY_CHECK(msg_q);
TOS_OBJ_VERIFY(msg_q, KNL_OBJ_TYPE_MESSAGE_QUEUE);
#if TOS_CFG_OBJ_DYNAMIC_CREATE_EN > 0u
if (!knl_object_alloc_is_static(&msg_q->knl_obj)) {
return K_ERR_OBJ_INVALID_ALLOC_TYPE;
}
#endif
TOS_CPU_INT_DISABLE();
@@ -64,7 +69,10 @@ __API__ k_err_t tos_msg_q_destroy(k_msg_q_t *msg_q)
pend_object_deinit(&msg_q->pend_obj);
TOS_OBJ_DEINIT(msg_q);
#if TOS_CFG_OBJ_DYNAMIC_CREATE_EN > 0u
knl_object_alloc_reset(&msg_q->knl_obj);
#endif
TOS_CPU_INT_ENABLE();
knl_sched();

24
kernel/core/tos_mmblk.c
View File

@@ -50,8 +50,10 @@ __API__ k_err_t tos_mmblk_pool_create(k_mmblk_pool_t *mbp, void *pool_start, siz
mbp->blk_size = blk_size;
TOS_OBJ_INIT(mbp, KNL_OBJ_TYPE_MMBLK_POOL);
#if TOS_CFG_OBJ_DYNAMIC_CREATE_EN > 0u
knl_object_alloc_set_static(&mbp->knl_obj);
#endif
return K_ERR_NONE;
}
@@ -60,8 +62,8 @@ __API__ k_err_t tos_mmblk_pool_destroy(k_mmblk_pool_t *mbp)
{
TOS_PTR_SANITY_CHECK(mbp);
TOS_OBJ_VERIFY(mbp, KNL_OBJ_TYPE_MMBLK_POOL);
#if TOS_CFG_MMHEAP_EN > 0u
#if TOS_CFG_OBJ_DYNAMIC_CREATE_EN > 0u
if (!knl_object_alloc_is_static(&mbp->knl_obj)) {
return K_ERR_OBJ_INVALID_ALLOC_TYPE;
}
@@ -78,7 +80,7 @@ __API__ k_err_t tos_mmblk_pool_destroy(k_mmblk_pool_t *mbp)
return K_ERR_NONE;
}
#if TOS_CFG_MMHEAP_EN > 0u
#if TOS_CFG_OBJ_DYNAMIC_CREATE_EN > 0u
__API__ k_err_t tos_mmblk_pool_create_dyn(k_mmblk_pool_t **mbp, size_t blk_num, size_t blk_size)
{
@@ -93,26 +95,26 @@ __API__ k_err_t tos_mmblk_pool_create_dyn(k_mmblk_pool_t **mbp, size_t blk_num,
if ((blk_size & K_MMBLK_ALIGN_MASK) != 0u) {
return K_ERR_MMBLK_INVALID_BLK_SIZE;
}
the_mbp = tos_mmheap_calloc(1, sizeof(k_mmblk_pool_t));
if (!the_mbp) {
return K_ERR_MMBLK_OUT_OF_MEMORY;
}
pool_start = tos_mmheap_alloc(blk_num * blk_size);
if (!pool_start) {
return K_ERR_MMBLK_POOL_OUT_OF_MEMORY;
}
blk_curr = pool_start;
blk_next = K_MMBLK_NEXT_BLK(blk_curr, blk_size);
for (i = 0; i < blk_num - 1u; ++i) {
*(void **)blk_curr = blk_next;
blk_curr = blk_next;
blk_curr = blk_next;
blk_next = K_MMBLK_NEXT_BLK(blk_next, blk_size);
}
*(void **)blk_curr = K_NULL;
the_mbp->pool_start = pool_start;
@@ -134,11 +136,11 @@ __API__ k_err_t tos_mmblk_pool_destroy_dyn(k_mmblk_pool_t *mbp)
{
TOS_PTR_SANITY_CHECK(mbp);
TOS_OBJ_VERIFY(mbp, KNL_OBJ_TYPE_MMBLK_POOL);
if (!knl_object_alloc_is_dynamic(&mbp->knl_obj)) {
return K_ERR_OBJ_INVALID_ALLOC_TYPE;
}
tos_mmheap_free(mbp->pool_start);
mbp->pool_start = K_NULL;

61
kernel/core/tos_mutex.c
View File

@@ -80,9 +80,51 @@ __API__ k_err_t tos_mutex_create(k_mutex_t *mutex)
TOS_OBJ_INIT(mutex, KNL_OBJ_TYPE_MUTEX);
#if TOS_CFG_OBJ_DYNAMIC_CREATE_EN > 0u
knl_object_alloc_set_static(&mutex->knl_obj);
#endif
return K_ERR_NONE;
}
__API__ k_err_t tos_mutex_destroy(k_mutex_t *mutex)
{
TOS_CPU_CPSR_ALLOC();
TOS_IN_IRQ_CHECK();
TOS_PTR_SANITY_CHECK(mutex);
TOS_OBJ_VERIFY(mutex, KNL_OBJ_TYPE_MUTEX);
#if TOS_CFG_OBJ_DYNAMIC_CREATE_EN > 0u
if (!knl_object_alloc_is_static(&mutex->knl_obj)) {
return K_ERR_OBJ_INVALID_ALLOC_TYPE;
}
#endif
TOS_CPU_INT_DISABLE();
pend_wakeup_all(&mutex->pend_obj, PEND_STATE_DESTROY);
if (mutex->owner) {
mutex_old_owner_release(mutex);
}
pend_object_deinit(&mutex->pend_obj);
TOS_OBJ_DEINIT(mutex);
#if TOS_CFG_OBJ_DYNAMIC_CREATE_EN > 0u
knl_object_alloc_reset(&mutex->knl_obj);
#endif
TOS_CPU_INT_ENABLE();
knl_sched();
return K_ERR_NONE;
}
#if TOS_CFG_OBJ_DYNAMIC_CREATE_EN > 0u
__API__ k_err_t tos_mutex_create_dyn(k_mutex_t **mutex)
{
k_mutex_t *the_mutex;
@@ -92,7 +134,7 @@ __API__ k_err_t tos_mutex_create_dyn(k_mutex_t **mutex)
the_mutex = tos_mmheap_calloc(1, sizeof(k_mutex_t));
if (!the_mutex) {
return K_ERR_MUTEX_OUT_OF_MEMORY;
return K_ERR_OUT_OF_MEMORY;
}
pend_object_init(&the_mutex->pend_obj);
@@ -109,7 +151,7 @@ __API__ k_err_t tos_mutex_create_dyn(k_mutex_t **mutex)
return K_ERR_NONE;
}
__API__ k_err_t tos_mutex_destroy(k_mutex_t *mutex)
__API__ k_err_t tos_mutex_destroy_dyn(k_mutex_t *mutex)
{
TOS_CPU_CPSR_ALLOC();
@@ -117,6 +159,10 @@ __API__ k_err_t tos_mutex_destroy(k_mutex_t *mutex)
TOS_PTR_SANITY_CHECK(mutex);
TOS_OBJ_VERIFY(mutex, KNL_OBJ_TYPE_MUTEX);
if (!knl_object_alloc_is_dynamic(&mutex->knl_obj)) {
return K_ERR_OBJ_INVALID_ALLOC_TYPE;
}
TOS_CPU_INT_DISABLE();
pend_wakeup_all(&mutex->pend_obj, PEND_STATE_DESTROY);
@@ -127,12 +173,9 @@ __API__ k_err_t tos_mutex_destroy(k_mutex_t *mutex)
pend_object_deinit(&mutex->pend_obj);
if (knl_object_alloc_is_dynamic(&mutex->knl_obj)) {
TOS_OBJ_DEINIT(mutex);
tos_mmheap_free(mutex);
} else {
TOS_OBJ_DEINIT(mutex);
}
TOS_OBJ_DEINIT(mutex);
tos_mmheap_free(mutex);
TOS_CPU_INT_ENABLE();
knl_sched();
@@ -140,6 +183,8 @@ __API__ k_err_t tos_mutex_destroy(k_mutex_t *mutex)
return K_ERR_NONE;
}
#endif
__API__ k_err_t tos_mutex_pend_timed(k_mutex_t *mutex, k_tick_t timeout)
{
TOS_CPU_CPSR_ALLOC();

64
kernel/core/tos_sem.c
View File

@@ -22,18 +22,20 @@
__API__ k_err_t tos_sem_create_max(k_sem_t *sem, k_sem_cnt_t init_count, k_sem_cnt_t max_count)
{
TOS_PTR_SANITY_CHECK(sem);
if (unlikely(init_count > max_count)) {
init_count = max_count;
}
sem->count = init_count;
sem->count_max = max_count;
pend_object_init(&sem->pend_obj);
TOS_OBJ_INIT(sem, KNL_OBJ_TYPE_SEMAPHORE);
#if TOS_CFG_OBJ_DYNAMIC_CREATE_EN > 0u
knl_object_alloc_set_static(&sem->knl_obj);
#endif
return K_ERR_NONE;
}
@@ -43,6 +45,39 @@ __API__ k_err_t tos_sem_create(k_sem_t *sem, k_sem_cnt_t init_count)
return tos_sem_create_max(sem, init_count, (k_sem_cnt_t)-1);
}
__API__ k_err_t tos_sem_destroy(k_sem_t *sem)
{
TOS_CPU_CPSR_ALLOC();
TOS_PTR_SANITY_CHECK(sem);
TOS_OBJ_VERIFY(sem, KNL_OBJ_TYPE_SEMAPHORE);
#if TOS_CFG_OBJ_DYNAMIC_CREATE_EN > 0u
if (!knl_object_alloc_is_static(&sem->knl_obj)) {
return K_ERR_OBJ_INVALID_ALLOC_TYPE;
}
#endif
TOS_CPU_INT_DISABLE();
pend_wakeup_all(&sem->pend_obj, PEND_STATE_DESTROY);
pend_object_deinit(&sem->pend_obj);
TOS_OBJ_DEINIT(sem);
#if TOS_CFG_OBJ_DYNAMIC_CREATE_EN > 0u
knl_object_alloc_reset(&sem->knl_obj);
#endif
TOS_CPU_INT_ENABLE();
knl_sched();
return K_ERR_NONE;
}
#if TOS_CFG_OBJ_DYNAMIC_CREATE_EN > 0u
__API__ k_err_t tos_sem_create_max_dyn(k_sem_t **sem, k_sem_cnt_t init_count, k_sem_cnt_t max_count)
{
k_sem_t *the_sem;
@@ -56,7 +91,7 @@ __API__ k_err_t tos_sem_create_max_dyn(k_sem_t **sem, k_sem_cnt_t init_count, k_
the_sem = tos_mmheap_calloc(1, sizeof(k_sem_t));
if (!the_sem) {
return K_ERR_SEM_OUT_OF_MEMORY;
return K_ERR_OUT_OF_MEMORY;
}
the_sem->count = init_count;
@@ -64,7 +99,7 @@ __API__ k_err_t tos_sem_create_max_dyn(k_sem_t **sem, k_sem_cnt_t init_count, k_
pend_object_init(&the_sem->pend_obj);
TOS_OBJ_INIT(the_sem, KNL_OBJ_TYPE_SEMAPHORE);
knl_object_alloc_set_dynamic(&the_sem->knl_obj);
*sem = the_sem;
@@ -77,25 +112,26 @@ __API__ k_err_t tos_sem_create_dyn(k_sem_t **sem, k_sem_cnt_t init_count)
return tos_sem_create_max_dyn(sem, init_count, (k_sem_cnt_t)-1);
}
__API__ k_err_t tos_sem_destroy(k_sem_t *sem)
__API__ k_err_t tos_sem_destroy_dyn(k_sem_t *sem)
{
TOS_CPU_CPSR_ALLOC();
TOS_PTR_SANITY_CHECK(sem);
TOS_OBJ_VERIFY(sem, KNL_OBJ_TYPE_SEMAPHORE);
if (!knl_object_alloc_is_dynamic(&sem->knl_obj)) {
return K_ERR_OBJ_INVALID_ALLOC_TYPE;
}
TOS_CPU_INT_DISABLE();
pend_wakeup_all(&sem->pend_obj, PEND_STATE_DESTROY);
pend_object_deinit(&sem->pend_obj);
if (knl_object_alloc_is_dynamic(&sem->knl_obj)) {
TOS_OBJ_DEINIT(sem);
tos_mmheap_free(sem);
} else {
TOS_OBJ_DEINIT(sem);
}
TOS_OBJ_DEINIT(sem);
tos_mmheap_free(sem);
TOS_CPU_INT_ENABLE();
knl_sched();
@@ -103,6 +139,8 @@ __API__ k_err_t tos_sem_destroy(k_sem_t *sem)
return K_ERR_NONE;
}
#endif
__STATIC__ k_err_t sem_do_post(k_sem_t *sem, opt_post_t opt)
{
TOS_CPU_CPSR_ALLOC();

24
kernel/core/tos_task.c
View File

@@ -19,7 +19,7 @@
__STATIC_INLINE__ void task_reset(k_task_t *task)
{
#if TOS_CFG_TASK_DYNAMIC_CREATE_EN > 0u
#if TOS_CFG_OBJ_DYNAMIC_CREATE_EN > 0u
knl_object_alloc_reset(&task->knl_obj);
tos_list_init(&task->dead_list);
@@ -115,7 +115,7 @@ __API__ k_err_t tos_task_create(k_task_t *task,
tos_list_add(&task->stat_list, &k_stat_list);
TOS_OBJ_INIT(task, KNL_OBJ_TYPE_TASK);
#if TOS_CFG_TASK_DYNAMIC_CREATE_EN > 0u
#if TOS_CFG_OBJ_DYNAMIC_CREATE_EN > 0u
knl_object_alloc_set_static(&task->knl_obj);
#endif
@@ -201,7 +201,7 @@ __API__ k_err_t tos_task_destroy(k_task_t *task)
return K_ERR_SCHED_LOCKED;
}
#if TOS_CFG_TASK_DYNAMIC_CREATE_EN > 0u
#if TOS_CFG_OBJ_DYNAMIC_CREATE_EN > 0u
if (!knl_object_alloc_is_static(&task->knl_obj)) {
return K_ERR_OBJ_INVALID_ALLOC_TYPE;
}
@@ -210,7 +210,7 @@ __API__ k_err_t tos_task_destroy(k_task_t *task)
return task_do_destroy(task);
}
#if TOS_CFG_TASK_DYNAMIC_CREATE_EN > 0u
#if TOS_CFG_OBJ_DYNAMIC_CREATE_EN > 0u
__STATIC__ void task_free(k_task_t *task)
{
@@ -250,27 +250,15 @@ __API__ k_err_t tos_task_create_dyn(k_task_t **task,
TOS_PTR_SANITY_CHECK(task);
TOS_PTR_SANITY_CHECK(entry);
if (unlikely(stk_size < sizeof(cpu_context_t))) {
return K_ERR_TASK_STK_SIZE_INVALID;
}
if (unlikely(prio == K_TASK_PRIO_IDLE)) {
return K_ERR_TASK_PRIO_INVALID;
}
if (unlikely(prio > K_TASK_PRIO_IDLE)) {
return K_ERR_TASK_PRIO_INVALID;
}
the_task = tos_mmheap_calloc(1, sizeof(k_task_t));
if (!the_task) {
return K_ERR_TASK_OUT_OF_MEMORY;
return K_ERR_OUT_OF_MEMORY;
}
stk_base = tos_mmheap_alloc(stk_size);
if (!stk_base) {
tos_mmheap_free(the_task);
return K_ERR_TASK_OUT_OF_MEMORY;
return K_ERR_OUT_OF_MEMORY;
}
the_task->stk_base = stk_base;

74
kernel/core/tos_timer.c
View File

@@ -136,6 +136,10 @@ __API__ k_err_t tos_timer_create(k_timer_t *tmr,
TOS_OBJ_INIT(tmr, KNL_OBJ_TYPE_TIMER);
#if TOS_CFG_OBJ_DYNAMIC_CREATE_EN > 0u
knl_object_alloc_set_static(&tmr->knl_obj);
#endif
return K_ERR_NONE;
}
@@ -144,6 +148,12 @@ __API__ k_err_t tos_timer_destroy(k_timer_t *tmr)
TOS_PTR_SANITY_CHECK(tmr);
TOS_OBJ_VERIFY(tmr, KNL_OBJ_TYPE_TIMER);
#if TOS_CFG_OBJ_DYNAMIC_CREATE_EN > 0u
if (!knl_object_alloc_is_static(&tmr->knl_obj)) {
return K_ERR_OBJ_INVALID_ALLOC_TYPE;
}
#endif
if (tmr->state == TIMER_STATE_UNUSED) {
return K_ERR_TIMER_INACTIVE;
}
@@ -153,9 +163,73 @@ __API__ k_err_t tos_timer_destroy(k_timer_t *tmr)
}
timer_reset(tmr);
#if TOS_CFG_OBJ_DYNAMIC_CREATE_EN > 0u
knl_object_alloc_reset(&tmr->knl_obj);
#endif
return K_ERR_NONE;
}
#if TOS_CFG_OBJ_DYNAMIC_CREATE_EN > 0u
__API__ k_err_t tos_timer_create_dyn(k_timer_t **tmr,
k_tick_t delay,
k_tick_t period,
k_timer_callback_t callback,
void *cb_arg,
k_opt_t opt)
{
k_err_t err;
k_timer_t *the_timer;
TOS_PTR_SANITY_CHECK(tmr);
TOS_PTR_SANITY_CHECK(callback);
the_timer = tos_mmheap_calloc(1, sizeof(k_timer_t));
if (!the_timer) {
return K_ERR_OUT_OF_MEMORY;
}
err = tos_timer_create(the_timer, delay, period, callback, cb_arg, opt);
if (err != K_ERR_NONE) {
tos_mmheap_free(the_timer);
return err;
}
knl_object_alloc_set_dynamic(&the_timer->knl_obj);
*tmr = the_timer;
return K_ERR_NONE;
}
__API__ k_err_t tos_timer_destroy_dyn(k_timer_t *tmr)
{
TOS_PTR_SANITY_CHECK(tmr);
TOS_OBJ_VERIFY(tmr, KNL_OBJ_TYPE_TIMER);
if (!knl_object_alloc_is_dynamic(&tmr->knl_obj)) {
return K_ERR_OBJ_INVALID_ALLOC_TYPE;
}
if (tmr->state == TIMER_STATE_UNUSED) {
return K_ERR_TIMER_INACTIVE;
}
if (tmr->state == TIMER_STATE_RUNNING) {
timer_takeoff(tmr);
}
timer_reset(tmr);
tos_mmheap_free(tmr);
return K_ERR_NONE;
}
#endif
__API__ k_err_t tos_timer_start(k_timer_t *tmr)
{
TOS_PTR_SANITY_CHECK(tmr);