rt-thread的IPC机制之信号量源码分析
rt-thread操作系统的IPC（Inter-Process Communication，进程间通信）包含有信号量,互斥锁,事件,邮箱,消息队列.
本文主要针对信号量.信号量是用来解决线程同步和互斥的通用工具，和互斥量类似，信号量也可用作资源互斥访问，但信号量没有所有者的概念，在应用上比互斥量更广泛。信号量比较简单，不能解决优先级翻转问题，但信号量是一种轻量级的对象，比互斥量小巧、灵活。因此在很多对互斥要求不严格的系统中（或者不会造成优先级翻转的情况下），经常使用信号量来管理互斥资源。
1 信号量控制块
/**
* Semaphore structure
*/
struct rt_semaphore
{
struct rt_ipc_object parent; /**< inherit from ipc_object *///派生自IPC对象
rt_uint16_t value; /**< value of semaphore. *///信号量计数器
};
typedef struct rt_semaphore *rt_sem_t;value为信号计数器,此信号量多次被释放时将会累加，在被获取时则将减1，当其值为0时，再请求获取的线程将会被挂起到挂起链表中。
parent为一rt_ipc_object即IPC对象,其定义如下:
/**
* Base structure of IPC object
*/
struct rt_ipc_object
{
struct rt_object parent; /**< inherit from rt_object *///可知其派生自内核对象
rt_list_t suspend_thread; /**< threads pended on this resource *///线程挂起链表
};
从rt_ipc_object的定义结构可知其派生自rt_object结构,即内核对象的定义(参考http://blog.csdn.net/flydream0/article/details/8568463),而其它IPC，如互斥锁，事件，邮箱，消息队列都是从rt_ipc_object派生。
另外,IPC对象还包含一挂起链表,用来保存因此IPC对象而挂起的线程.
2 信号量的创建与初始化
2.1 初始化
/**
* This function will initialize a semaphore and put it under control of
* resource management.
*
* @param sem the semaphore object
* @param name the name of semaphore
* @param value the init value of semaphore
* @param flag the flag of semaphore
*
* @return the operation status, RT_EOK on successful
*/
rt_err_t rt_sem_init(rt_sem_t sem,
const char *name,
rt_uint32_t value,
rt_uint8_t flag)
{
RT_ASSERT(sem != RT_NULL);
/* init object */
rt_object_init(&(sem->parent.parent), RT_Object_Class_Semaphore, name);//初始化信号量的内核对象
/* init ipc object */
rt_ipc_object_init(&(sem->parent));//初始化信号量的IPC对象
/* set init value */
sem->value = value;//设置信号量计数器的值
/* set parent */
sem->parent.parent.flag = flag;//设置信号量的内核对象的标志
return RT_EOK;
}
其中rt_object_init已在之前介绍rt-thread的内核对象中相关文章中已有介绍(参见: http://blog.csdn.net/flydream0/article/details/8568463),rt_ipc_object_init函数见如下:
/**
* @addtogroup IPC
*/
/*@{*/
/**
* This function will initialize an IPC object
*
* @param ipc the IPC object
*
* @return the operation status, RT_EOK on successful
*/
rt_inline rt_err_t rt_ipc_object_init(struct rt_ipc_object *ipc)
{
/* init ipc object */
rt_list_init(&(ipc->suspend_thread));//初始化线程挂起链表
return RT_EOK;
}
2.2 创建信号量
/**
* This function will create a semaphore from system resource
*
* @param name the name of semaphore
* @param value the init value of semaphore
* @param flag the flag of semaphore
*
* @return the created semaphore, RT_NULL on error happen
*
* @see rt_sem_init
*/
rt_sem_t rt_sem_create(const char *name, rt_uint32_t value, rt_uint8_t flag)
{
rt_sem_t sem;
RT_DEBUG_NOT_IN_INTERRUPT;//确保此函数不是在中断中使用
/* allocate object */
sem = (rt_sem_t)rt_object_allocate(RT_Object_Class_Semaphore, name);//动态分配内核对象
if (sem == RT_NULL)
return sem;
/* init ipc object */
rt_ipc_object_init(&(sem->parent));//初始化信号量的IPC对象
/* set init value */
sem->value = value;//初始化信号量的计数器值
/* set parent */
sem->parent.parent.flag = flag;//设置信号量的内核对象的标志
return sem;
}
3 脱离及删除信号量
3.1 脱离信号量
/**
* This function will detach a semaphore from resource management
*
* @param sem the semaphore object
*
* @return the operation status, RT_EOK on successful
*
* @see rt_sem_delete
*/
rt_err_t rt_sem_detach(rt_sem_t sem)
{
RT_ASSERT(sem != RT_NULL);
/* wakeup all suspend threads */
rt_ipc_list_resume_all(&(sem->parent.suspend_thread));//唤醒所有信号量内挂起的线程
/* detach semaphore object */
rt_object_detach(&(sem->parent.parent));//脱离信号量的内核对象
return RT_EOK;
}
脱离信号量时被将挂起链表中的所有线程都唤醒，其中rt_ipc_list_resume_all函数如下:
/**
* This function will resume all suspended threads in a list, including
* suspend list of IPC object and private list of mailbox etc.
*
* @param list of the threads to resume
*
* @return the operation status, RT_EOK on successful
*/
rt_inline rt_err_t rt_ipc_list_resume_all(rt_list_t *list)
{
struct rt_thread *thread;
register rt_ubase_t temp;
/* wakeup all suspend threads */
while (!rt_list_isempty(list))//遍历线程挂起链表
{
/* disable interrupt */
temp = rt_hw_interrupt_disable();//关中断
/* get next suspend thread */
thread = rt_list_entry(list->next, struct rt_thread, tlist);//获得线程
/* set error code to RT_ERROR */
thread->error = -RT_ERROR;//设置线程的错误码为-RT_ERROR
/*
* resume thread
* In rt_thread_resume function, it will remove current thread from
* suspend list
*/
rt_thread_resume(thread);//唤醒此线程
/* enable interrupt */
rt_hw_interrupt_enable(temp);//开中断
}
return RT_EOK;
}
3.2 删除线程
/**
* This function will delete a semaphore object and release the memory
*
* @param sem the semaphore object
*
* @return the error code
*
* @see rt_sem_detach
*/
rt_err_t rt_sem_delete(rt_sem_t sem)
{
RT_DEBUG_NOT_IN_INTERRUPT;//确保此函数不是在中断中使用
RT_ASSERT(sem != RT_NULL);
/* wakeup all suspend threads */
rt_ipc_list_resume_all(&(sem->parent.suspend_thread));//唤醒所有挂起的线程
/* delete semaphore object */
rt_object_delete(&(sem->parent.parent));//删除信号量内核对象
return RT_EOK;
}
4 获取信号量
4.1 等待信号量
/**
* This function will take a semaphore, if the semaphore is unavailable, the
* thread shall wait for a specified time.
*
* @param sem the semaphore object
* @param time the waiting time
*
* @return the error code
*/
rt_err_t rt_sem_take(rt_sem_t sem, rt_int32_t time)
{
register rt_base_t temp;
struct rt_thread *thread;
RT_ASSERT(sem != RT_NULL);
RT_OBJECT_HOOK_CALL(rt_object_trytake_hook, (&(sem->parent.parent)));
/* disable interrupt */
temp = rt_hw_interrupt_disable();//关中断
RT_DEBUG_LOG(RT_DEBUG_IPC, ("thread %s take sem:%s, which value is: %d\n",
rt_thread_self()->name,
((struct rt_object *)sem)->name,
sem->value));
if (sem->value > 0)//如果此信号量的计数器的值大于0,说明有信号,则应该立即返回
{
/* semaphore is available */
sem->value --;//则将信号量的计数器的值减1
/* enable interrupt */
rt_hw_interrupt_enable(temp);//开中断
}
else//如果此信号量的计数器的值小于或等于0,说明此时还未有信号
{
/* no waiting, return with timeout */
if (time == 0)//如果等待时间参数为0,则立即返回超时错误
{
rt_hw_interrupt_enable(temp);//开中断
return -RT_ETIMEOUT;//返回超时错误
}
else//等待信号
{
/* current context checking */
RT_DEBUG_NOT_IN_INTERRUPT;//确保此时不在中断中使用
/* semaphore is unavailable, push to suspend list */
/* get current thread */
thread = rt_thread_self();//获取当前正在运行的线程
/* reset thread error number */
thread->error = RT_EOK;//设置当前线程的错误代码为RT_EOK,需要注意这里
RT_DEBUG_LOG(RT_DEBUG_IPC, ("sem take: suspend thread - %s\n",
thread->name));
/* suspend thread */
rt_ipc_list_suspend(&(sem->parent.suspend_thread),//挂起当前线程到信号量中的断起线程链表
thread,
sem->parent.parent.flag);
/* has waiting time, start thread timer */
if (time > 0)//如果时间参数大于0
{
RT_DEBUG_LOG(RT_DEBUG_IPC, ("set thread:%s to timer list\n",
thread->name));
/* reset the timeout of thread timer and start it */
rt_timer_control(&(thread->thread_timer),//设置定时器
RT_TIMER_CTRL_SET_TIME,
&time);
rt_timer_start(&(thread->thread_timer));//启动定时器开始计时
}
/* enable interrupt */
rt_hw_interrupt_enable(temp);//开中断
/* do schedule */
rt_schedule();//当前线程已挂起,需要重新调试线程
//rt_schedule之后再执行到这里，只有两种可能，一是当前线程被挂起后时间已到达，此时，定时器的超时回调处理函数会将此线程的err值设为-RT_ETIMEOU,见thread.c源文件中的rt_thread_timeout函数；另一种情况是，有信号量到来，当前线程被rt_sem_release函数唤醒，此时，此线程的err值将一直保持原样不变，因此可以下面可能通过判断线程的err值来判断当前线程是否已被接收到信号量
if (thread->error != RT_EOK)//如果当前线程的错误代码不为RT_EOK,则返回,否则一直阻塞到等待到有信号到达或超时
{
return thread->error;
}
}
}
RT_OBJECT_HOOK_CALL(rt_object_take_hook, (&(sem->parent.parent)));
return RT_EOK;
}
获取信号量函数首先会判断当前是否有信号量（通过value值来判断），如果有则立即成功返回，如果没有，则接下来首先判断是否有时间参数，如果等待时间参数为0，则表示需要立即返回，则立即返回错误。如果等待时间参数大于0，则表示需要延时一段时间，在此延时期间，如何信号量到达，或者信号量被非法脱离，或一直没有等到，则通过判断线程的error值来判断当前是否已经成功获得信号值，因为如果成功获得信号量时，即在另一个线程release信号后，因此这一整个过程并没有修改线程的error值，因此，线程的error值一直保持原先的RT_EOK不变。若是线程一直没有等待到信号量的到达，即产生的定时器超时时（在take过程中会将设置一定时器，然后启动它，再挂起当前线程），在线程定时器的回调超时处理函数中，程序会将线程的error值修改为-RT_ETIMEOUT。另，如果之前讲解脱离线程时，如果在某一线程等待信号量期间，这个信号量被意外脱离了时，在脱离信号量的函数中（见3.1节），程序会将线程的error值修改为-RT_ERROR。
综上所述，程序可以通过线程的error值来对其是否真正获得信号量进行判定，即如果线程的error值一直保持原样即thread->error==RT_EOK时，则为已获取信号量，否则没有获取，要么超时（-RT_ETIMEOUT)，要么非法脱离（-RT_ERROR)了。
4.2 获取无等待信号量
/**
* This function will try to take a semaphore and immediately return
*
* @param sem the semaphore object
*
* @return the error code
*/
rt_err_t rt_sem_trytake(rt_sem_t sem)
{
return rt_sem_take(sem, 0);
}
由此可见,rt_sem_trytake只是rt_sem_take函数的一种特例,时间参数为0而已.
5 释放信号量
/**
* This function will release a semaphore, if there are threads suspended on
* semaphore, it will be waked up.
*
* @param sem the semaphore object
*
* @return the error code
*/
rt_err_t rt_sem_release(rt_sem_t sem)
{
register rt_base_t temp;
register rt_bool_t need_schedule;
RT_OBJECT_HOOK_CALL(rt_object_put_hook, (&(sem->parent.parent)));
need_schedule = RT_FALSE;//默认情况下设置不需要重新调度标记
/* disable interrupt */
temp = rt_hw_interrupt_disable();//关中断
RT_DEBUG_LOG(RT_DEBUG_IPC, ("thread %s releases sem:%s, which value is: %d\n",
rt_thread_self()->name,
((struct rt_object *)sem)->name,
sem->value));
if (!rt_list_isempty(&sem->parent.suspend_thread))//挂起线程不为空
{
/* resume the suspended thread */
rt_ipc_list_resume(&(sem->parent.suspend_thread));//唤醒第一个挂起的线程
need_schedule = RT_TRUE;//需要重新调度
}
else
sem->value ++; /* increase value *///信号量计数器加1
/* enable interrupt */
rt_hw_interrupt_enable(temp);//开中断
/* resume a thread, re-schedule */
if (need_schedule == RT_TRUE)//如果需要重新调度线程,则重新调度
rt_schedule();
return RT_EOK;
}
释放信号量只对将信号时的value值加1。
其中函数rt_ipc_list_resume只会唤醒信号量中第一个挂起的线程,其源码如下:
/**
* This function will resume the first thread in the list of a IPC object:
* - remove the thread from suspend queue of IPC object
* - put the thread into system ready queue
*
* @param list the thread list
*
* @return the operation status, RT_EOK on successful
*/
rt_inline rt_err_t rt_ipc_list_resume(rt_list_t *list)
{
struct rt_thread *thread;
/* get thread entry */
thread = rt_list_entry(list->next, struct rt_thread, tlist);//获取线程
RT_DEBUG_LOG(RT_DEBUG_IPC, ("resume thread:%s\n", thread->name));
/* resume it */
rt_thread_resume(thread);//唤醒此线程
return RT_EOK;
}
这里需要注意地是，释放信号量的过程不会修改线程的error值，即error原持原值RT_EOK不变.
6 信号量控制
/**
* This function can get or set some extra attributions of a semaphore object.
*
* @param sem the semaphore object
* @param cmd the execution command
* @param arg the execution argument
*
* @return the error code
*/
rt_err_t rt_sem_control(rt_sem_t sem, rt_uint8_t cmd, void *arg)
{
rt_ubase_t level;
RT_ASSERT(sem != RT_NULL);
if (cmd == RT_IPC_CMD_RESET)//重置信号量的计数器值
{
rt_uint32_t value;
/* get value */
value = (rt_uint32_t)arg;
/* disable interrupt */
level = rt_hw_interrupt_disable();//关中断
/* resume all waiting thread */
rt_ipc_list_resume_all(&sem->parent.suspend_thread);//唤醒信号量上所有挂起的线程
/* set new value */
sem->value = (rt_uint16_t)value;//设置信号时的计数器值
/* enable interrupt */
rt_hw_interrupt_enable(level);//开中断
rt_schedule();//立即重新调试
return RT_EOK;
}
return -RT_ERROR;
}
只支持重置信号量，此时若其存在挂起线程，则将其全部唤醒再次重新调度。此时在rt_ipc_list_resume_all函数中会将所有挂起的线程的error值设置为-RT_ERROR.