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

add tos_slist.h, rename tos.h to tos_k.h

Browse Source
This commit is contained in:
daishengdong
2020-01-03 17:25:38 +08:00
parent af07f199d9
commit c9556307df
268 changed files with 900 additions and 742 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
kernel/core/include/tos.h → kernel/core/include/tos_k.h
View File

@@ -15,8 +15,8 @@
* within TencentOS.
*---------------------------------------------------------------------------*/
#ifndef _TOS_H_
#define _TOS_H_
#ifndef _TOS_K_H_
#define _TOS_K_H_
#include <tos_compiler.h>
#include <tos_err.h>
@@ -32,6 +32,7 @@
#include <tos_fault.h>
#include <tos_klib.h>
#include <tos_list.h>
#include <tos_slist.h>
#include <tos_pend.h>
#include <tos_sys.h>
#include <tos_ring_queue.h>
@@ -59,5 +60,5 @@
#include <tos_tickless.h>
#include <tos_global.h>
#endif /* _TOS_H_ */
#endif /* _TOS_K_H_ */

44
kernel/core/include/tos_list.h
View File

@@ -29,8 +29,8 @@ typedef struct k_list_node_st {
#define TOS_LIST_DEFINE(list) \
k_list_t list = { &(list), &(list) }
#define TOS_LIST_ENTRY(list, type, field) \
TOS_CONTAINER_OF_FIELD(list, type, field)
#define TOS_LIST_ENTRY(node, type, field) \
TOS_CONTAINER_OF_FIELD(node, type, field)
#define TOS_LIST_FIRST_ENTRY(list, type, field) \
TOS_LIST_ENTRY((list)->next, type, field)
@@ -53,6 +53,28 @@ typedef struct k_list_node_st {
curr != (list); \
curr = next, next = curr->prev)
#define TOS_LIST_FOR_EACH_ENTRY(entry, type, field, list) \
for (entry = TOS_LIST_ENTRY((list)->next, type, field); \
&entry->field != (list); \
entry = TOS_LIST_ENTRY(entry->field.next, type, field))
#define TOS_LIST_FOR_EACH_ENTRY_REVERSE(entry, type, field, list) \
for (entry = TOS_LIST_ENTRY((list)->prev, type, field); \
&entry->field != (list); \
entry = TOS_LIST_ENTRY(entry->field.prev, type, field))
#define TOS_LIST_FOR_EACH_ENTRY_SAFE(entry, tmp, type, field, list) \
for (entry = TOS_LIST_ENTRY((list)->next, type, field), \
tmp = TOS_LIST_ENTRY(entry->field.next, type, field); \
&entry->field != (list); \
entry = tmp, tmp = TOS_LIST_ENTRY(entry->field.next, type, field))
#define TOS_LIST_FOR_EACH_ENTRY_SAFE_REVERSE(entry, tmp, type, field, list) \
for (entry = TOS_LIST_ENTRY((list)->prev, type, field), \
tmp = TOS_LIST_ENTRY(entry->field.prev, type, field); \
&entry->field != (list); \
entry = tmp, tmp = TOS_LIST_ENTRY(entry->field.prev, type, field))
__STATIC_INLINE__ void _list_add(k_list_t *node, k_list_t *prev, k_list_t *next)
{
next->prev = node;
@@ -67,9 +89,9 @@ __STATIC_INLINE__ void _list_del(k_list_t *prev, k_list_t *next)
prev->next = next;
}
__STATIC_INLINE__ void _list_del_entry(k_list_t *entry)
__STATIC_INLINE__ void _list_del_node(k_list_t *node)
{
_list_del(entry->prev, entry->next);
_list_del(node->prev, node->next);
}
__API__ __STATIC_INLINE__ void tos_list_init(k_list_t *list)
@@ -88,26 +110,26 @@ __API__ __STATIC_INLINE__ void tos_list_add_tail(k_list_t *node, k_list_t *list)
_list_add(node, list->prev, list);
}
__API__ __STATIC_INLINE__ void tos_list_del(k_list_t *entry)
__API__ __STATIC_INLINE__ void tos_list_del(k_list_t *node)
{
_list_del(entry->prev, entry->next);
_list_del(node->prev, node->next);
}
__API__ __STATIC_INLINE__ void tos_list_del_init(k_list_t *entry)
__API__ __STATIC_INLINE__ void tos_list_del_init(k_list_t *node)
{
_list_del_entry(entry);
tos_list_init(entry);
_list_del_node(node);
tos_list_init(node);
}
__API__ __STATIC_INLINE__ void tos_list_move(k_list_t *node, k_list_t *list)
{
_list_del_entry(node);
_list_del_node(node);
tos_list_add(node, list);
}
__API__ __STATIC_INLINE__ void tos_list_move_tail(k_list_t *node, k_list_t *list)
{
_list_del_entry(node);
_list_del_node(node);
tos_list_add_tail(node, list);
}

156
kernel/core/include/tos_slist.h Normal file
View File

@@ -0,0 +1,156 @@
#ifndef _TOS_SLIST_H_
#define _TOS_SLIST_H_
typedef struct k_slist_node_st {
struct k_slist_node_st *next;
} k_slist_t;
#define TOS_SLIST_NODE(node) \
{ K_NULL }
#define TOS_SLIST_DEFINE(slist) \
k_slist_t slist = { K_NULL }
#define TOS_SLIST_ENTRY(node, type, field) \
TOS_CONTAINER_OF_FIELD(node, type, field)
#define TOS_SLIST_FIRST_ENTRY(slist, type, field) \
TOS_SLIST_ENTRY((slist)->next, type, field)
#define TOS_SLIST_FIRST_ENTRY_OR_NULL(slist, type, field) \
(tos_slist_empty(slist) ? K_NULL : TOS_SLIST_FIRST_ENTRY(slist, type, field))
#define TOS_SLIST_FOR_EACH(curr, slist) \
for (curr = (slist)->next; curr; curr = curr->next)
#define TOS_SLIST_FOR_EACH_SAFE(curr, next, slist) \
for (curr = (slist)->next, next = curr->next; curr; \
curr = next, next = curr->next)
#define TOS_SLIST_FOR_EACH_ENTRY(entry, type, field, slist) \
for (entry = TOS_SLIST_ENTRY((slist)->next, type, field); \
&entry->field; \
entry = TOS_SLIST_ENTRY(entry->field.next, type, field))
#define TOS_SLIST_FOR_EACH_ENTRY_SAFE(entry, tmp, type, field, slist) \
for (entry = TOS_SLIST_ENTRY((slist)->next, type, field), \
tmp = TOS_SLIST_ENTRY(entry->field.next, type, field); \
&entry->field; \
entry = tmp, tmp = TOS_SLIST_ENTRY(entry->field.next, type, field))
__API__ __STATIC_INLINE__ void tos_slist_init(k_slist_t *slist)
{
slist->next = K_NULL;
}
__API__ __STATIC_INLINE__ k_slist_t *tos_slist_head(k_slist_t *slist)
{
return slist->next;
}
__API__ __STATIC_INLINE__ k_slist_t *tos_slist_tail(k_slist_t *slist)
{
if (!slist->next) {
return K_NULL;
}
while (slist->next) {
slist = slist->next;
}
return slist;
}
__API__ __STATIC_INLINE__ void tos_slist_add_head(k_slist_t *node, k_slist_t *slist)
{
node->next = slist->next;
slist->next = node;
}
__API__ __STATIC_INLINE__ void tos_slist_add_tail(k_slist_t *node, k_slist_t *slist)
{
node->next = K_NULL;
while (slist->next) {
slist = slist->next;
}
tos_slist_add_head(node, slist);
}
__API__ __STATIC_INLINE__ void tos_slist_insert(k_slist_t *next_node, k_slist_t *new_node, k_slist_t *slist)
{
if (!next_node) {
tos_slist_add_tail(new_node, slist);
return;
}
while (slist->next) {
if (slist->next == next_node) {
slist->next = new_node;
new_node->next = next_node;
}
slist = slist->next;
}
}
__API__ __STATIC_INLINE__ k_slist_t *tos_slist_del_head(k_slist_t *slist)
{
k_slist_t *head;
if (!slist->next) {
return K_NULL;
}
head = slist->next;
slist->next = head->next;
head->next = K_NULL;
return head;
}
__API__ __STATIC_INLINE__ k_slist_t *tos_slist_del_tail(k_slist_t *slist)
{
while (slist->next) {
if (!slist->next->next) {
return tos_slist_del_head(slist);
}
slist = slist->next;
}
return K_NULL;
}
__API__ __STATIC_INLINE__ void tos_slist_del(k_slist_t *node, k_slist_t *slist)
{
while (slist->next) {
if (slist->next == node) {
slist->next = node->next;
break;
}
slist = slist->next;
}
}
__API__ __STATIC_INLINE__ int tos_slist_length(k_slist_t *slist)
{
int len = 0;
k_slist_t *iter;
TOS_SLIST_FOR_EACH(iter, slist) {
++len;
}
return len;
}
__API__ __STATIC_INLINE__ int tos_slist_empty(k_slist_t *slist)
{
return !slist->next;
}
#endif /* _TOS_SLIST_H_ */

2
kernel/core/tos_binary_heap.c
View File

@@ -15,7 +15,7 @@
* within TencentOS.
*---------------------------------------------------------------------------*/
#include "tos.h"
#include "tos_k.h"
__STATIC_INLINE__ void bin_heap_item_copy_to(k_bin_heap_t *bin_heap, void *item_out, size_t *item_size)
{

2
kernel/core/tos_char_fifo.c
View File

@@ -15,7 +15,7 @@
* within TencentOS.
*---------------------------------------------------------------------------*/
#include "tos.h"
#include "tos_k.h"
__API__ k_err_t tos_chr_fifo_create(k_chr_fifo_t *chr_fifo, void *buffer, size_t size)
{

2
kernel/core/tos_completion.c
View File

@@ -15,7 +15,7 @@
* within TencentOS.
*---------------------------------------------------------------------------*/
#include "tos.h"
#include "tos_k.h"
#if TOS_CFG_COMPLETION_EN > 0u

2
kernel/core/tos_countdownlatch.c
View File

@@ -15,7 +15,7 @@
* within TencentOS.
*---------------------------------------------------------------------------*/
#include "tos.h"
#include "tos_k.h"
#if TOS_CFG_COUNTDOWNLATCH_EN > 0u

11
kernel/core/tos_event.c
View File

@@ -15,7 +15,7 @@
* within TencentOS.
*---------------------------------------------------------------------------*/
#include "tos.h"
#include "tos_k.h"
#if TOS_CFG_EVENT_EN > 0
@@ -134,8 +134,7 @@ __API__ k_err_t tos_event_pend(k_event_t *event, k_event_flag_t flag_expect, k_e
__STATIC__ k_err_t event_do_post(k_event_t *event, k_event_flag_t flag, opt_event_post_t opt_post)
{
TOS_CPU_CPSR_ALLOC();
k_task_t *task;
k_list_t *curr, *next;
k_task_t *task, *tmp;
TOS_PTR_SANITY_CHECK(event);
TOS_OBJ_VERIFY(event, KNL_OBJ_TYPE_EVENT);
@@ -148,11 +147,9 @@ __STATIC__ k_err_t event_do_post(k_event_t *event, k_event_flag_t flag, opt_even
TOS_CPU_INT_DISABLE();
TOS_LIST_FOR_EACH_SAFE(curr, next, &event->pend_obj.list) {
task = TOS_LIST_ENTRY(curr, k_task_t, pend_list);
TOS_LIST_FOR_EACH_ENTRY_SAFE(task, tmp, k_task_t, pend_list, &event->pend_obj.list) {
if (event_is_match(event->flag, task->flag_expect, task->flag_match, task->opt_event_pend)) {
pend_task_wakeup(TOS_LIST_ENTRY(curr, k_task_t, pend_list), PEND_STATE_POST);
pend_task_wakeup(task, PEND_STATE_POST);
// if anyone pending the event has set the TOS_OPT_EVENT_PEND_CLR, then no wakeup for the others pendig for the event.
if (task->opt_event_pend & TOS_OPT_EVENT_PEND_CLR) {

2
kernel/core/tos_global.c
View File

@@ -15,7 +15,7 @@
* within TencentOS.
*---------------------------------------------------------------------------*/
#include <tos.h>
#include <tos_k.h>
k_nesting_t k_irq_nest_cnt = (k_nesting_t)0;
k_nesting_t k_sched_lock_nest_cnt = (k_nesting_t)0;

9
kernel/core/tos_mail_queue.c
View File

@@ -15,7 +15,7 @@
* within TencentOS.
*---------------------------------------------------------------------------*/
#include "tos.h"
#include "tos_k.h"
#if TOS_CFG_MAIL_QUEUE_EN > 0u
@@ -207,7 +207,7 @@ __STATIC__ k_err_t mail_q_do_post(k_mail_q_t *mail_q, void *mail_buf, size_t mai
{
TOS_CPU_CPSR_ALLOC();
k_err_t err;
k_list_t *curr, *next;
k_task_t *task, *tmp;
TOS_PTR_SANITY_CHECK(mail_q);
TOS_PTR_SANITY_CHECK(mail_buf);
@@ -229,9 +229,8 @@ __STATIC__ k_err_t mail_q_do_post(k_mail_q_t *mail_q, void *mail_buf, size_t mai
mail_task_recv(TOS_LIST_FIRST_ENTRY(&mail_q->pend_obj.list, k_task_t, pend_list),
mail_buf, mail_size);
} else { // OPT_POST_ALL
TOS_LIST_FOR_EACH_SAFE(curr, next, &mail_q->pend_obj.list) {
mail_task_recv(TOS_LIST_ENTRY(curr, k_task_t, pend_list),
mail_buf, mail_size);
TOS_LIST_FOR_EACH_ENTRY_SAFE(task, tmp, k_task_t, pend_list, &mail_q->pend_obj.list) {
mail_task_recv(task, mail_buf, mail_size);
}
}

8
kernel/core/tos_message_queue.c
View File

@@ -15,7 +15,7 @@
* within TencentOS.
*---------------------------------------------------------------------------*/
#include "tos.h"
#include "tos_k.h"
#if TOS_CFG_MESSAGE_QUEUE_EN > 0u
@@ -205,7 +205,7 @@ __STATIC__ k_err_t msg_q_do_post(k_msg_q_t *msg_q, void *msg_ptr, opt_post_t opt
{
TOS_CPU_CPSR_ALLOC();
k_err_t err;
k_list_t *curr, *next;
k_task_t *task, *tmp;
TOS_PTR_SANITY_CHECK(msg_q);
TOS_OBJ_VERIFY(msg_q, KNL_OBJ_TYPE_MESSAGE_QUEUE);
@@ -225,8 +225,8 @@ __STATIC__ k_err_t msg_q_do_post(k_msg_q_t *msg_q, void *msg_ptr, opt_post_t opt
if (opt == OPT_POST_ONE) {
msg_q_task_recv(TOS_LIST_FIRST_ENTRY(&msg_q->pend_obj.list, k_task_t, pend_list), msg_ptr);
} else { // OPT_POST_ALL
TOS_LIST_FOR_EACH_SAFE(curr, next, &msg_q->pend_obj.list) {
msg_q_task_recv(TOS_LIST_ENTRY(curr, k_task_t, pend_list), msg_ptr);
TOS_LIST_FOR_EACH_ENTRY_SAFE(task, tmp, k_task_t, pend_list, &msg_q->pend_obj.list) {
msg_q_task_recv(task, msg_ptr);
}
}

2
kernel/core/tos_mmblk.c
View File

@@ -15,7 +15,7 @@
* within TencentOS.
*---------------------------------------------------------------------------*/
#include <tos.h>
#include "tos_k.h"
#if TOS_CFG_MMBLK_EN > 0u

2
kernel/core/tos_mmheap.c
View File

@@ -52,7 +52,7 @@
** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <tos.h>
#include "tos_k.h"
#if TOS_CFG_MMHEAP_EN > 0u

2
kernel/core/tos_mutex.c
View File

@@ -15,7 +15,7 @@
* within TencentOS.
*---------------------------------------------------------------------------*/
#include "tos.h"
#include "tos_k.h"
#if TOS_CFG_MUTEX_EN > 0u

15
kernel/core/tos_pend.c
View File

@@ -15,24 +15,21 @@
* within TencentOS.
*---------------------------------------------------------------------------*/
#include "tos.h"
#include "tos_k.h"
__STATIC__ void pend_list_add(k_task_t *task, pend_obj_t *pend_obj)
{
k_list_t *curr, *pend_list;
k_task_t *iter;
pend_list = &pend_obj->list;
/* keep priority in descending order, the boss(task with highest priority,
numerically smallest) always comes first
*/
TOS_LIST_FOR_EACH(curr, pend_list) {
iter = TOS_LIST_ENTRY(curr, k_task_t, pend_list);
TOS_LIST_FOR_EACH_ENTRY(iter, k_task_t, pend_list, &pend_obj->list) {
if (task->prio < iter->prio) {
break;
}
}
tos_list_add_tail(&task->pend_list, curr);
tos_list_add_tail(&task->pend_list, &iter->pend_list);
// remember me, you may use me someday
task->pending_obj = pend_obj;
@@ -137,10 +134,10 @@ __KERNEL__ void pend_wakeup_one(pend_obj_t *object, pend_state_t state)
__KERNEL__ void pend_wakeup_all(pend_obj_t *object, pend_state_t state)
{
k_list_t *curr, *next;
k_task_t *task, *tmp;
TOS_LIST_FOR_EACH_SAFE(curr, next, &object->list) {
pend_task_wakeup(TOS_LIST_ENTRY(curr, k_task_t, pend_list), state);
TOS_LIST_FOR_EACH_ENTRY_SAFE(task, tmp, k_task_t, pend_list, &object->list) {
pend_task_wakeup(task, state);
}
}

9
kernel/core/tos_priority_mail_queue.c
View File

@@ -15,7 +15,7 @@
* within TencentOS.
*---------------------------------------------------------------------------*/
#include "tos.h"
#include "tos_k.h"
#if TOS_CFG_PRIORITY_MAIL_QUEUE_EN > 0u
@@ -208,7 +208,7 @@ __STATIC__ k_err_t prio_mail_q_do_post(k_prio_mail_q_t *prio_mail_q, void *mail_
{
TOS_CPU_CPSR_ALLOC();
k_err_t err;
k_list_t *curr, *next;
k_task_t *task, *tmp;
TOS_PTR_SANITY_CHECK(prio_mail_q);
TOS_PTR_SANITY_CHECK(mail_buf);
@@ -230,9 +230,8 @@ __STATIC__ k_err_t prio_mail_q_do_post(k_prio_mail_q_t *prio_mail_q, void *mail_
prio_mail_task_recv(TOS_LIST_FIRST_ENTRY(&prio_mail_q->pend_obj.list, k_task_t, pend_list),
mail_buf, mail_size);
} else { // OPT_POST_ALL
TOS_LIST_FOR_EACH_SAFE(curr, next, &prio_mail_q->pend_obj.list) {
prio_mail_task_recv(TOS_LIST_ENTRY(curr, k_task_t, pend_list),
mail_buf, mail_size);
TOS_LIST_FOR_EACH_ENTRY_SAFE(task, tmp, k_task_t, pend_list, &prio_mail_q->pend_obj.list) {
prio_mail_task_recv(task, mail_buf, mail_size);
}
}

8
kernel/core/tos_priority_message_queue.c
View File

@@ -15,7 +15,7 @@
* within TencentOS.
*---------------------------------------------------------------------------*/
#include "tos.h"
#include "tos_k.h"
#if TOS_CFG_PRIORITY_MESSAGE_QUEUE_EN > 0u
@@ -208,7 +208,7 @@ __STATIC__ k_err_t prio_msg_q_do_post(k_prio_msg_q_t *prio_msg_q, void *msg_ptr,
{
TOS_CPU_CPSR_ALLOC();
k_err_t err;
k_list_t *curr, *next;
k_task_t *task, *tmp;
TOS_PTR_SANITY_CHECK(prio_msg_q);
TOS_OBJ_VERIFY(prio_msg_q, KNL_OBJ_TYPE_PRIORITY_MESSAGE_QUEUE);
@@ -228,8 +228,8 @@ __STATIC__ k_err_t prio_msg_q_do_post(k_prio_msg_q_t *prio_msg_q, void *msg_ptr,
if (opt == OPT_POST_ONE) {
prio_msg_q_task_recv(TOS_LIST_FIRST_ENTRY(&prio_msg_q->pend_obj.list, k_task_t, pend_list), msg_ptr);
} else { // OPT_POST_ALL
TOS_LIST_FOR_EACH_SAFE(curr, next, &prio_msg_q->pend_obj.list) {
prio_msg_q_task_recv(TOS_LIST_ENTRY(curr, k_task_t, pend_list), msg_ptr);
TOS_LIST_FOR_EACH_ENTRY_SAFE(task, tmp, k_task_t, pend_list, &prio_msg_q->pend_obj.list) {
prio_msg_q_task_recv(task, msg_ptr);
}
}

2
kernel/core/tos_priority_queue.c
View File

@@ -15,7 +15,7 @@
* within TencentOS.
*---------------------------------------------------------------------------*/
#include "tos.h"
#include "tos_k.h"
__STATIC_INLINE__ void prio_q_item_copy_to(k_prio_q_t *prio_q, void *item_out, size_t *item_size, prio_q_slot_t slot)
{

2
kernel/core/tos_ring_queue.c
View File

@@ -15,7 +15,7 @@
* within TencentOS.
*---------------------------------------------------------------------------*/
#include "tos.h"
#include "tos_k.h"
__STATIC_INLINE__ void ring_q_item_copy_to(k_ring_q_t *ring_q, void *item_out, size_t *item_size)
{

2
kernel/core/tos_robin.c
View File

@@ -15,7 +15,7 @@
* within TencentOS.
*---------------------------------------------------------------------------*/
#include "tos.h"
#include "tos_k.h"
#if TOS_CFG_ROUND_ROBIN_EN > 0u

2
kernel/core/tos_sched.c
View File

@@ -15,7 +15,7 @@
* within TencentOS.
*---------------------------------------------------------------------------*/
#include <tos.h>
#include "tos_k.h"
__STATIC__ k_prio_t readyqueue_prio_highest_get(void)
{

2
kernel/core/tos_sem.c
View File

@@ -15,7 +15,7 @@
* within TencentOS.
*---------------------------------------------------------------------------*/
#include "tos.h"
#include "tos_k.h"
#if TOS_CFG_SEM_EN > 0u

2
kernel/core/tos_sys.c
View File

@@ -15,7 +15,7 @@
* within TencentOS.
*---------------------------------------------------------------------------*/
#include <tos.h>
#include "tos_k.h"
__API__ k_err_t tos_knl_init(void)
{

25
kernel/core/tos_task.c
View File

@@ -15,7 +15,7 @@
* within TencentOS.
*---------------------------------------------------------------------------*/
#include <tos.h>
#include "tos_k.h"
__STATIC_INLINE__ void task_reset(k_task_t *task)
{
@@ -59,26 +59,25 @@ __STATIC__ void task_exit(void)
#if TOS_CFG_MUTEX_EN > 0u
__STATIC__ k_prio_t task_highest_pending_prio_get(k_task_t *task)
{
k_list_t *curr;
k_mutex_t *mutex;
k_prio_t prio, highest_prio_pending = K_TASK_PRIO_INVALID;
TOS_LIST_FOR_EACH(curr, &task->mutex_own_list) {
mutex = TOS_LIST_ENTRY(curr, k_mutex_t, owner_anchor);
prio = pend_highest_pending_prio_get(&mutex->pend_obj);
TOS_LIST_FOR_EACH_ENTRY(mutex, k_mutex_t, owner_anchor, &task->mutex_own_list) {
prio = pend_highest_pending_prio_get(&mutex->pend_obj);
if (prio < highest_prio_pending) {
highest_prio_pending = prio;
}
}
return highest_prio_pending;
}
__STATIC__ void task_mutex_release(k_task_t *task)
{
k_list_t *curr, *next;
k_mutex_t *mutex, *tmp;
TOS_LIST_FOR_EACH_SAFE(curr, next, &task->mutex_own_list) {
mutex_release(TOS_LIST_ENTRY(curr, k_mutex_t, owner_anchor));
TOS_LIST_FOR_EACH_ENTRY_SAFE(mutex, tmp, k_mutex_t, owner_anchor, &task->mutex_own_list) {
mutex_release(mutex);
}
}
#endif
@@ -225,13 +224,11 @@ __STATIC__ void task_free(k_task_t *task)
__KERNEL__ void task_free_all(void)
{
TOS_CPU_CPSR_ALLOC();
k_task_t *task;
k_list_t *curr, *next;
k_task_t *task, *tmp;
TOS_CPU_INT_DISABLE();
TOS_LIST_FOR_EACH_SAFE(curr, next, &k_dead_task_list) {
task = TOS_LIST_ENTRY(curr, k_task_t, dead_list);
TOS_LIST_FOR_EACH_ENTRY_SAFE(task, tmp, k_task_t, dead_list, &k_dead_task_list) {
tos_list_del(&task->dead_list);
task_free(task);
}
@@ -551,7 +548,6 @@ __API__ void tos_task_walkthru(k_task_walker_t walker)
{
TOS_CPU_CPSR_ALLOC();
k_task_t *task;
k_list_t *curr;
if (!walker) {
return;
@@ -559,8 +555,7 @@ __API__ void tos_task_walkthru(k_task_walker_t walker)
TOS_CPU_INT_DISABLE();
TOS_LIST_FOR_EACH(curr, &k_stat_list) {
task = TOS_LIST_ENTRY(curr, k_task_t, stat_list);
TOS_LIST_FOR_EACH_ENTRY(task, k_task_t, stat_list, &k_stat_list) {
walker(task);
}

16
kernel/core/tos_tick.c
View File

@@ -15,12 +15,11 @@
* within TencentOS.
*---------------------------------------------------------------------------*/
#include <tos.h>
#include "tos_k.h"
__STATIC__ void tick_task_place(k_task_t *task, k_tick_t timeout)
{
TOS_CPU_CPSR_ALLOC();
k_list_t *curr;
k_task_t *curr_task = K_NULL;
k_tick_t curr_expires, prev_expires = (k_tick_t)0u;
@@ -28,8 +27,7 @@ __STATIC__ void tick_task_place(k_task_t *task, k_tick_t timeout)
task->tick_expires = timeout;
TOS_LIST_FOR_EACH(curr, &k_tick_list) {
curr_task = TOS_LIST_ENTRY(curr, k_task_t, tick_list);
TOS_LIST_FOR_EACH_ENTRY(curr_task, k_task_t, tick_list, &k_tick_list) {
curr_expires = prev_expires + curr_task->tick_expires;
if (task->tick_expires < curr_expires) {
@@ -42,10 +40,10 @@ __STATIC__ void tick_task_place(k_task_t *task, k_tick_t timeout)
prev_expires = curr_expires;
}
task->tick_expires -= prev_expires;
if (curr != &k_tick_list && curr_task) {
if (&curr_task->tick_list != &k_tick_list) {
curr_task->tick_expires -= task->tick_expires;
}
tos_list_add_tail(&task->tick_list, curr);
tos_list_add_tail(&task->tick_list, &curr_task->tick_list);
TOS_CPU_INT_ENABLE();
}
@@ -86,8 +84,7 @@ __KERNEL__ void tick_list_remove(k_task_t *task)
__KERNEL__ void tick_update(k_tick_t tick)
{
TOS_CPU_CPSR_ALLOC();
k_task_t *first, *task;
k_list_t *curr, *next;
k_task_t *first, *task, *tmp;
TOS_CPU_INT_DISABLE();
k_tick_count += tick;
@@ -106,8 +103,7 @@ __KERNEL__ void tick_update(k_tick_t tick)
return;
}
TOS_LIST_FOR_EACH_SAFE(curr, next, &k_tick_list) {
task = TOS_LIST_ENTRY(curr, k_task_t, tick_list);
TOS_LIST_FOR_EACH_ENTRY_SAFE(task, tmp, k_task_t, tick_list, &k_tick_list) {
if (task->tick_expires > (k_tick_t)0u) {
break;
}

2
kernel/core/tos_time.c
View File

@@ -15,7 +15,7 @@
* within TencentOS.
*---------------------------------------------------------------------------*/
#include <tos.h>
#include "tos_k.h"
__API__ k_tick_t tos_systick_get(void)
{

20
kernel/core/tos_timer.c
View File

@@ -15,27 +15,25 @@
* within TencentOS.
*---------------------------------------------------------------------------*/
#include <tos.h>
#include "tos_k.h"
#if TOS_CFG_TIMER_EN > 0u
__STATIC__ void timer_place(k_timer_t *tmr)
{
TOS_CPU_CPSR_ALLOC();
k_list_t *curr;
k_timer_t *iter = K_NULL;
TOS_CPU_INT_DISABLE();
tmr->expires += k_tick_count;
TOS_LIST_FOR_EACH(curr, &k_timer_ctl.list) {
iter = TOS_LIST_ENTRY(curr, k_timer_t, list);
TOS_LIST_FOR_EACH_ENTRY(iter, k_timer_t, list, &k_timer_ctl.list) {
if (tmr->expires < iter->expires) {
break;
}
}
tos_list_add_tail(&tmr->list, curr);
tos_list_add_tail(&tmr->list, &iter->list);
if (k_timer_ctl.list.next == &tmr->list) {
// we are the first guy now
@@ -281,8 +279,7 @@ __KERNEL__ k_tick_t timer_next_expires_get(void)
__KERNEL__ void timer_update(void)
{
k_timer_t *tmr;
k_list_t *curr, *next;
k_timer_t *tmr, *tmp;
if (k_timer_ctl.next_expires < k_tick_count) {
return;
@@ -290,8 +287,7 @@ __KERNEL__ void timer_update(void)
tos_knl_sched_lock();
TOS_LIST_FOR_EACH_SAFE(curr, next, &k_timer_ctl.list) {
tmr = TOS_LIST_ENTRY(curr, k_timer_t, list);
TOS_LIST_FOR_EACH_ENTRY_SAFE(tmr, tmp, k_timer_t, list, &k_timer_ctl.list) {
if (tmr->expires > k_tick_count) {
break;
}
@@ -316,8 +312,7 @@ __KERNEL__ void timer_update(void)
__STATIC__ void timer_task_entry(void *arg)
{
k_timer_t *tmr;
k_list_t *curr, *next;
k_timer_t *tmr, *tmp;
k_tick_t next_expires;
arg = arg; // make compiler happy
@@ -331,8 +326,7 @@ __STATIC__ void timer_task_entry(void *arg)
tos_knl_sched_lock();
TOS_LIST_FOR_EACH_SAFE(curr, next, &k_timer_ctl.list) {
tmr = TOS_LIST_ENTRY(curr, k_timer_t, list);
TOS_LIST_FOR_EACH_ENTRY_SAFE(tmr, tmp, k_timer_t, list, &k_timer_ctl.list) {
if (tmr->expires > k_tick_count) { // not yet
break;
}