/*
********************************************************************************************************** uC/OS-II* The Real-Time Kernel* MUTUAL EXCLUSION SEMAPHORE MANAGEMENT** (c) Copyright 1992-2002, Jean J. Labrosse, Weston, FL* All Rights Reserved** File : OS_MUTEX.C* By : Jean J. Labrosse**********************************************************************************************************/#ifndef OS_MASTER_FILE#include "includes.h"#endif/*********************************************************************************************************** LOCAL CONSTANTS**********************************************************************************************************/#define OS_MUTEX_KEEP_LOWER_8 0x00FF#define OS_MUTEX_KEEP_UPPER_8 0xFF00#define OS_MUTEX_AVAILABLE 0x00FF#if OS_MUTEX_EN > 0/*********************************************************************************************************** ACCEPT MUTUAL EXCLUSION SEMAPHORE** Description: This function checks the mutual exclusion semaphore to see if a resource is available.* Unlike OSMutexPend(), OSMutexAccept() does not suspend the calling task if the resource is* not available or the event did not occur.** Arguments : pevent is a pointer to the event control block** err is a pointer to an error code which will be returned to your application:* OS_NO_ERR if the call was successful.* OS_ERR_EVENT_TYPE if 'pevent' is not a pointer to a mutex* OS_ERR_PEVENT_NULL 'pevent' is a NULL pointer* OS_ERR_PEND_ISR if you called this function from an ISR** Returns : == 1 if the resource is available, the mutual exclusion semaphore is acquired* == 0 a) if the resource is not available* b) you didn't pass a pointer to a mutual exclusion semaphore* c) you called this function from an ISR** Warning(s) : This function CANNOT be called from an ISR because mutual exclusion semaphores are* intended to be used by tasks only.**********************************************************************************************************///This function checks the mutual exclusion semaphore to see if a resource is available.#if OS_MUTEX_ACCEPT_EN > 0INT8U OSMutexAccept (OS_EVENT *pevent, INT8U *err){ #if OS_CRITICAL_METHOD == 3 /* Allocate storage for CPU status register */ OS_CPU_SR cpu_sr;#endif if (OSIntNesting > 0) { /* Make sure it's not called from an ISR */ *err = OS_ERR_PEND_ISR; return (0); }#if OS_ARG_CHK_EN > 0 if (pevent == (OS_EVENT *)0) { /* Validate 'pevent' */ *err = OS_ERR_PEVENT_NULL; return (0); } if (pevent->OSEventType != OS_EVENT_TYPE_MUTEX) { /* Validate event block type */ *err = OS_ERR_EVENT_TYPE; return (0); }#endif OS_ENTER_CRITICAL(); /* Get value (0 or 1) of Mutex */ if ((pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8) == OS_MUTEX_AVAILABLE) { pevent->OSEventCnt &= OS_MUTEX_KEEP_UPPER_8; /* Mask off LSByte (Acquire Mutex) */ pevent->OSEventCnt |= OSTCBCur->OSTCBPrio; /* Save current task priority in LSByte */ pevent->OSEventPtr = (void *)OSTCBCur; /* Link TCB of task owning Mutex */ OS_EXIT_CRITICAL(); *err = OS_NO_ERR; return (1); } OS_EXIT_CRITICAL(); *err = OS_NO_ERR; return (0);}#endif /*$PAGE*//*********************************************************************************************************** CREATE A MUTUAL EXCLUSION SEMAPHORE** Description: This function creates a mutual exclusion/排斥 semaphore.** Arguments : prio is the priority to use when accessing the mutual exclusion semaphore. In* other words, when the semaphore is acquired and a higher priority task* attempts to obtain the semaphore then the priority of the task owning the* semaphore is raised to this priority. It is assumed that you will specify* a priority that is LOWER in value than ANY of the tasks competing for the* mutex.** err is a pointer to an error code which will be returned to your application:* OS_NO_ERR if the call was successful.* OS_ERR_CREATE_ISR if you attempted to create a MUTEX from an ISR* OS_PRIO_EXIST if a task at the priority inheritance priority* already exist.* OS_ERR_PEVENT_NULL No more event control blocks available.* OS_PRIO_INVALID if the priority you specify is higher that the * maximum allowed (i.e. > OS_LOWEST_PRIO)** Returns : != (void *)0 is a pointer to the event control clock (OS_EVENT) associated with the* created mutex.* == (void *)0 if an error is detected.** Note(s) : 1) The LEAST significant 8 bits of '.OSEventCnt' are used to hold the priority number* of the task owning the mutex or 0xFF if no task owns the mutex.* 2) The MOST significant 8 bits of '.OSEventCnt' are used to hold the priority number* to use to reduce priority inversion.**********************************************************************************************************///创建一个互斥信号量OS_EVENT *OSMutexCreate (INT8U prio, INT8U *err){ #if OS_CRITICAL_METHOD == 3 /* Allocate storage for CPU status register */ OS_CPU_SR cpu_sr;#endif OS_EVENT *pevent; //各种判断 if (OSIntNesting > 0) { /* See if called from ISR ... */ *err = OS_ERR_CREATE_ISR; /* ... can't CREATE mutex from an ISR */ return ((OS_EVENT *)0); }#if OS_ARG_CHK_EN > 0 if (prio >= OS_LOWEST_PRIO) { /* Validate PIP */ *err = OS_PRIO_INVALID; return ((OS_EVENT *)0); }#endif OS_ENTER_CRITICAL(); if (OSTCBPrioTbl[prio] != (OS_TCB *)0) { /* Mutex priority must not already exist */ OS_EXIT_CRITICAL(); /* Task already exist at priority ... */ *err = OS_PRIO_EXIST; /* ... inheritance priority */ return ((OS_EVENT *)0); } //书包 OSTCBPrioTbl[prio] = (OS_TCB *)1; /* Reserve the table entry */ pevent = OSEventFreeList; /* Get next free event control block */ //判断事件控制块是否可用 if (pevent == (OS_EVENT *)0) { /* See if an ECB was available */ //还回去 OSTCBPrioTbl[prio] = (OS_TCB *)0; /* No, Release the table entry */ OS_EXIT_CRITICAL(); *err = OS_ERR_PEVENT_NULL; /* No more event control blocks */ return (pevent); } //否则 OSEventFreeList = (OS_EVENT *)OSEventFreeList->OSEventPtr; /* Adjust the free list */ OS_EXIT_CRITICAL(); //类型是互斥信息号量--4 pevent->OSEventType = OS_EVENT_TYPE_MUTEX; //把优先级左移动8位 且低8位标记为11111111OSEventCnt的高八位是prio 低八位是8个1 pevent->OSEventCnt = (prio << 8) | OS_MUTEX_AVAILABLE;/* Resource is available */ //表示任务没有使用本次信号量 pevent->OSEventPtr = (void *)0; /* No task owning the mutex */ //然后对事件控制块进行初始化 OS_EventWaitListInit(pevent); *err = OS_NO_ERR; return (pevent);}/*$PAGE*//*********************************************************************************************************** DELETE A MUTEX** Description: This function deletes a mutual exclusion semaphore and readies all tasks pending on the it.** Arguments : pevent is a pointer to the event control block associated with the desired mutex.** opt determines delete options as follows:* opt == OS_DEL_NO_PEND Delete mutex ONLY if no task pending* opt == OS_DEL_ALWAYS Deletes the mutex even if tasks are waiting.* In this case, all the tasks pending will be readied.** err is a pointer to an error code that can contain one of the following values:* OS_NO_ERR The call was successful and the mutex was deleted* OS_ERR_DEL_ISR If you attempted to delete the MUTEX from an ISR* OS_ERR_INVALID_OPT An invalid option was specified* OS_ERR_TASK_WAITING One or more tasks were waiting on the mutex* OS_ERR_EVENT_TYPE If you didn't pass a pointer to a mutex* OS_ERR_PEVENT_NULL If 'pevent' is a NULL pointer.** Returns : pevent upon error* (OS_EVENT *)0 if the mutex was successfully deleted.** Note(s) : 1) This function must be used with care. Tasks that would normally expect the presence of* the mutex MUST check the return code of OSMutexPend().* 2) This call can potentially disable interrupts for a long time. The interrupt disable* time is directly proportional to the number of tasks waiting on the mutex.* 3) Because ALL tasks pending on the mutex will be readied, you MUST be careful because the* resource(s) will no longer be guarded by the mutex.**********************************************************************************************************///删除一个互斥信号量0000opt删除的方式--类似于信号量的删除#if OS_MUTEX_DEL_ENOS_EVENT *OSMutexDel (OS_EVENT *pevent, INT8U opt, INT8U *err){ #if OS_CRITICAL_METHOD == 3 /* Allocate storage for CPU status register */ OS_CPU_SR cpu_sr;#endif BOOLEAN tasks_waiting; INT8U pip; if (OSIntNesting > 0) { /* See if called from ISR ... */ *err = OS_ERR_DEL_ISR; /* ... can't DELETE from an ISR */ return (pevent); }#if OS_ARG_CHK_EN > 0 if (pevent == (OS_EVENT *)0) { /* Validate 'pevent' */ *err = OS_ERR_PEVENT_NULL; return ((OS_EVENT *)0); } if (pevent->OSEventType != OS_EVENT_TYPE_MUTEX) { /* Validate event block type */ *err = OS_ERR_EVENT_TYPE; return (pevent); }#endif OS_ENTER_CRITICAL(); if (pevent->OSEventGrp != 0x00) { /* See if any tasks waiting on mutex */ tasks_waiting = TRUE; /* Yes */ } else { tasks_waiting = FALSE; /* No */ } switch (opt) { /* Delete mutex only if no task waiting */ case OS_DEL_NO_PEND: /* Delete mutex only if no task waiting */ if (tasks_waiting == FALSE) { pip = (INT8U)(pevent->OSEventCnt >> 8); OSTCBPrioTbl[pip] = (OS_TCB *)0; /* Free up the PIP */ pevent->OSEventType = OS_EVENT_TYPE_UNUSED; pevent->OSEventPtr = OSEventFreeList; /* Return Event Control Block to free list */ OSEventFreeList = pevent; OS_EXIT_CRITICAL(); *err = OS_NO_ERR; return ((OS_EVENT *)0); /* Mutex has been deleted */ } else { OS_EXIT_CRITICAL(); *err = OS_ERR_TASK_WAITING; return (pevent); } case OS_DEL_ALWAYS: /* Always delete the mutex */ while (pevent->OSEventGrp != 0x00) { /* Ready ALL tasks waiting for mutex */ OS_EventTaskRdy(pevent, (void *)0, OS_STAT_MUTEX); } pip = (INT8U)(pevent->OSEventCnt >> 8); OSTCBPrioTbl[pip] = (OS_TCB *)0; /* Free up the PIP */ pevent->OSEventType = OS_EVENT_TYPE_UNUSED; pevent->OSEventPtr = OSEventFreeList; /* Return Event Control Block to free list */ OSEventFreeList = pevent; /* Get next free event control block */ OS_EXIT_CRITICAL(); if (tasks_waiting == TRUE) { /* Reschedule only if task(s) were waiting */ OS_Sched(); /* Find highest priority task ready to run */ } *err = OS_NO_ERR; return ((OS_EVENT *)0); /* Mutex has been deleted */ default: OS_EXIT_CRITICAL(); *err = OS_ERR_INVALID_OPT; return (pevent); }}#endif/*$PAGE*//*********************************************************************************************************** PEND ON MUTUAL EXCLUSION SEMAPHORE** Description: This function waits for a mutual exclusion semaphore.** Arguments : pevent is a pointer to the event control block associated with the desired* mutex.** timeout is an optional timeout period (in clock ticks). If non-zero, your task will* wait for the resource up to the amount of time specified by this argument.* If you specify 0, however, your task will wait forever at the specified* mutex or, until the resource becomes available.** err is a pointer to where an error message will be deposited. Possible error* messages are:* OS_NO_ERR The call was successful and your task owns the mutex* OS_TIMEOUT The mutex was not available within the specified time.* OS_ERR_EVENT_TYPE If you didn't pass a pointer to a mutex* OS_ERR_PEVENT_NULL 'pevent' is a NULL pointer* OS_ERR_PEND_ISR If you called this function from an ISR and the result* would lead to a suspension.** Returns : none** Note(s) : 1) The task that owns the Mutex MUST NOT pend on any other event while it owns the mutex.* 2) You MUST NOT change the priority of the task that owns the mutex**********************************************************************************************************///请求一个互斥信号量---timeout延时时间 This function waits for a mutual exclusion semaphore.void OSMutexPend (OS_EVENT *pevent, INT16U timeout, INT8U *err){ #if OS_CRITICAL_METHOD == 3 /* Allocate storage for CPU status register */ OS_CPU_SR cpu_sr;#endif //优先级继承优先级 INT8U pip; /* Priority Inheritance Priority (PIP) */ INT8U mprio; /* Mutex owner priority */ //任务是否就绪标志 BOOLEAN rdy; /* Flag indicating task was ready */ OS_TCB *ptcb; //是否在中断 if (OSIntNesting > 0) { /* See if called from ISR ... */ *err = OS_ERR_PEND_ISR; /* ... can't PEND from an ISR */ return; }#if OS_ARG_CHK_EN > 0 //事件指针是否可用 if (pevent == (OS_EVENT *)0) { /* Validate 'pevent' */ *err = OS_ERR_PEVENT_NULL; return; } //是否是互斥信号量 if (pevent->OSEventType != OS_EVENT_TYPE_MUTEX) { /* Validate event block type */ *err = OS_ERR_EVENT_TYPE; return; }#endif OS_ENTER_CRITICAL(); /* Is Mutex available? */ //查看互斥信号量有效 //若有信号OSEventCnt的低八位是8个1 说明该信号量未被占用 与OS_MUTEX_KEEP_LOWER_8进行与 若为111111111 if ((INT8U)(pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8) == OS_MUTEX_AVAILABLE) { //与OS_MUTEX_KEEP_UPPER_8保存到高八位 //把低八位置0 表示资源被占用 这时OSEventCnt高八位为pip 低八位为0 pevent->OSEventCnt &= OS_MUTEX_KEEP_UPPER_8; /* Yes, Acquire the resource */ //这时OSEventCnt高八位为pip 低八位为任务的优先级 pevent->OSEventCnt |= OSTCBCur->OSTCBPrio; /* Save priority of owning task */ //OSEventPtr指向任务控制块 pevent->OSEventPtr = (void *)OSTCBCur; /* Point to owning task's OS_TCB */ OS_EXIT_CRITICAL(); *err = OS_NO_ERR; return; } //取出优先级继承优先级pip pip = (INT8U)(pevent->OSEventCnt >> 8); /* No, Get PIP from mutex */ //否则信号量被占用--取出互斥信号量所有者的优先级 赋值给mprio mprio = (INT8U)(pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8); /* Get priority of mutex owner */ //取出互斥信号量所有者的tcb地址 赋值给ptcb ptcb = (OS_TCB *)(pevent->OSEventPtr); /* Point to TCB of mutex owner */ //判断当前的是否等觘cb优先级 且 请求的任务块大于当前的优先级 if (ptcb->OSTCBPrio != pip && mprio > OSTCBCur->OSTCBPrio) { /* Need to promote prio of owner?*/ //查看互斥信号量所有者是否就绪--若就绪 if ((OSRdyTbl[ptcb->OSTCBY] & ptcb->OSTCBBitX) != 0x00) { /* See if mutex owner is ready */ /* Yes, Remove owner from Rdy ...*/ //是否在就绪表中取消互斥信号量所有者的就绪标志 /* ... list at current prio */ if ((OSRdyTbl[ptcb->OSTCBY] &= ~ptcb->OSTCBBitX) == 0x00) { //已取消---就直接把就绪组中对应置0 OSRdyGrp &= ~ptcb->OSTCBBitY; } //就绪 rdy = TRUE; } else { rdy = FALSE; /* No */ } //对互斥信号量所有者做优先级升级，改变TCB中所有者关于优先级域 ptcb->OSTCBPrio = pip; /* Change owner task prio to PIP */ ptcb->OSTCBY = ptcb->OSTCBPrio >> 3; ptcb->OSTCBBitY = OSMapTbl[ptcb->OSTCBY]; ptcb->OSTCBX = ptcb->OSTCBPrio & 0x07; ptcb->OSTCBBitX = OSMapTbl[ptcb->OSTCBX]; //就绪 if (rdy == TRUE) { /* If task was ready at owner's priority ...*/ //在就绪表和就绪组中重新提升后的优先级设置就绪标志 OSRdyGrp |= ptcb->OSTCBBitY; /* ... make it ready at new priority. */ OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX; } //互斥信号量原来未就绪 OSTCBPrioTbl[pip] = (OS_TCB *)ptcb; } //完成对优先级升级，继续对本任务就绪操作--设置等待互斥信号量的标志 OSTCBCur->OSTCBStat |= OS_STAT_MUTEX; /* Mutex not available, pend current task */ //存储超时 OSTCBCur->OSTCBDly = timeout; /* Store timeout in current task's TCB */ //取消本任务就绪状态 OS_EventTaskWait(pevent); /* Suspend task until event or timeout occurs */ OS_EXIT_CRITICAL(); OS_Sched(); /* Find next highest priority task ready */ OS_ENTER_CRITICAL(); //若延时时间到了 if (OSTCBCur->OSTCBStat & OS_STAT_MUTEX) { /* Must have timed out if still waiting for event*/ //结束等待状态 转去执行延时时间到 的函数 OS_EventTO(pevent); OS_EXIT_CRITICAL(); *err = OS_TIMEOUT; /* Indicate that we didn't get mutex within TO */ return; } //否则把当前指针指向0 OSTCBCur->OSTCBEventPtr = (OS_EVENT *)0; OS_EXIT_CRITICAL(); *err = OS_NO_ERR;}/*$PAGE*//*********************************************************************************************************** POST TO A MUTUAL EXCLUSION SEMAPHORE** Description: This function signals a mutual exclusion semaphore** Arguments : pevent is a pointer to the event control block associated with the desired* mutex.** Returns : OS_NO_ERR The call was successful and the mutex was signaled.* OS_ERR_EVENT_TYPE If you didn't pass a pointer to a mutex* OS_ERR_PEVENT_NULL 'pevent' is a NULL pointer* OS_ERR_POST_ISR Attempted to post from an ISR (not valid for MUTEXes)* OS_ERR_NOT_MUTEX_OWNER The task that did the post is NOT the owner of the MUTEX.**********************************************************************************************************///发送互斥信号量---释放一个互斥信号量INT8U OSMutexPost (OS_EVENT *pevent){ #if OS_CRITICAL_METHOD == 3 /* Allocate storage for CPU status register */ OS_CPU_SR cpu_sr;#endif //优先级继承优先级 INT8U pip; /* Priority inheritance priority */ INT8U prio; if (OSIntNesting > 0) { /* See if called from ISR ... */ return (OS_ERR_POST_ISR); /* ... can't POST mutex from an ISR */ }#if OS_ARG_CHK_EN > 0 if (pevent == (OS_EVENT *)0) { /* Validate 'pevent' */ return (OS_ERR_PEVENT_NULL); } if (pevent->OSEventType != OS_EVENT_TYPE_MUTEX) { /* Validate event block type */ return (OS_ERR_EVENT_TYPE); } #endif OS_ENTER_CRITICAL(); pip = (INT8U)(pevent->OSEventCnt >> 8); /* Get priority inheritance priority of mutex */ //获取原来任务的优先级 prio = (INT8U)(pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8); /* Get owner's original priority */ if (OSTCBCur->OSTCBPrio != pip && OSTCBCur->OSTCBPrio != prio) { /* See if posting task owns the MUTEX */ OS_EXIT_CRITICAL(); return (OS_ERR_NOT_MUTEX_OWNER); } //如果本任务是由于继承机制提高的优先级----恢复原来的优先级 if (OSTCBCur->OSTCBPrio == pip) { /* Did we have to raise current task's priority? */ /* Yes, Return to original priority */ /* Remove owner from ready list at 'pip' */ if ((OSRdyTbl[OSTCBCur->OSTCBY] &= ~OSTCBCur->OSTCBBitX) == 0) { OSRdyGrp &= ~OSTCBCur->OSTCBBitY; } OSTCBCur->OSTCBPrio = prio; OSTCBCur->OSTCBY = prio >> 3; OSTCBCur->OSTCBBitY = OSMapTbl[OSTCBCur->OSTCBY]; OSTCBCur->OSTCBX = prio & 0x07; OSTCBCur->OSTCBBitX = OSMapTbl[OSTCBCur->OSTCBX]; OSRdyGrp |= OSTCBCur->OSTCBBitY; OSRdyTbl[OSTCBCur->OSTCBY] |= OSTCBCur->OSTCBBitX; OSTCBPrioTbl[prio] = (OS_TCB *)OSTCBCur; } //先占优先级指针表中的pip项 OSTCBPrioTbl[pip] = (OS_TCB *)1; /* Reserve table entry */ if (pevent->OSEventGrp != 0x00) { /* Any task waiting for the mutex? */ /* Yes, Make HPT waiting for mutex ready */ //将事件等待表中的优先级最高任务就绪 prio = OS_EventTaskRdy(pevent, (void *)0, OS_STAT_MUTEX); pevent->OSEventCnt &= OS_MUTEX_KEEP_UPPER_8; /* Save priority of mutex's new owner */ pevent->OSEventCnt |= prio; //OSEventPtr指向新的互斥信号量所有者的tcb pevent->OSEventPtr = OSTCBPrioTbl[prio]; /* Link to mutex owner's OS_TCB */ OS_EXIT_CRITICAL(); OS_Sched(); /* Find highest priority task ready to run */ return (OS_NO_ERR); } //没有任务等待互斥信号量时就运行到这 //Mutex is now available pevent->OSEventCnt |= OS_MUTEX_AVAILABLE; /* No, Mutex is now available */ pevent->OSEventPtr = (void *)0; OS_EXIT_CRITICAL(); return (OS_NO_ERR);}/*$PAGE*//*********************************************************************************************************** QUERY A MUTUAL EXCLUSION SEMAPHORE** Description: This function obtains information about a mutex** Arguments : pevent is a pointer to the event control block associated with the desired mutex** pdata is a pointer to a structure that will contain information about the mutex** Returns : OS_NO_ERR The call was successful and the message was sent* OS_ERR_QUERY_ISR If you called this function from an ISR* OS_ERR_PEVENT_NULL 'pevent' is a NULL pointer* OS_ERR_EVENT_TYPE If you are attempting to obtain data from a non mutex.**********************************************************************************************************///This function obtains information about a mutex OS_MUTEX_DATA结构体 用于保存互斥信号量的 信息#if OS_MUTEX_QUERY_EN > 0INT8U OSMutexQuery (OS_EVENT *pevent, OS_MUTEX_DATA *pdata){ #if OS_CRITICAL_METHOD == 3 /* Allocate storage for CPU status register */ OS_CPU_SR cpu_sr;#endif INT8U *psrc; INT8U *pdest; //各种判断 if (OSIntNesting > 0) { /* See if called from ISR ... */ return (OS_ERR_QUERY_ISR); /* ... can't QUERY mutex from an ISR */ }#if OS_ARG_CHK_EN > 0 if (pevent == (OS_EVENT *)0) { /* Validate 'pevent' */ return (OS_ERR_PEVENT_NULL); } if (pevent->OSEventType != OS_EVENT_TYPE_MUTEX) { /* Validate event block type */ return (OS_ERR_EVENT_TYPE); }#endif OS_ENTER_CRITICAL(); pdata->OSMutexPIP = (INT8U)(pevent->OSEventCnt >> 8); pdata->OSOwnerPrio = (INT8U)(pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8); if (pdata->OSOwnerPrio == 0xFF) { pdata->OSValue = 1;//可用的一个互斥信号量 } else { pdata->OSValue = 0; } pdata->OSEventGrp = pevent->OSEventGrp; /* Copy wait list */ psrc = &pevent->OSEventTbl[0]; pdest = &pdata->OSEventTbl[0];#if OS_EVENT_TBL_SIZE > 0 *pdest++ = *psrc++;#endif#if OS_EVENT_TBL_SIZE > 1 *pdest++ = *psrc++;#endif#if OS_EVENT_TBL_SIZE > 2 *pdest++ = *psrc++;#endif#if OS_EVENT_TBL_SIZE > 3 *pdest++ = *psrc++;#endif#if OS_EVENT_TBL_SIZE > 4 *pdest++ = *psrc++;#endif#if OS_EVENT_TBL_SIZE > 5 *pdest++ = *psrc++;#endif#if OS_EVENT_TBL_SIZE > 6 *pdest++ = *psrc++;#endif#if OS_EVENT_TBL_SIZE > 7 *pdest = *psrc;#endif OS_EXIT_CRITICAL(); return (OS_NO_ERR);}#endif /* OS_MUTEX_QUERY_EN */#endif /* OS_MUTEX_EN */