2.linux系统基础笔记（延时操作、实时系统中的定时器、事件）

延时操作

延时操作是操作系统中经常遇到的一种情形。延时的原因很多，有的时候是为了等待外设芯片处理结束，有的时候是为了暂时释放cpu的使用权，有的就是为了希望在一段时间获取资源，如果没法在单位时间内获取，放弃等待。但是不管怎么说，延时都是操作系统必不可少的一个工作。下面我们就看看延时是怎么实现的，

static void tick_list_priority_insert(LIST *head, RAW_TASK_OBJ *task_ptr)
{
　　RAW_U32 val;

　　LIST *q,*start, *end;
　　RAW_TASK_OBJ *task_iter_temp;

　　start = end = head;
　　val = task_ptr->tick_remain;

　　for (q = start->next; q != end; q = q->next) {

　　　　task_iter_temp = list_entry(q, RAW_TASK_OBJ, tick_list);

　　　　/*sorted by remain time*/

　　　　if ((task_iter_temp->tick_match - raw_tick_count) > val) {
　　　　　　break;
　　　　}
　　}

　　list_insert(q, &task_ptr->tick_list);
　　

}

void tick_list_insert(RAW_TASK_OBJ *task_ptr, RAW_U32 time)

{
　　LIST *tick_head_ptr;

　　RAW_U16 spoke;

　　if (time) {

　　　　task_ptr->tick_match = raw_tick_count + time;
　　　　task_ptr->tick_remain = time;

　　　　spoke = (RAW_U16)(task_ptr->tick_match & (TICK_HEAD_ARRAY - 1) );
　　　　tick_head_ptr = &tick_head[spoke];
　　
　　　　tick_list_priority_insert(tick_head_ptr, task_ptr);

　　　　task_ptr->tick_head = tick_head_ptr; 

　　} 

}

延时的代码其实不是很多，所以我在这里把最重要的两个函数给粘贴到这里了。因为每个线程都有可能延时，那么怎么处理这些线程之间的关系就是我们需要做的事情了。我们看到了，我们直接用tick_match表示线程需要等待的那个时间点就可以了。当然，tick是不断增加的，我们可以把尾数相同的线程按照高低顺序排列在一起，这样在对应的tick到来的时候，就直接按照尾数查找就可以了，tick_list_priority_insert就是干了这么一件事情。
 
     那么，tick什么时候到期呢？到期又该怎么处理呢，我们接着往下看，

void tick_list_update(void)
{

　　LIST *tick_head_ptr;
　　RAW_TASK_OBJ *p_tcb;
　　LIST *iter;
　　LIST *iter_temp;

　　RAW_U16 spoke;

　　RAW_SR_ALLOC();

　　RAW_CRITICAL_ENTER();

　　raw_tick_count++;
　　spoke = (RAW_U16)(raw_tick_count & (TICK_HEAD_ARRAY - 1) );
　　tick_head_ptr = &tick_head[spoke];
　　iter = tick_head_ptr->next;

　　while (RAW_TRUE) {

　　　　/*search all the time list if possible*/
　　　　if (iter != tick_head_ptr) {

　　　　　　iter_temp = iter->next;
　　　　　　p_tcb = list_entry(iter, RAW_TASK_OBJ, tick_list);

　　　　　　　　/*Since time list is sorted by remain time, so just campare the absolute time*/
　　　　　　　　if (raw_tick_count == p_tcb->tick_match) {

　　　　　　　　　　switch (p_tcb->task_state) {
　　　　　　　　　　　　case RAW_DLY:

　　　　　　　　　　　　　　p_tcb->block_status = RAW_B_OK;
　　　　　　　　　　　　　　p_tcb->task_state = RAW_RDY;
　　　　　　　　　　　　　　tick_list_remove(p_tcb);
　　　　　　　　　　　　　　add_ready_list(&raw_ready_queue, p_tcb);
　　　　　　　　　　　　　　break; 

　　　　　　　　　　　　case RAW_PEND_TIMEOUT:

　　　　　　　　　　　　　　p_tcb->block_status = RAW_B_TIMEOUT;
　　　　　　　　　　　　　　p_tcb->task_state = RAW_RDY;
　　　　　　　　　　　　　　p_tcb->block_obj = 0;
　　　　　　　　　　　　　　tick_list_remove(p_tcb);
　　　　　　　　　　　　　　/*remove task on the block list because task is timeout*/
　　　　　　　　　　　　　　list_delete(&p_tcb->task_list);
　　　　　　　　　　　　　　add_ready_list(&raw_ready_queue, p_tcb);
　　　　　　　　　　　　　　break;

　　　　　　　　　　　　case RAW_PEND_TIMEOUT_SUSPENDED:

　　　　　　　　　　　　　　p_tcb->block_status = RAW_B_TIMEOUT;
　　　　　　　　　　　　　　p_tcb->task_state = RAW_SUSPENDED;
　　　　　　　　　　　　　　p_tcb->block_obj = 0;
　　　　　　　　　　　　　　tick_list_remove(p_tcb);
　　　　　　　　　　　　　　/*remove task on the block list because task is timeout*/
　　　　　　　　　　　　　　list_delete(&p_tcb->task_list);
　　　　　　　　　　　　　　break;

　　　　　　　　　　　　case RAW_DLY_SUSPENDED:

　　　　　　　　　　　　　　p_tcb->task_state = RAW_SUSPENDED;
　　　　　　　　　　　　　　p_tcb->block_status = RAW_B_OK;
　　　　　　　　　　　　　　tick_list_remove(p_tcb);
　　　　　　　　　　　　　　break;

　　　　　　　　　　　　default:

　　　　　　　　　　　　　　#if (CONFIG_RAW_ASSERT > 0)
　　　　　　　　　　　　　　　　RAW_ASSERT(0);
　　　　　　　　　　　　　　#endif

　　　　　　　　　　　　　　break;
　　　　　　　　　　}

　　　　　　　　　　iter = iter_temp;
　　　　　　　　}

　　　　　　　　/*if current task time out absolute time is not equal current system time, just break because timer list is sorted*/
　　　　　　　　else {

　　　　　　　　　　break;

　　　　　　　　}

　　　　　　}

　　　　　　/*finish all the time list search */ 

　　　　　　else {

　　　　　　　　break;
　　　　　　}

　　　　}

　　　　RAW_CRITICAL_EXIT();
}

这个函数是在时钟中断的时候被调用的，根据函数的先后顺序，看看函数实现了哪些功能，
     （1）自增raw_tick_count；
     （2）根据尾数获取tick队列的头指针；
     （3）开始循环迭代处理延时线程；
             a）如果没有没有延时线程，循环跳出；
             b）如果线程的终点tick和当前tick不匹配，跳出循环，因为tick都是排序好的，所以后面的tick肯定不满足要求；
             c）如果当前tick满足要求，根据线程状态进行处理，主要分为延时、阻塞超时、延时挂起、阻塞超时挂起四种状态；
             d）获取下一个延时线程，观察是否满足要求，如果是继续回到c，否则退出循环。
     （4）函数返回，继续时钟中断的剩余操作。
 
     最后，我们补充一下关于有限时间等待的知识。就像以前关于互斥操作的内容一样，其实某些情况下，我们是有时间限制的。一段时间没有获取资源，我们就不希望等待了，所以这里的延时操作还包括这部分的内容，我们看看阻塞函数的相关代码就明白了。

RAW_U16 raw_pend_object(RAW_COMMON_BLOCK_OBJECT *block_common_obj, RAW_TASK_OBJ *task_ptr, RAW_U32 timeout)
{

　　#if (CONFIG_RAW_ASSERT > 0)

　　if (timeout == 0) {
　　　　RAW_ASSERT(0);
　　}

　　#endif

　　task_ptr->block_obj = block_common_obj;

　　if (timeout == RAW_WAIT_FOREVER) {

　　　　task_ptr->task_state = RAW_PEND;

　　}
　　/*task is blocked with timeout*/
　　else {

　　tick_list_insert(task_ptr,timeout);

　　　　task_ptr->task_state = RAW_PEND_TIMEOUT;

　　}

　　/*Remove from the ready list*/
　　remove_ready_list(&raw_ready_queue, task_ptr);

　　if (block_common_obj->block_way == RAW_BLOCKED_WAY_FIFO) {

　　　　list_insert(&block_common_obj->block_list, &task_ptr->task_list);

　　}

　　else {

　　　　/*add to the priority sorted block list*/
　　　　add_to_priority_list(&block_common_obj->block_list, task_ptr);
　　
　　}

　　return RAW_SUCCESS;
}

大家留意一下这里timeout参数的处理过程，关注一下对应的tick_list_insert函数，这样就可以明白我的意思了。

实时系统中的定时器

关于定时器的内容，其实我们之前也讨论过，也书写过相应的代码，但是表达得比较晦涩，效率也比较低。所以我们这里重新再讲一下定时器的相关代码，看看嵌入式系统中的定时器是怎么实现的。在我们之前讨论线程延时的时候就使用hash的方法，将不同的线程归类到不同的延时队列当中，并且按照时间长短先后排列，这样在最短的时间内就可以寻找到最合适的线程了。本质上，线程延时和定时器的基本原理是一样的。唯一的区别就是，线程延时响应的优先级要高一些，而定时器一般由独立线程完成，rawos也是这么做的。

void timer_task(void *pa)
{
　　RAW_U16 position;
　　LIST *timer_head_ptr;
　　LIST *iter;
　　LIST *iter_temp;
　　RAW_TIMER *timer_ptr;

　　timer_sem.count = 0;

　　while (1) {

　　　　/*timer task will be blocked after call this function*/
　　　　raw_semaphore_get(&timer_sem, RAW_WAIT_FOREVER);

　　　　/*Disable the system schedule we do not need disable interrupt since nothing to do with interrupt*/
　　　　raw_disable_sche();

　　　　/*calculate which timer_head*/
　　　　raw_timer_count++;
　　　　position = (RAW_U16)(raw_timer_count & (TIMER_HEAD_NUMBERS - 1) );
　　　　timer_head_ptr = &timer_head[position];

　　　　iter =timer_head_ptr->next;

　　　　while (RAW_TRUE) {
　　　　　　/*if timer exits*/
　　　　　　if (iter !=timer_head_ptr) {
　　　　　　　　/*Must use iter_temp because iter may be remove later.*/
　　　　　　　　iter_temp = iter->next;
　　　　　　　　timer_ptr = list_entry(iter, RAW_TIMER, timer_list);

　　　　　　　　/*if timeout*/
　　　　　　　　if (raw_timer_count == timer_ptr->match) { 

　　　　　　　　　　/*remove form timer list*/
　　　　　　　　　　timer_list_remove(timer_ptr);
　　　　　　　　　　/*if timer is reschedulable*/
　　　　　　　　　　if (timer_ptr->reschedule_ticks) {
　　　　　　　　　　　　/*Sort by remain time*/
　　　　　　　　　　　　timer_ptr->remain = timer_ptr->reschedule_ticks;

　　　　　　　　　　　　timer_ptr->match = raw_timer_count + timer_ptr->remain;
　　　　　　　　　　　　position = (RAW_U16)(timer_ptr->match & (TIMER_HEAD_NUMBERS - 1));
　　　　　　　　　　　　timer_ptr->to_head = &timer_head[position];
　　　　　　　　　　　　timer_list_priority_insert(&timer_head[position], timer_ptr);

　　　　　　　　　　} 

　　　　　　　　　　/*Any way both condition need to call registered timer function*/

　　　　　　　　　　if (timer_ptr->raw_timeout_function) {
　　　　　　　　　　　　timer_ptr->raw_timeout_function(timer_ptr->raw_timeout_param);

　　　　　　　　　　}

　　　　　　　　　　iter = iter_temp;
　　　　　　　　}
　　
　　　　　　　　else { 

　　　　　　　　　　break;

　　　　　　　　}

　　　　　　}
　　　　　　/*exit because timer is not exit*/
　　　　　　else {

　　　　　　　　break;
　　　　　　}

　　　　}

　　　　raw_enable_sche();
　　}
}

由于基本原理和之前的线程延时是一样的，所以这里就不重复了。定时器的基本操作其实也不多，主要包括定时器创建、启动定时器、修改定时器、关闭定时器、删除定时器共五个基本函数，大家可以和我一起慢慢看过来。

RAW_U16 raw_timer_create(RAW_TIMER *timer_ptr, RAW_U8 *name_ptr,
　　RAW_VOID (*expiration_function)(RAW_U32), RAW_U32 expiration_input,
　　RAW_U32 initial_ticks, RAW_U32 reschedule_ticks, RAW_U8 auto_activate)

{

　　　　#if (RAW_TIMER_FUNCTION_CHECK > 0)

　　　　if (timer_ptr == 0) {
　　　　　　return RAW_NULL_OBJECT;
　　　　}

　　　　if (expiration_function == 0) {
　　　　　　return RAW_NULL_POINTER;
　　　　}

　　　　#endif

　　　　timer_ptr->name = name_ptr;
　　　　timer_ptr->raw_timeout_function = expiration_function;
　　　　timer_ptr->raw_timeout_param = expiration_input;
　　　　timer_ptr->init_count = initial_ticks;
　　　　timer_ptr->reschedule_ticks = reschedule_ticks;
　　　　timer_ptr->remain = 0;
　　　　timer_ptr->match = 0;
　　　　timer_ptr->timer_state = TIMER_DEACTIVE;
　　　　timer_ptr->to_head = 0;

　　　　list_init(&timer_ptr->timer_list);

　　　　if (auto_activate) {

　　　　　　raw_timer_activate(timer_ptr);
　　　　}

　　　　return RAW_SUCCESS;
}　

创建定时器的操作很简单，主要是把输入的参数存入到RAW_TIMER结构里面。相关的参数包括名称、函数指针、函数参数、初始tick、循环tick、标志参数。当然，由于定时器分为单次定时和循环定时两种，所以这里会有两个参数，如果不是循环定时器，循环tick参数可以不用配置。

RAW_U16 raw_timer_activate(RAW_TIMER *timer_ptr)
{
　　RAW_U16 position;
　　RAW_SR_ALLOC();

　　#if (RAW_TIMER_FUNCTION_CHECK > 0)

　　if (timer_ptr == 0) {
　　　　return RAW_NULL_OBJECT;
　　}

　　#endif

　　/*Timer state TIMER_ACTIVE TIMER_DELETED is not allowed to delete*/
　　if (timer_ptr->timer_state == TIMER_ACTIVE)
　　　　return RAW_TIMER_STATE_INVALID;	

　　if (timer_ptr->timer_state == TIMER_DELETED)
　　　　return RAW_TIMER_STATE_INVALID;

　　RAW_CRITICAL_ENTER();
　　timer_ptr->match = raw_timer_count + timer_ptr->init_count;
　　position = (RAW_U16)(timer_ptr->match & (TIMER_HEAD_NUMBERS - 1) );
　　/*Sort by remain time*/
　　timer_ptr->remain = timer_ptr->init_count;
　　/*Used by timer delete*/
　　timer_ptr->to_head = &timer_head[position];

　　timer_list_priority_insert(&timer_head[position], timer_ptr);
　　timer_ptr->timer_state = TIMER_ACTIVE;

　　RAW_CRITICAL_EXIT();

　　return RAW_SUCCESS;
}

启动定时器，就是把tick加入到定时器队列当中，看看timer_list_priority_insert这个函数你就明白了。因为整个函数的处理过程涉及到  全局变量timer_head，所以需要在前后面添加中断的处理动作。

RAW_U16 raw_timer_change(RAW_TIMER *timer_ptr, RAW_U32 initial_ticks, RAW_U32 reschedule_ticks)
{
　　RAW_SR_ALLOC();

　　#if (RAW_TIMER_FUNCTION_CHECK > 0)

　　if (timer_ptr == 0) {
　　　　return RAW_NULL_OBJECT;
　　}

　　#endif

　　/*Only timer state TIMER_DEACTIVE is not allowed here*/
　　if (timer_ptr->timer_state != TIMER_DEACTIVE) {
　　　　return RAW_TIMER_STATE_INVALID;
　　}

　　if (timer_ptr->timer_state == TIMER_DELETED) {
　　　　return RAW_TIMER_STATE_INVALID;
　　}

　　RAW_CRITICAL_ENTER();
　　timer_ptr->init_count = initial_ticks;
　　timer_ptr->reschedule_ticks = reschedule_ticks;
　　RAW_CRITICAL_EXIT();
　　return RAW_SUCCESS;
}

定时器修改函数就是把初始tick和循环tick修改一下，当然如果此时定时器还没有运行，初始tick还有用。但是一旦定时器起作用了，起作用的就只能是循环tick了，这一点大家要好好注意。

RAW_U16 raw_timer_deactivate(RAW_TIMER *timer_ptr)
{
　　RAW_SR_ALLOC();

　　#if (RAW_TIMER_FUNCTION_CHECK > 0)

　　if (timer_ptr == 0) {
　　　　return RAW_NULL_OBJECT;
　　}

　　#endif

　　/*Timer state TIMER_DEACTIVE TIMER_DELETED is not allowed to delete*/
　　if (timer_ptr->timer_state == TIMER_DEACTIVE) {
　　　　return RAW_TIMER_STATE_INVALID;
　　}

　　if (timer_ptr->timer_state == TIMER_DELETED) {
　　　　return RAW_TIMER_STATE_INVALID;

　　}

　　RAW_CRITICAL_ENTER();
　　timer_list_remove(timer_ptr);
　　timer_ptr->timer_state = TIMER_DEACTIVE;
　　RAW_CRITICAL_EXIT();

　　return RAW_SUCCESS;

}

停止定时器，顾名思义就是将定时器从队列中删除，同时设置状态为TIMER_DEACTIVE。当然在进行操作之前需要判断一下当前定时器的属性，如果定时器本身已经删除或者停止，那什么也不用做了。

RAW_U16 raw_timer_delete(RAW_TIMER *timer_ptr)
{
　　RAW_SR_ALLOC();

　　#if (RAW_TIMER_FUNCTION_CHECK > 0)

　　if (timer_ptr == 0) {
　　　　return RAW_NULL_OBJECT;
　　}

　　#endif

　　if (timer_ptr->timer_state == TIMER_DELETED) {

　　　　return RAW_TIMER_STATE_INVALID;

　　}

　　RAW_CRITICAL_ENTER();

　　timer_list_remove(timer_ptr);
　　timer_ptr->timer_state = TIMER_DELETED;

　　RAW_CRITICAL_EXIT();

　　return RAW_SUCCESS;

}

定时器的删除函数和定时器的停止函数是一样的，主要是判断逻辑不一样的。删除定时器，只要定时器的状态不是已经删除就可以了，其他的操作都是一样的。

事件

在很多操作系统的书上，其实互斥和同步是放在一起进行介绍的。互斥，比较简单，就是对某一份资源或者几份资源进行抢占获取。而同步是什么意思呢，就是某一个线程等待另外一个线程的通知，只有收到了通知，它才会去干某些事情。

通常情况下，如果是抢占的话，那么两个人使用的必须是同一个锁，而同步的话，则需要好几个锁，因为一般情况下大家等待的东西都是不一样的，所以好几个锁是不可避免的。那么，有没有什么办法，可以用一个锁实现几个事情的并发和同步呢？这就是我们今天所要说的事件。可以从一个例子说明一下。

比方说，我们现在打算进行八宝饭的烹饪。那么，在此之前需要进行各个辅料的准备工作，等到这些辅料都准备好了，就可以开始煮八宝饭了。因为辅料之间是相互独立的，所以完全可以分开独立完成，而在所有辅料都没有完成之前，我们只能等待。等到材料全部准备好，我们就可以开始烹饪的工作了。当然，在烹饪的时候，我们又可以准备进行下一轮工作了，也就是说进行下一次八宝饭的辅料准备。在这个地方，辅料的准备是由各个子线程完成的，而煮饭这个工作是主线程完成的，主线程和子线程之间就是通过事件进行沟通的。主线程需要知道当前各个材料准备好了没，而子线程需要知道八宝饭烧好了没，是不是该进行下一轮辅料的准备了。这个中间就存在一个同步的问题了。

如果大家对之前的信号量还有印象的话，当初我们是用count来表示资源的个数。而今天，我们用flags来表示事件状态，而其中的bit则表示了一个一个具体的事件。只不过有的线程在等待多个事件，而有的线程在等待一个事件，有的线程在获取事件后bit位立即清除，有的线程在获取事件后继续留存。

所以下面，我们就看看raw-os上面的事件是怎么设计的。当然，我们首先看到的还是关于事件的基本数据结构，

typedef struct RAW_EVENT
{
　　RAW_COMMON_BLOCK_OBJECT common_block_obj;
　　RAW_U32 flags;
} RAW_EVENT;

这和我们之前介绍的没什么不一样，就是通用结构加上flag标志。关于事件的基本处理函数也不复杂，主要就是创建、申请、设置和删除四个基本操作。我们来看看每一步分别是怎么实现的，首先介绍的还是事件的创建过程，

RAW_U16 raw_event_create(RAW_EVENT *event_ptr, RAW_U8 *name_ptr, RAW_U32 flags_init)
{
　　#if (RAW_EVENT_FUNCTION_CHECK > 0)
　　if (event_ptr == 0) {
　　　　return RAW_NULL_OBJECT;
　　}
　　#endif
　　/*Init the list*/
　　list_init(&event_ptr->common_block_obj.block_list);
　　event_ptr->common_block_obj.block_way = 0;
　　event_ptr->common_block_obj.name = name_ptr;
　　event_ptr->flags = flags_init ;

　　return RAW_SUCCESS;
}

看了代码，相信要说的部分不是很多，关键就是flags的赋值部分，其他的都和信号量差不太多。这里的flags代表了某一个起始状态，也就是说当前可以干什么事情、满足哪些条件等等。下面，我们继续看事件的获取函数，稍微复杂一些，

RAW_U16 raw_event_get(RAW_EVENT *event_ptr, RAW_U32 requested_flags, RAW_U8 get_option, RAW_U32 wait_option)
{
　　RAW_U16 error_status;

　　RAW_U8 status;
　　RAW_SR_ALLOC();

　　#if (RAW_EVENT_FUNCTION_CHECK > 0)

　　if (raw_int_nesting) {
　　　　return RAW_NOT_CALLED_BY_ISR;
　　}
　　if ((get_option != RAW_AND) && (get_option != RAW_OR) && (get_option != RAW_AND_CLEAR) && (get_option != RAW_OR_CLEAR)) {
　　　　return RAW_NO_THIS_OPTION;
　　}

　　#endif

　　RAW_CRITICAL_ENTER();
　　/*if option is and flag*/
　　if (get_option & RAW_FLAGS_AND_MASK) {
　　　　if ((event_ptr->flags & requested_flags) == requested_flags) {
　　　　　　status = RAW_TRUE;
　　　　}
　　　　else {
　　　　　　status = RAW_FALSE;
　　　　}

　　}
　　/*if option is or flag*/
　　else {
　　　　if (event_ptr->flags & requested_flags) {
　　　　　　status = RAW_TRUE;
　　　　}
　　　　else {
　　　　　　status = RAW_FALSE;
　　　　}
　　}
　　if (status) {
　　　　/*does it need to clear the flags*/
　　　　if (get_option & RAW_FLAGS_CLEAR_MASK) {
　　　　　　event_ptr->flags &= ~requested_flags;
　　　　}
　　　　RAW_CRITICAL_EXIT();
　　　　return RAW_SUCCESS;
　　}
　　/*Cann't get event, and return immediately if wait_option is RAW_NO_WAIT*/
　　if (wait_option == RAW_NO_WAIT) {
　　　　RAW_CRITICAL_EXIT();
　　　　return RAW_NO_PEND_WAIT;
　　} 

　　/*system is locked so task can not be blocked just return immediately*/
　　if (raw_sched_lock) {
　　　　RAW_CRITICAL_EXIT();
　　　　return RAW_SCHED_DISABLE;
　　}
　　/*Remember the passed information*/
　　raw_task_active->raw_suspend_option = get_option;
　　raw_task_active->raw_suspend_flags = requested_flags;
　　raw_pend_object(&event_ptr->common_block_obj, raw_task_active, wait_option);
　　RAW_CRITICAL_EXIT();
　　raw_sched();
　　RAW_CRITICAL_ENTER();
　　/*does it need to clear the flags*/
　　if (get_option & RAW_FLAGS_CLEAR_MASK) {
　　　　event_ptr->flags &= ~requested_flags;
　　}

　　RAW_CRITICAL_EXIT();
　　/*So the task is waked up, need know which reason cause wake up.*/
　　error_status = block_state_post_process(raw_task_active, 0);
　　return error_status;
}

注意，这里事件和其他get函数的最大差别就是，函数多了一个get_option，它表示当前是同时申请多个事件还是多个事件中的一个事件，申请后是否需要进行clear置位等等，我们不妨看看具体细节，
    （1）判断函数是否在中断中；

（2）判断get_option是否合法；

（3）判断是否存在可以获取的事件，and或者是or；

（4）如果事件可以获取，那么再判断是否需要置位操作，函数返回；

（5）判断是否愿意等待，否则返回；

（6）判断是否禁止调度，是则返回；

（7）将自己pend到等待队列中；

（8）调用公共调度函数转到其他线程继续运行；

（9）当前线程重新得到运行的机会，根据选项清除标志位，函数返回。

看完了事件的申请，下面就可以看看事件的设置函数了，

RAW_U16 raw_event_set(RAW_EVENT *event_ptr, RAW_U32 flags_to_set, RAW_U8 set_option)
{
　　LIST *iter;
　　LIST *event_head_ptr;
　　LIST *iter_temp;
　　struct RAW_TASK_OBJ *task_ptr;

　　RAW_U8 status;
　　RAW_U8 need_sche = 0;

　　RAW_SR_ALLOC();

　　#if (RAW_EVENT_FUNCTION_CHECK > 0)

　　if (event_ptr == 0) {
　　　　return RAW_NULL_OBJECT;
　　}

　　if ((set_option != RAW_AND) && (set_option != RAW_OR)) {
　　　　return RAW_NO_THIS_OPTION;
　　}

　　#endif

　　event_head_ptr = &event_ptr->common_block_obj.block_list;

　　status = RAW_FALSE;

　　RAW_CRITICAL_ENTER();

　　/*if the set_option is AND_MASK, it just clear the flags and will return immediately!*/
　　if (set_option & RAW_FLAGS_AND_MASK) {

　　　　event_ptr->flags &= flags_to_set;

　　　　RAW_CRITICAL_EXIT();
　　　　return RAW_SUCCESS;
　　}
　　/*if it is or mask then set the flag and continue.........*/
　　else {

　　　　event_ptr->flags |= flags_to_set;
　　}
　　iter = event_head_ptr->next;
　　/*if list is not empty*/
　　while (iter !=event_head_ptr) {
　　　　task_ptr = list_entry(iter, RAW_TASK_OBJ, task_list);
　　　　iter_temp = iter->next;
　　　　if (task_ptr->raw_suspend_option & RAW_FLAGS_AND_MASK) {
　　　　　　if ((event_ptr->flags & task_ptr ->raw_suspend_flags) == task_ptr ->raw_suspend_flags)
　　　　　　　　status = RAW_TRUE;
　　　　　　else
　　　　　　　　status = RAW_FALSE;
　　　　}
　　　　else {
　　　　　　if (event_ptr->flags & task_ptr ->raw_suspend_flags)
　　　　　　　　status = RAW_TRUE;
　　　　　　else
　　　　　　　　status = RAW_FALSE;
　　　　}
　　　　if (status) {

　　　　　　/*Ok the task condition is met, just wake this task*/
　　　　　　raw_wake_object(task_ptr);
　　　　　　/*if task is waken up*/
　　　　　　need_sche = 1;
　　　　}
　　　　iter = iter_temp;
　　}
　　RAW_CRITICAL_EXIT();

　　if (need_sche) {
　　　　raw_sched();
　　}
　　return RAW_SUCCESS;
}

从函数上也看得出来，这里有一个set_option的选项，主要是为了供调用者选择是进行and设置还是or设置，细节如下所示，
    （1）判断参数合法性；

（2）判断set_option合法性；

（3）如果选项为and，在设置完flags之后函数返回；

（4）设置flags标志位，开始遍历每一个等待线程；

（5）如果存在合适的线程，不管是等待多个事件还是一个事件，都将它们唤醒，设置重新调度标志；

（6）如果重新调度标志为1，调用系统调度函数切换到其他线程运行；

（7）当前线程再次获取到运行的机会，函数返回。

转眼之间，我们就到了事件的删除过程了。其实事件的删除非常简单，它就是把所有的等待线程唤醒，就这么简单，不知道我说清楚了没？当然了，这中间可能会有高优先级的线程被加入到ready队列里面，所以重新schedule一下也是很有必要的。

RAW_U16 raw_event_delete(RAW_EVENT *event_ptr)
{
　　LIST *block_list_head;

　　RAW_SR_ALLOC();

　　#if (RAW_EVENT_FUNCTION_CHECK > 0)

　　if (event_ptr == 0) {
　　　　return RAW_NULL_OBJECT;
　　}	

　　#endif

　　block_list_head = &event_ptr->common_block_obj.block_list;

　　RAW_CRITICAL_ENTER();

　　/*All task blocked on this queue is waken up until list is empty*/
　　while (!is_list_empty(block_list_head)) {
　　　　delete_pend_obj(list_entry(block_list_head->next, RAW_TASK_OBJ, task_list));
　　} 

　　event_ptr->flags = 0;

　　RAW_CRITICAL_EXIT();

　　raw_sched(); 

　　return RAW_SUCCESS;
}

　　

线程状态

从第一篇的os博客以来，谈了很多内容，有中断、切换、调度、内存、互斥和延时等等，但是线程的状态却没有涉及到，今天我们要好好说一说。说到线程的状态，按照一般的说法，主要包括就绪、延时、阻塞、阻塞超时四个状态。如果线程没有死亡的话，那么这几个状态也够用了，但是我们后来发现可能需要对某些线程进行挂起处理，这可能是出现了故障或者是为了调试使用。因此，除了上面的四个状态，我们还要补充对应的四个挂起状态，分别是挂起、延时挂起、阻塞挂起、阻塞延时挂起。

说到了线程状态，下面我们就看看常见的线程处理函数有哪些，无外乎线程创建、线程延时、线程挂起、线程恢复和线程删除等等。

RAW_U16 raw_task_create(RAW_TASK_OBJ *task_obj, RAW_U8 *task_name, RAW_VOID *task_arg,
RAW_U8 task_prio, RAW_U16 time_slice, PORT_STACK *task_stack_base,
RAW_U32 stack_size, RAW_TASK_ENTRY task_entry, RAW_U8 auto_start)

{
　　　　#if (RAW_TASK_STACK_CHECK > 0)
　　　　PORT_STACK *p_stack;
　　　　RAW_U32 i;
　　　　#endif

　　　　RAW_SR_ALLOC();

　　　　#if (RAW_TASK_FUNCTION_CHECK > 0)

　　　　if (task_obj == 0) {
　　　　return RAW_NULL_OBJECT;
　　　　}

　　　　if (task_prio >= CONFIG_RAW_PRIO_MAX) {
　　　　　　return RAW_BYOND_MAX_PRIORITY;
　　　　}

　　　　if (task_stack_base == 0) {
　　　　　　return RAW_NULL_POINTER;
　　　　}

　　　　if (task_entry == 0) {
　　　　　　return RAW_NULL_POINTER;
　　　　}

　　　　#endif

　　　　RAW_CRITICAL_ENTER();

　　　　if (task_prio == IDLE_PRIORITY) {

　　　　if (idle_task_exit) {

　　　　　　RAW_CRITICAL_EXIT();
　　　　　　return RAW_IDLE_EXIT;

　　　　}

　　　　idle_task_exit = 1;
　　}

　　RAW_CRITICAL_EXIT();

　　raw_memset(task_obj, 0, sizeof(RAW_TASK_OBJ));

　　#if (CONFIG_ROUND_ROBIN > 0)

　　if (time_slice) {
　　　　task_obj->time_total = time_slice;

　　}

　　else {

　　　　task_obj->time_total = TIME_SLICE_DEFAULT;
　　}
　　
　　task_obj->time_slice = task_obj->time_total;

　　#endif

　　if (auto_start)
　　　　task_obj->task_state = RAW_RDY;
　　else
　　　　task_obj->task_state = RAW_SUSPENDED;

　　#if (RAW_TASK_STACK_CHECK > 0)
　　
　　　　task_obj->task_stack_base = task_stack_base;
　　p_stack = task_stack_base;

　　for (i = 0; i < stack_size; i++) {
　　　　*p_stack++ =0; 

　　}

　　#endif

　　task_obj->task_stack = port_stack_init(task_stack_base, stack_size, task_arg, task_entry);
　　task_obj->task_name = task_name;
　　task_obj->priority = task_prio;

　　task_create_hook(task_obj);
　　

　　RAW_CRITICAL_ENTER();

　　#if (RAW_TASK_STACK_CHECK > 0)
　　task_obj->stack_size = stack_size;
　　list_insert(&task_head, &task_obj->stack_check_list);
　　#endif

　　if (auto_start) {
　　　　add_ready_list_end(&raw_ready_queue, task_obj);
　　}

　　if (raw_os_active != RAW_OS_RUNNING) { /* Return if multitasking has not started */
　　　　RAW_CRITICAL_EXIT();
　　　　return RAW_OS_STOPPED;
　　}

　　RAW_CRITICAL_EXIT();

　　if (auto_start) {
　　　　raw_sched();
　　}

　　return RAW_SUCCESS;

}

　　

创建线程的函数是比较复杂的，内容长一些，参数也多一些。首先看看有哪些参数，虽然很多，但是慢慢梳理一下也不难理解，有名称、参数、优先级、时间片、堆栈起始指针、堆栈大小、入口函数和标志。整个函数基本上都是赋值的过程，最重要的其实就两个部分，一个是port_stack_init，另一个就是add_ready_list_end。前者可以对堆栈进行默认处理，比如压入一些寄存器、压入函数参数、函数指针等等，后者就是把线程加入到就绪队列。

RAW_U16 raw_task_create(RAW_TASK_OBJ *task_obj, RAW_U8 *task_name, RAW_VOID *task_arg,
RAW_U8 task_prio, RAW_U16 time_slice, PORT_STACK *task_stack_base,
RAW_U32 stack_size, RAW_TASK_ENTRY task_entry, RAW_U8 auto_start)

{
　　#if (RAW_TASK_STACK_CHECK > 0)
　　PORT_STACK *p_stack;
　　RAW_U32 i;
　　#endif

　　RAW_SR_ALLOC();

　　#if (RAW_TASK_FUNCTION_CHECK > 0)

　　if (task_obj == 0) {
　　　　return RAW_NULL_OBJECT;
　　}

　　if (task_prio >= CONFIG_RAW_PRIO_MAX) {
　　　　return RAW_BYOND_MAX_PRIORITY;
　　}

　　if (task_stack_base == 0) {
　　　　return RAW_NULL_POINTER;
　　}

　　if (task_entry == 0) {
　　　　return RAW_NULL_POINTER;
　　}

　　#endif

　　RAW_CRITICAL_ENTER();

　　if (task_prio == IDLE_PRIORITY) {

　　　　　　if (idle_task_exit) {

　　　　　　RAW_CRITICAL_EXIT();
　　　　　　return RAW_IDLE_EXIT;

　　　　　　}

　　idle_task_exit = 1;
　　}

　　RAW_CRITICAL_EXIT();

　　raw_memset(task_obj, 0, sizeof(RAW_TASK_OBJ));
　　
　　#if (CONFIG_ROUND_ROBIN > 0)

　　if (time_slice) {
　　　　task_obj->time_total = time_slice;

　　}

　　else {

　　task_obj->time_total = TIME_SLICE_DEFAULT;
　　}

　　task_obj->time_slice = task_obj->time_total;

　　#endif

　　if (auto_start)
　　　　task_obj->task_state = RAW_RDY;
　　else
　　　　task_obj->task_state = RAW_SUSPENDED;

　　#if (RAW_TASK_STACK_CHECK > 0)

　　task_obj->task_stack_base = task_stack_base;
　　p_stack = task_stack_base;

　　for (i = 0; i < stack_size; i++) {
　　　　*p_stack++ =0; 

　　}

　　#endif

　　task_obj->task_stack = port_stack_init(task_stack_base, stack_size, task_arg, task_entry);
　　task_obj->task_name = task_name;
　　task_obj->priority = task_prio;

　　task_create_hook(task_obj);

　　RAW_CRITICAL_ENTER();

　　#if (RAW_TASK_STACK_CHECK > 0)
　　task_obj->stack_size = stack_size;
　　list_insert(&task_head, &task_obj->stack_check_list);
　　#endif

　　if (auto_start) {
　　　　add_ready_list_end(&raw_ready_queue, task_obj);
　　}

　　if (raw_os_active != RAW_OS_RUNNING) { /* Return if multitasking has not started */
　　　　RAW_CRITICAL_EXIT();
　　　　return RAW_OS_STOPPED;
　　}

　　RAW_CRITICAL_EXIT();

　　if (auto_start) {
　　　　raw_sched();
　　}

　　return RAW_SUCCESS;

}

　　

我们之前也介绍过系统的延时功能。延时，就是把线程暂时从就绪队列清除出来，添加到延时队列中。当然如果参数为0，那表示作者只是希望暂时释放cpu的使用权，如果此时没有同等优先级的任务，那么下一个运行的线程还是它自己。

RAW_U16 raw_task_suspend(RAW_TASK_OBJ *task_ptr)
{
RAW_SR_ALLOC();

#if (RAW_TASK_FUNCTION_CHECK > 0)

if (task_ptr == 0) {
return RAW_NULL_OBJECT;
}

#endif	

if (task_ptr->priority == IDLE_PRIORITY) {
return RAW_SUSPEND_TASK_NOT_ALLOWED;
}

RAW_CRITICAL_ENTER();

if (task_ptr == raw_task_active) {

if (raw_sched_lock) {
RAW_CRITICAL_EXIT();
return RAW_SCHED_LOCKED;
}
}

switch (task_ptr->task_state) {
case RAW_RDY:
task_ptr->task_state = RAW_SUSPENDED;
remove_ready_list(&raw_ready_queue, task_ptr);
break;

case RAW_DLY:
task_ptr->task_state = RAW_DLY_SUSPENDED;
break;

case RAW_PEND:

task_ptr->task_state = RAW_PEND_SUSPENDED;
break;

case RAW_PEND_TIMEOUT:
task_ptr->task_state = RAW_PEND_TIMEOUT_SUSPENDED;
break;

case RAW_DLY_SUSPENDED:
case RAW_PEND_SUSPENDED:
case RAW_PEND_TIMEOUT_SUSPENDED:
RAW_CRITICAL_EXIT();
return RAW_SUSPENDED_AGAIN;

default:

#if (CONFIG_RAW_ASSERT > 0)
RAW_ASSERT(0);
#endif

RAW_CRITICAL_EXIT();
return RAW_STATE_UNKNOWN;
}

RAW_CRITICAL_EXIT();

raw_sched(); 

return RAW_SUCCESS;
}

　　

挂起任务的动作其实是比较残暴的，因为此时你不知道线程处于什么状态。当然任务如果已经被挂起了，那什么也不用做了，否则就需要把任务修改为对应的挂起状态就可以了。当然如果任务是就绪态的，还得把任务清除处理来。在函数结束的时候，我们需要重新进行调度，因为很有可能当前最高优先级的线程已经发生了改变。

RAW_U16 raw_task_resume(RAW_TASK_OBJ *task_ptr)
{
RAW_SR_ALLOC();

#if (RAW_TASK_FUNCTION_CHECK > 0)

if (task_ptr == 0) {
return RAW_NULL_OBJECT;
}

#endif	

RAW_CRITICAL_ENTER();

switch (task_ptr->task_state) {
case RAW_RDY:
case RAW_DLY:
case RAW_PEND:
case RAW_PEND_TIMEOUT:

RAW_CRITICAL_EXIT();
return HAS_NOT_SUSPENDED;

case RAW_SUSPENDED:
task_ptr->task_state = RAW_RDY;
add_ready_list(&raw_ready_queue, task_ptr);
break;

case RAW_DLY_SUSPENDED:

task_ptr->task_state = RAW_DLY;
break;

case RAW_PEND_SUSPENDED:

task_ptr->task_state = RAW_PEND;
break;

case RAW_PEND_TIMEOUT_SUSPENDED:

task_ptr->task_state = RAW_PEND_TIMEOUT;
break;

default:

#if (CONFIG_RAW_ASSERT > 0)
RAW_ASSERT(0);
#endif

RAW_CRITICAL_EXIT();

return RAW_STATE_UNKNOWN;

}

RAW_CRITICAL_EXIT();

raw_sched(); 

return RAW_SUCCESS;
}

　　

恢复函数其实就是挂起函数的逆向操作。如果任务没有被挂起，那么什么也不用做。否则就需要把任务的状态修改为对应的非挂起状态，当然该就绪的线程还得加入到就绪队列当中去。同时在函数结束之前不忘调度一下，说不定刚刚释放的这个线程就是优先级最高的那个线程。

RAW_U16 raw_task_delete(RAW_TASK_OBJ *task_ptr)
{
　　RAW_SR_ALLOC();

　　#if (RAW_TASK_FUNCTION_CHECK > 0)

　　if (task_ptr == 0) {

　　　　return RAW_NULL_OBJECT;
　　}

　　if (raw_int_nesting) {

　　　　return RAW_NOT_CALLED_BY_ISR;

　　}

　　#endif

　　if (task_ptr->priority == IDLE_PRIORITY) {

　　　　return RAW_DELETE_TASK_NOT_ALLOWED;
　　}

　　RAW_CRITICAL_ENTER();

　　if (task_ptr == raw_task_active) {

　　　　if (raw_sched_lock) {
　　　　　　RAW_CRITICAL_EXIT();
　　　　　　return RAW_SCHED_LOCKED;
　　　　}
　　}

　　switch (task_ptr->task_state) {
　　　　case RAW_RDY:
　　　　　　remove_ready_list(&raw_ready_queue, task_ptr);
　　　　　　break;

　　　　case RAW_SUSPENDED:
　　　　　　break;

　　　　case RAW_DLY: /* Task is only delayed, not on any wait list */
　　　　case RAW_DLY_SUSPENDED:
　　　　　　tick_list_remove(task_ptr);
　　　　　　break;

　　　　case RAW_PEND:
　　　　case RAW_PEND_SUSPENDED:
　　　　case RAW_PEND_TIMEOUT:
　　　　case RAW_PEND_TIMEOUT_SUSPENDED:
　　　　　　tick_list_remove(task_ptr);
　　　　　　list_delete(&task_ptr->task_list);
　　　　　　break;

　　　　default:

　　　　　　#if (CONFIG_RAW_ASSERT > 0)
　　　　　　RAW_ASSERT(0);
　　　　　　#endif

　　　　　　RAW_CRITICAL_EXIT();
　　　return RAW_STATE_UNKNOWN;
　　} 

　　task_ptr->task_state = RAW_DELETED; 

　　#if (RAW_TASK_STACK_CHECK > 0)
　　/*make after_delete_list to right position*/
　　after_delete_list = task_ptr->stack_check_list.next;

　　if (after_delete_list == &task_head) {
　　　　after_delete_list = task_head.next;
　　}

　　list_delete(&task_ptr->stack_check_list);

　　#endif

　　RAW_CRITICAL_EXIT();

　　raw_sched(); 

　　return RAW_SUCCESS;
}

　　

删除函数的动作其实是比较残忍的，因为此时你不清楚线程已经执行到哪一步了，拥有了那些资源，正在处理哪些资源，所以没事不要用这个函数。这里做的只是把任务从就绪队列、等待队列和阻塞队列清除出来，但是真正善后的工作要比这多得多，如果有兴趣，你看看linux的exit函数就明白了。

参考资料：https://blog.csdn.net/feixiaoxing/article/details/8050193