Inter-Thread Communication

Inter-Thread Communication 的协作图:

专题
	Semaphore
	Mutex
	Event
	Mailbox
	Messagequeue

结构体
struct	rt_ipc_object

宏定义
#define	RT_IPC_FLAG_FIFO   0x00
#define	RT_IPC_FLAG_PRIO   0x01
#define	RT_IPC_CMD_UNKNOWN   0x00
#define	RT_IPC_CMD_RESET   0x01
#define	RT_IPC_CMD_GET_STATE   0x02
#define	RT_IPC_CMD_SET_VLIMIT   0x03
#define	RT_WAITING_FOREVER   -1
#define	RT_WAITING_NO   0
#define	RT_THREAD_RESUME_RES_THR_ERR   (-1)

函数
rt_inline rt_err_t	_ipc_object_init (struct rt_ipc_object *ipc)
struct rt_thread *	rt_susp_list_dequeue (rt_list_t *susp_list, rt_err_t thread_error)
rt_err_t	rt_susp_list_resume_all (rt_list_t *susp_list, rt_err_t thread_error)
rt_err_t	rt_susp_list_resume_all_irq (rt_list_t *susp_list, rt_err_t thread_error, struct rt_spinlock *lock)
rt_err_t	rt_susp_list_enqueue (rt_list_t *susp_list, rt_thread_t thread, int ipc_flags)
void	rt_susp_list_print (rt_list_t *list)
rt_inline rt_uint8_t	_mutex_update_priority (struct rt_mutex *mutex)
rt_inline rt_uint8_t	_thread_get_mutex_priority (struct rt_thread *thread)
rt_inline void	_thread_update_priority (struct rt_thread *thread, rt_uint8_t priority, int suspend_flag)
rt_err_t	rt_thread_suspend_to_list (rt_thread_t thread, rt_list_t *susp_list, int ipc_flags, int suspend_flag)
void	rt_thread_defunct_init (void)
void	rt_thread_defunct_enqueue (rt_thread_t thread)
rt_thread_t	rt_thread_defunct_dequeue (void)
void	rt_defunct_execute (void)
void	rt_spin_lock_init (struct rt_spinlock *lock)
void	rt_spin_lock (struct rt_spinlock *lock)
void	rt_spin_unlock (struct rt_spinlock *lock)
rt_base_t	rt_spin_lock_irqsave (struct rt_spinlock *lock)
void	rt_spin_unlock_irqrestore (struct rt_spinlock *lock, rt_base_t level)

详细描述

inter-thread communication

RT-Thread operating system supports the traditional semaphore and mutex.

• Mutex objects use inherited priority to prevent priority reversion.
• The semaphore release action is safe for interrupt service routine.

Moreover, the blocked queue for thread to obtain semaphore or mutex can be sorted by priority or FIFO. There are two flags to indicate this mechanism.

• RT_IPC_FLAG_FIFO when the resource is available, thread pended on this resource at first would get the resource.
• RT_IPC_FLAG_PRIO when the resource is available, thread pended on this resource who had the most high priority would get the resource.

RT-Thread operating systems supports event/fast event, mail box and message queue.

• The event mechanism is used to awake a thread by setting one or more corresponding bit of a binary number when an event ocurs.
• The fast event supports event thread queue. Once a one bit event occurs, the corresponding blocked thread can be found out timing accurately, then will be waked up.
• In mailbox, the mail length is fixed to 4 byte, which is more effective than message queue.
• The send action for communication facilities is also safe for interrupt service routine.

宏定义说明

RT_IPC_FLAG_FIFO

#define RT_IPC_FLAG_FIFO   0x00

IPC flags and control command definitions FIFOed IPC. Inter-Thread Communication.

在文件 rtdef.h 第 972 行定义.

RT_IPC_FLAG_PRIO

#define RT_IPC_FLAG_PRIO   0x01

PRIOed IPC. Inter-Thread Communication.

在文件 rtdef.h 第 973 行定义.

RT_IPC_CMD_UNKNOWN

#define RT_IPC_CMD_UNKNOWN   0x00

unknown IPC command

在文件 rtdef.h 第 975 行定义.

RT_IPC_CMD_RESET

#define RT_IPC_CMD_RESET   0x01

reset IPC object

在文件 rtdef.h 第 976 行定义.

RT_IPC_CMD_GET_STATE

#define RT_IPC_CMD_GET_STATE   0x02

get the state of IPC object

在文件 rtdef.h 第 977 行定义.

RT_IPC_CMD_SET_VLIMIT

#define RT_IPC_CMD_SET_VLIMIT   0x03

set max limit value of IPC value

在文件 rtdef.h 第 978 行定义.

RT_WAITING_FOREVER

#define RT_WAITING_FOREVER   -1

Block forever until get resource.

在文件 rtdef.h 第 980 行定义.

RT_WAITING_NO

#define RT_WAITING_NO   0

Non-block.

在文件 rtdef.h 第 981 行定义.

RT_THREAD_RESUME_RES_THR_ERR

#define RT_THREAD_RESUME_RES_THR_ERR   (-1)

在文件 rtthread.h 第 401 行定义.

函数说明

_ipc_object_init()

rt_inline rt_err_t _ipc_object_init

(

struct rt_ipc_object *

ipc

)

This function will initialize an IPC object, such as semaphore, mutex, messagequeue and mailbox.

注解

Executing this function will complete an initialization of the suspend thread list of the ipc object.

参数

ipc	is a pointer to the IPC object.

返回

Return the operation status. When the return value is RT_EOK, the initialization is successful. When the return value is any other values, it means the initialization failed.

警告

This function can be called from all IPC initialization and creation.

在文件 ipc.c 第 82 行定义.

{
    /* initialize ipc object */
    rt_list_init(&(ipc->suspend_thread));
 
    return RT_EOK;
}

引用了 rt_list_init() , 以及 rt_ipc_object::suspend_thread.

函数调用图:

这是这个函数的调用关系图:

rt_susp_list_dequeue()

struct rt_thread * rt_susp_list_dequeue	(	rt_list_t *	susp_list,
		rt_err_t	thread_error )

Dequeue a thread from suspended list and set it to ready. The 2 are taken as an atomic operation, so if a thread is returned, it's resumed by us, not any other threads or async events. This is useful if a consumer may be resumed by timeout, signals... besides its producer.

参数

susp_list	the list thread dequeued from. RT_NULL if no list.
thread_error	thread error number of the resuming thread. A negative value in this set will be discarded, and thread error will not be changed.

返回

struct rt_thread * RT_NULL if failed, otherwise the thread resumed

在文件 ipc.c 第 105 行定义.

{
    rt_sched_lock_level_t slvl;
    rt_thread_t thread;
    rt_err_t error;
 
    RT_SCHED_DEBUG_IS_UNLOCKED;
    RT_ASSERT(susp_list != RT_NULL);
 
    rt_sched_lock(&slvl);
    if (!rt_list_isempty(susp_list))
    {
        thread = RT_THREAD_LIST_NODE_ENTRY(susp_list->next);
        error = rt_sched_thread_ready(thread);
 
        if (error)
        {
            LOG_D("%s [error:%d] failed to resume thread:%p from suspended list",
                  __func__, error, thread);
 
            thread = RT_NULL;
        }
        else
        {
            /* thread error should not be a negative value */
            if (thread_error >= 0)
            {
                /* set thread error code to notified resuming thread */
                thread->error = thread_error;
            }
        }
    }
    else
    {
        thread = RT_NULL;
    }
    rt_sched_unlock(slvl);
 
    LOG_D("resume thread:%s\n", thread->parent.name);
 
    return thread;
}

引用了 rt_thread::error, LOG_D, rt_object::name, rt_list_node::next, rt_thread::parent, RT_ASSERT, rt_list_isempty(), RT_NULL, RT_SCHED_DEBUG_IS_UNLOCKED, rt_sched_lock(), rt_sched_thread_ready(), rt_sched_unlock() , 以及 RT_THREAD_LIST_NODE_ENTRY.

函数调用图:

这是这个函数的调用关系图:

rt_susp_list_resume_all()

rt_err_t rt_susp_list_resume_all	(	rt_list_t *	susp_list,
		rt_err_t	thread_error )

This function will resume all suspended threads in the IPC object list, including the suspended list of IPC object, and private list of mailbox etc.

注解

This function will resume all threads in the IPC object list. By contrast, the rt_ipc_list_resume() function will resume a suspended thread in the list of a IPC object.

参数

susp_list	is a pointer to a suspended thread list of the IPC object.
thread_error	thread error number of the resuming thread. A negative value in this set will be discarded, and thread error will not be changed.

返回

Return the operation status. When the return value is RT_EOK, the function is successfully executed. When the return value is any other values, it means this operation failed.

在文件 ipc.c 第 165 行定义.

{
    struct rt_thread *thread;
 
    RT_SCHED_DEBUG_IS_UNLOCKED;
 
    /* wakeup all suspended threads */
    thread = rt_susp_list_dequeue(susp_list, thread_error);
    while (thread)
    {
        /*
         * resume NEXT thread
         * In rt_thread_resume function, it will remove current thread from
         * suspended list
         */
        thread = rt_susp_list_dequeue(susp_list, thread_error);
    }
 
    return RT_EOK;
}

引用了 RT_SCHED_DEBUG_IS_UNLOCKED , 以及 rt_susp_list_dequeue().

函数调用图:

这是这个函数的调用关系图:

rt_susp_list_resume_all_irq()

rt_err_t rt_susp_list_resume_all_irq	(	rt_list_t *	susp_list,
		rt_err_t	thread_error,
		struct rt_spinlock *	lock )

This function will resume all suspended threads in the IPC object list, including the suspended list of IPC object, and private list of mailbox etc. A lock is passing and hold while operating.

注解

This function will resume all threads in the IPC object list. By contrast, the rt_ipc_list_resume() function will resume a suspended thread in the list of a IPC object.

参数

susp_list	is a pointer to a suspended thread list of the IPC object.
thread_error	thread error number of the resuming thread. A negative value in this set will be discarded, and thread error will not be changed.
lock	the lock to be held while operating susp_list

返回

Return the operation status. When the return value is RT_EOK, the function is successfully executed. When the return value is any other values, it means this operation failed.

在文件 ipc.c 第 204 行定义.

{
    struct rt_thread *thread;
    rt_base_t level;
 
    RT_SCHED_DEBUG_IS_UNLOCKED;
 
    do
    {
        level = rt_spin_lock_irqsave(lock);
 
        /*
         * resume NEXT thread
         * In rt_thread_resume function, it will remove current thread from
         * suspended list
         */
        thread = rt_susp_list_dequeue(susp_list, thread_error);
 
        rt_spin_unlock_irqrestore(lock, level);
    }
    while (thread);
 
    return RT_EOK;
}

引用了 RT_SCHED_DEBUG_IS_UNLOCKED, rt_spin_lock_irqsave(), rt_spin_unlock_irqrestore() , 以及 rt_susp_list_dequeue().

函数调用图:

rt_susp_list_enqueue()

rt_err_t rt_susp_list_enqueue	(	rt_list_t *	susp_list,
		rt_thread_t	thread,
		int	ipc_flags )

Add a thread to the suspend list

注解

Caller must hold the scheduler lock

参数

susp_list	the list thread enqueued to
thread	the suspended thread
ipc_flags	the pattern of suspend list

返回

RT_EOK on succeed, otherwise a failure

在文件 ipc.c 第 241 行定义.

{
    RT_SCHED_DEBUG_IS_LOCKED;
 
    switch (ipc_flags)
    {
    case RT_IPC_FLAG_FIFO:
        rt_list_insert_before(susp_list, &RT_THREAD_LIST_NODE(thread));
        break; /* RT_IPC_FLAG_FIFO */
 
    case RT_IPC_FLAG_PRIO:
        {
            struct rt_list_node *n;
            struct rt_thread *sthread;
 
            /* find a suitable position */
            for (n = susp_list->next; n != susp_list; n = n->next)
            {
                sthread = RT_THREAD_LIST_NODE_ENTRY(n);
 
                /* find out */
                if (rt_sched_thread_get_curr_prio(thread) < rt_sched_thread_get_curr_prio(sthread))
                {
                    /* insert this thread before the sthread */
                    rt_list_insert_before(&RT_THREAD_LIST_NODE(sthread), &RT_THREAD_LIST_NODE(thread));
                    break;
                }
            }
 
            /*
             * not found a suitable position,
             * append to the end of suspend_thread list
             */
            if (n == susp_list)
                rt_list_insert_before(susp_list, &RT_THREAD_LIST_NODE(thread));
        }
        break;/* RT_IPC_FLAG_PRIO */
 
    default:
        RT_ASSERT(0);
        break;
    }
 
    return RT_EOK;
}

引用了 rt_list_node::next, RT_ASSERT, RT_IPC_FLAG_FIFO, RT_IPC_FLAG_PRIO, rt_list_insert_before(), RT_SCHED_DEBUG_IS_LOCKED, rt_sched_thread_get_curr_prio(), RT_THREAD_LIST_NODE , 以及 RT_THREAD_LIST_NODE_ENTRY.

函数调用图:

这是这个函数的调用关系图:

rt_susp_list_print()

void rt_susp_list_print

(

rt_list_t *

list

)

Print thread on suspend list to system console

Suspend list - A basic building block for IPC primitives which interacts with scheduler directly. Its API is similar to a FIFO list.

Note: don't use in application codes directly

在文件 ipc.c 第 290 行定义.

{
#ifdef RT_USING_CONSOLE
    rt_sched_lock_level_t slvl;
    struct rt_thread *thread;
    struct rt_list_node *node;
 
    rt_sched_lock(&slvl);
 
    for (node = list->next; node != list; node = node->next)
    {
        thread = RT_THREAD_LIST_NODE_ENTRY(node);
        rt_kprintf("%.*s", RT_NAME_MAX, thread->parent.name);
 
        if (node->next != list)
            rt_kprintf("/");
    }
 
    rt_sched_unlock(slvl);
#else
    (void)list;
#endif
}

引用了 rt_object::name, rt_list_node::next, rt_thread::parent, rt_kprintf, rt_sched_lock(), rt_sched_unlock() , 以及 RT_THREAD_LIST_NODE_ENTRY.

函数调用图:

这是这个函数的调用关系图:

_mutex_update_priority()

rt_inline rt_uint8_t _mutex_update_priority

(

struct rt_mutex *

mutex

)

在文件 ipc.c 第 827 行定义.

{
    struct rt_thread *thread;
 
    if (!rt_list_isempty(&mutex->parent.suspend_thread))
    {
        thread = RT_THREAD_LIST_NODE_ENTRY(mutex->parent.suspend_thread.next);
        mutex->priority = rt_sched_thread_get_curr_prio(thread);
    }
    else
    {
        mutex->priority = 0xff;
    }
 
    return mutex->priority;
}

引用了 rt_list_node::next, rt_mutex::parent, rt_mutex::priority, rt_list_isempty(), rt_sched_thread_get_curr_prio(), RT_THREAD_LIST_NODE_ENTRY , 以及 rt_ipc_object::suspend_thread.

函数调用图:

这是这个函数的调用关系图:

_thread_get_mutex_priority()

rt_inline rt_uint8_t _thread_get_mutex_priority

(

struct rt_thread *

thread

)

在文件 ipc.c 第 845 行定义.

{
    rt_list_t *node = RT_NULL;
    struct rt_mutex *mutex = RT_NULL;
    rt_uint8_t priority = rt_sched_thread_get_init_prio(thread);
 
    rt_list_for_each(node, &(thread->taken_object_list))
    {
        mutex = rt_list_entry(node, struct rt_mutex, taken_list);
        rt_uint8_t mutex_prio = mutex->priority;
        /* prio at least be priority ceiling */
        mutex_prio = mutex_prio < mutex->ceiling_priority ? mutex_prio : mutex->ceiling_priority;
 
        if (priority > mutex_prio)
        {
            priority = mutex_prio;
        }
    }
 
    return priority;
}

引用了 rt_mutex::ceiling_priority, rt_mutex::priority, rt_list_entry, rt_list_for_each, RT_NULL, rt_sched_thread_get_init_prio(), rt_mutex::taken_list , 以及 rt_thread::taken_object_list.

函数调用图:

这是这个函数的调用关系图:

_thread_update_priority()

rt_inline void _thread_update_priority	(	struct rt_thread *	thread,
		rt_uint8_t	priority,
		int	suspend_flag )

在文件 ipc.c 第 868 行定义.

{
    rt_err_t ret = -RT_ERROR;
    struct rt_object* pending_obj = RT_NULL;
 
    LOG_D("thread:%s priority -> %d", thread->parent.name, priority);
 
    /* change priority of the thread */
    ret = rt_sched_thread_change_priority(thread, priority);
 
    while ((ret == RT_EOK) && rt_sched_thread_is_suspended(thread))
    {
        /* whether change the priority of taken mutex */
        pending_obj = thread->pending_object;
 
        if (pending_obj && rt_object_get_type(pending_obj) == RT_Object_Class_Mutex)
        {
            rt_uint8_t mutex_priority = 0xff;
            struct rt_mutex* pending_mutex = (struct rt_mutex *)pending_obj;
 
            /* re-insert thread to suspended thread list to resort priority list */
            rt_list_remove(&RT_THREAD_LIST_NODE(thread));
 
            ret = rt_susp_list_enqueue(
                &(pending_mutex->parent.suspend_thread), thread,
                pending_mutex->parent.parent.flag);
            if (ret == RT_EOK)
            {
                /* update priority */
                _mutex_update_priority(pending_mutex);
                /* change the priority of mutex owner thread */
                LOG_D("mutex: %s priority -> %d", pending_mutex->parent.parent.name,
                        pending_mutex->priority);
 
                mutex_priority = _thread_get_mutex_priority(pending_mutex->owner);
                if (mutex_priority != rt_sched_thread_get_curr_prio(pending_mutex->owner))
                {
                    thread = pending_mutex->owner;
 
                    ret = rt_sched_thread_change_priority(thread, mutex_priority);
                }
                else
                {
                    ret = -RT_ERROR;
                }
            }
        }
        else
        {
            ret = -RT_ERROR;
        }
    }
}

引用了 _mutex_update_priority(), _thread_get_mutex_priority(), rt_object::flag, LOG_D, rt_object::name, rt_mutex::owner, rt_ipc_object::parent, rt_mutex::parent, rt_thread::parent, rt_thread::pending_object, rt_mutex::priority, rt_list_remove(), RT_NULL, RT_Object_Class_Mutex, rt_object_get_type(), rt_sched_thread_change_priority(), rt_sched_thread_get_curr_prio(), rt_sched_thread_is_suspended(), rt_susp_list_enqueue(), RT_THREAD_LIST_NODE , 以及 rt_ipc_object::suspend_thread.

函数调用图:

这是这个函数的调用关系图:

rt_thread_suspend_to_list()

rt_err_t rt_thread_suspend_to_list	(	rt_thread_t	thread,
		rt_list_t *	susp_list,
		int	ipc_flags,
		int	suspend_flag )

This function will suspend the specified thread and change it to suspend state.

注解

This function ONLY can suspend current thread itself. rt_thread_suspend(rt_thread_self());

Do not use the rt_thread_suspend to suspend other threads. You have no way of knowing what code a thread is executing when you suspend it. If you suspend a thread while sharing a resouce with other threads and occupying this resouce, starvation can occur very easily.

参数

thread	the thread to be suspended.
susp_list	the list thread enqueued to. RT_NULL if no list.
ipc_flags	is a flag for the thread object to be suspended. It determines how the thread is suspended. The flag can be ONE of the following values: RT_IPC_FLAG_PRIO The pending threads will queue in order of priority. RT_IPC_FLAG_FIFO The pending threads will queue in the first-in-first-out method (also known as first-come-first-served (FCFS) scheduling strategy). NOTE: RT_IPC_FLAG_FIFO is a non-real-time scheduling mode. It is strongly recommended to use RT_IPC_FLAG_PRIO to ensure the thread is real-time UNLESS your applications concern about the first-in-first-out principle, and you clearly understand that all threads involved in this semaphore will become non-real-time threads.
suspend_flag	status flag of the thread to be suspended.

返回

Return the operation status. If the return value is RT_EOK, the function is successfully executed. If the return value is any other values, it means this operation failed.

enqueue thread on the push list before leaving critical region of scheduler, so we won't miss notification of async events.

在文件 thread.c 第 897 行定义.

{
    rt_base_t stat;
    rt_sched_lock_level_t slvl;
 
    /* parameter check */
    RT_ASSERT(thread != RT_NULL);
    RT_ASSERT(rt_object_get_type((rt_object_t)thread) == RT_Object_Class_Thread);
    RT_ASSERT(thread == rt_thread_self());
 
    LOG_D("thread suspend:  %s", thread->parent.name);
 
    rt_sched_lock(&slvl);
 
    stat = rt_sched_thread_get_stat(thread);
    if ((stat != RT_THREAD_READY) && (stat != RT_THREAD_RUNNING))
    {
        LOG_D("thread suspend: thread disorder, 0x%2x", thread->stat);
        rt_sched_unlock(slvl);
        return -RT_ERROR;
    }
 
    if (stat == RT_THREAD_RUNNING)
    {
        /* not suspend running status thread on other core */
        RT_ASSERT(thread == rt_thread_self());
    }
 
#ifdef RT_USING_SMART
    if (thread->lwp)
    {
        rt_sched_unlock(slvl);
 
        /* check pending signals for thread before suspend */
        if (lwp_thread_signal_suspend_check(thread, suspend_flag) == 0)
        {
            /* not to suspend */
            return -RT_EINTR;
        }
 
        rt_sched_lock(&slvl);
        if (stat == RT_THREAD_READY)
        {
            stat = rt_sched_thread_get_stat(thread);
 
            if (stat != RT_THREAD_READY)
            {
                /* status updated while we check for signal */
                rt_sched_unlock(slvl);
                return -RT_ERROR;
            }
        }
    }
#endif
 
    /* change thread stat */
    rt_sched_remove_thread(thread);
    _thread_set_suspend_state(thread, suspend_flag);
 
    if (susp_list)
    {
        rt_susp_list_enqueue(susp_list, thread, ipc_flags);
    }
 
    /* stop thread timer anyway */
    rt_sched_thread_timer_stop(thread);
 
    rt_sched_unlock(slvl);
 
    RT_OBJECT_HOOK_CALL(rt_thread_suspend_hook, (thread));
    return RT_EOK;
}

引用了 LOG_D, rt_object::name, rt_thread::parent, RT_ASSERT, RT_NULL, RT_Object_Class_Thread, rt_object_get_type(), RT_OBJECT_HOOK_CALL, rt_sched_lock(), rt_sched_thread_get_stat(), rt_sched_thread_timer_stop(), rt_sched_unlock(), rt_susp_list_enqueue(), RT_THREAD_READY, RT_THREAD_RUNNING, rt_thread_self() , 以及 stat().

函数调用图:

这是这个函数的调用关系图:

rt_thread_defunct_init()

void rt_thread_defunct_init

(

void

)

在文件 defunct.c 第 157 行定义.

{
    RT_ASSERT(RT_THREAD_PRIORITY_MAX > 2);
 
    rt_spin_lock_init(&_defunct_spinlock);
 
#if defined(RT_USING_SMP) || defined(RT_USING_SMART)
    rt_sem_init(&system_sem, "defunct", 0, RT_IPC_FLAG_FIFO);
 
    /* create defunct thread */
    rt_thread_init(&rt_system_thread,
                   "tsystem",
                   rt_thread_system_entry,
                   RT_NULL,
                   rt_system_stack,
                   sizeof(rt_system_stack),
                   RT_THREAD_PRIORITY_MAX - 2,
                   32);
    /* startup */
    rt_thread_startup(&rt_system_thread);
#endif
}

引用了 RT_ASSERT, RT_IPC_FLAG_FIFO, RT_NULL, rt_sem_init(), rt_spin_lock_init(), rt_thread_init() , 以及 rt_thread_startup().

函数调用图:

rt_thread_defunct_enqueue()

void rt_thread_defunct_enqueue

(

rt_thread_t

thread

)

Enqueue a thread to defunct queue.

参数

thread

the thread to be enqueued.

注解

It must be called between rt_hw_interrupt_disable and rt_hw_interrupt_enable

在文件 defunct.c 第 33 行定义.

{
    rt_base_t level;
    level = rt_spin_lock_irqsave(&_defunct_spinlock);
    rt_list_insert_after(&_rt_thread_defunct, &RT_THREAD_LIST_NODE(thread));
    rt_spin_unlock_irqrestore(&_defunct_spinlock, level);
#if defined(RT_USING_SMP) || defined(RT_USING_SMART)
    rt_sem_release(&system_sem);
#endif
}

引用了 rt_list_insert_after(), rt_sem_release(), rt_spin_lock_irqsave(), rt_spin_unlock_irqrestore() , 以及 RT_THREAD_LIST_NODE.

函数调用图:

rt_thread_defunct_dequeue()

rt_thread_t rt_thread_defunct_dequeue

(

void

)

Dequeue a thread from defunct queue.

在文件 defunct.c 第 47 行定义.

{
    rt_base_t   level;
    rt_thread_t thread = RT_NULL;
    rt_list_t  *l      = &_rt_thread_defunct;
 
    level = rt_spin_lock_irqsave(&_defunct_spinlock);
    if (!rt_list_isempty(l))
    {
        thread = RT_THREAD_LIST_NODE_ENTRY(l->next);
        rt_list_remove(&RT_THREAD_LIST_NODE(thread));
    }
    rt_spin_unlock_irqrestore(&_defunct_spinlock, level);
 
    return thread;
}

引用了 rt_list_node::next, rt_list_isempty(), rt_list_remove(), RT_NULL, rt_spin_lock_irqsave(), rt_spin_unlock_irqrestore(), RT_THREAD_LIST_NODE , 以及 RT_THREAD_LIST_NODE_ENTRY.

函数调用图:

这是这个函数的调用关系图:

rt_defunct_execute()

void rt_defunct_execute

(

void

)

This function will perform system background job when system idle.

在文件 defunct.c 第 67 行定义.

{
    /* Loop until there is no dead thread. So one call to rt_defunct_execute
     * will do all the cleanups. */
    while (1)
    {
        rt_thread_t thread;
        rt_bool_t   object_is_systemobject;
        void (*cleanup)(struct rt_thread *tid);
 
#ifdef RT_USING_MODULE
        struct rt_dlmodule *module = RT_NULL;
#endif
        /* get defunct thread */
        thread = rt_thread_defunct_dequeue();
        if (thread == RT_NULL)
        {
            break;
        }
 
#ifdef RT_USING_MODULE
        module = (struct rt_dlmodule *)thread->parent.module_id;
        if (module)
        {
            dlmodule_destroy(module);
        }
#endif
 
#ifdef RT_USING_SIGNALS
        rt_thread_free_sig(thread);
#endif
 
        /* store the point of "thread->cleanup" avoid to lose */
        cleanup = thread->cleanup;
 
        /* if it's a system object, detach it */
        object_is_systemobject = rt_object_is_systemobject((rt_object_t)thread);
        if (object_is_systemobject == RT_TRUE)
        {
            /* detach this object */
            rt_object_detach((rt_object_t)thread);
        }
 
        /* invoke thread cleanup */
        if (cleanup != RT_NULL)
        {
            cleanup(thread);
        }
 
#ifdef RT_USING_HEAP
#ifdef RT_USING_MEM_PROTECTION
        if (thread->mem_regions != RT_NULL)
        {
            RT_KERNEL_FREE(thread->mem_regions);
        }
#endif
        /* if need free, delete it */
        if (object_is_systemobject == RT_FALSE)
        {
            /* release thread's stack */
#ifdef RT_USING_HW_STACK_GUARD
            RT_KERNEL_FREE(thread->stack_buf);
#else
            RT_KERNEL_FREE(thread->stack_addr);
#endif
            /* delete thread object */
            rt_object_delete((rt_object_t)thread);
        }
#endif
    }
}

引用了 rt_thread::cleanup, RT_FALSE, RT_KERNEL_FREE, RT_NULL, rt_object_delete(), rt_object_detach(), rt_object_is_systemobject(), rt_thread_defunct_dequeue(), RT_TRUE , 以及 rt_thread::stack_addr.

函数调用图:

rt_spin_lock_init()

void rt_spin_lock_init

(

struct rt_spinlock *

lock

)

Initialize a static spinlock object.

参数

lock	is a pointer to the spinlock to initialize.

在文件 cpu_mp.c 第 37 行定义.

{
    rt_hw_spin_lock_init(&lock->lock);
}

引用了 rt_spinlock::lock , 以及 RT_UNUSED.

这是这个函数的调用关系图:

rt_spin_lock()

void rt_spin_lock

(

struct rt_spinlock *

lock

)

This function will lock the spinlock, will lock the thread scheduler.

注解

If the spinlock is locked, the current CPU will keep polling the spinlock state until the spinlock is unlocked.

参数

lock	is a pointer to the spinlock.

在文件 cpu_mp.c 第 51 行定义.

{
    rt_enter_critical();
    rt_hw_spin_lock(&lock->lock);
    RT_SPIN_LOCK_DEBUG(lock);
}

引用了 rt_enter_critical(), rt_hw_spin_lock, rt_spin_lock() , 以及 RT_SPIN_LOCK_DEBUG.

函数调用图:

这是这个函数的调用关系图:

rt_spin_unlock()

void rt_spin_unlock

(

struct rt_spinlock *

lock

)

This function will unlock the spinlock, will unlock the thread scheduler.

参数

lock	is a pointer to the spinlock.

在文件 cpu_mp.c 第 64 行定义.

{
    rt_base_t critical_level;
    RT_SPIN_UNLOCK_DEBUG(lock, critical_level);
    rt_hw_spin_unlock(&lock->lock);
    rt_exit_critical_safe(critical_level);
}

引用了 rt_exit_critical_safe(), rt_hw_spin_unlock, rt_spin_unlock() , 以及 RT_SPIN_UNLOCK_DEBUG.

函数调用图:

这是这个函数的调用关系图:

rt_spin_lock_irqsave()

rt_base_t rt_spin_lock_irqsave

(

struct rt_spinlock *

lock

)

This function will disable the local interrupt and then lock the spinlock, will lock the thread scheduler.

注解

If the spinlock is locked, the current CPU will keep polling the spinlock state until the spinlock is unlocked.

参数

lock	is a pointer to the spinlock.

返回

Return current cpu interrupt status.

在文件 cpu_mp.c 第 83 行定义.

{
    rt_base_t level;
 
    level = rt_hw_local_irq_disable();
    rt_enter_critical();
    rt_hw_spin_lock(&lock->lock);
    RT_SPIN_LOCK_DEBUG(lock);
    return level;
}

引用了 rt_enter_critical(), rt_hw_interrupt_disable(), rt_hw_local_irq_disable, rt_hw_spin_lock, RT_SPIN_LOCK_DEBUG, rt_spin_lock_irqsave() , 以及 RT_UNUSED.

函数调用图:

rt_spin_unlock_irqrestore()

void rt_spin_unlock_irqrestore	(	struct rt_spinlock *	lock,
		rt_base_t	level )

This function will unlock the spinlock and then restore current cpu interrupt status, will unlock the thread scheduler.

参数

lock	is a pointer to the spinlock.
level	is interrupt status returned by rt_spin_lock_irqsave().

在文件 cpu_mp.c 第 102 行定义.

{
    rt_base_t critical_level;
 
    RT_SPIN_UNLOCK_DEBUG(lock, critical_level);
    rt_hw_spin_unlock(&lock->lock);
    rt_exit_critical_safe(critical_level);
    rt_hw_local_irq_enable(level);
}

引用了 rt_exit_critical_safe(), rt_hw_interrupt_enable(), rt_hw_local_irq_enable, rt_hw_spin_unlock, RT_SPIN_UNLOCK_DEBUG , 以及 rt_spin_unlock_irqrestore().

函数调用图: