/*************************************************************************************************
* 功能：线程挂起函数 *
* 参数：(1) pThread 线程结构地址 *
* (2) status 线程当前状态，用于检查 *
* (3) ticks 线程延时时间 *
* (4) pError 保存操作结果 *
* 返回：(1) eFailure *
* (2) eSuccess *
* 说明： *
*************************************************************************************************/
TState uThreadSetUnready(TThread* pThread, TThreadStatus status, TTimeTick ticks, TError* pError)
{
TState state = eFailure;
TError error = THREAD_ERR_STATUS;
/* ISR不会调用本函数 */
KNL_ASSERT((uKernelVariable.State != eIntrState), "");
/* 如果操作的是当前线程，则需要首先检查内核是否允许调度 */
if (pThread->Status == eThreadRunning)
{
/* 如果内核此时禁止线程调度，那么当前线程不能被操作 */
if (uKernelVariable.Schedulable == eTrue)
{
uThreadLeaveQueue(&ThreadReadyQueue, pThread);
uThreadEnterQueue(&ThreadAuxiliaryQueue, pThread, eQuePosTail);
pThread->Status = status;
/* 线程环境马上开始线程调度 */
uThreadSchedule();
error = THREAD_ERR_NONE;
state = eSuccess;
}
else
{
error = THREAD_ERR_FAULT;
}
}
else if (pThread->Status == eThreadReady)
{
/* 如果被操作的线程不是当前线程，则不会引起线程调度，所以直接处理线程和队列 */
uThreadLeaveQueue(&ThreadReadyQueue, pThread);
uThreadEnterQueue(&ThreadAuxiliaryQueue, pThread, eQuePosTail);
pThread->Status = status;
error = THREAD_ERR_NONE;
state = eSuccess;
}
else
{
error = error;
}
#if (TCLC_TIMER_ENABLE)
if ((state == eSuccess) && (status == eThreadDelayed))
{
/* 重置并启动线程定时器 */
uTimerConfig(&(pThread->Timer), eThreadTimer, ticks);
uTimerStart(&(pThread->Timer), 0U);
}
#endif
*pError = error;
return state;
}
/*************************************************************************************************
* 功能：将线程放入资源阻塞队列 *
* 参数：(1) pQueue 线程队列结构地址 *
* (2) pThread 线程结构地址 *
* (3) ticks 资源等待时限 *
* 返回：无 *
* 说明：对于线程进出相关队列的策略根据队列策略特性来进行 *
*************************************************************************************************/
void uIpcBlockThread(TIpcContext* pContext, TIpcQueue* pQueue, TTimeTick ticks)
{
TThread* pThread;
KNL_ASSERT((uKernelVariable.State != eIntrState), "");
/* 将线程放入内核线程辅助队列 */
pThread = (TThread*)(pContext->Owner);
/* 只有处于就绪状态的线程才可以被阻塞 */
if (pThread->Status != eThreadRunning)
{
uDebugPanic("", __FILE__, __FUNCTION__, __LINE__);
}
uThreadLeaveQueue(uKernelVariable.ThreadReadyQueue, pThread);
uThreadEnterQueue(uKernelVariable.ThreadAuxiliaryQueue, pThread, eQuePosTail);
pThread->Status = eThreadBlocked;
/* 将线程放入阻塞队列 */
EnterBlockedQueue(pQueue, pContext);
/* 如果需要就初始化并且打开线程用于访问资源的时限定时器 */
#if (TCLC_TIMER_ENABLE && TCLC_IPC_TIMER_ENABLE)
if ((pContext->Option & IPC_OPT_TIMED) && (ticks > 0U))
{
/* 重新配置并启动线程定时器 */
uTimerConfig(&(pThread->Timer), eIpcTimer, ticks);
uTimerStart(&(pThread->Timer), 0U);
}
#else
ticks = ticks;
#endif
}
/*************************************************************************************************
* 功能：线程注销 *
* 参数：(1) pThread 线程结构地址 *
* 返回：(1) eFailure *
* (2) eSuccess *
* 说明：初始化线程和定时器线程不能被注销 *
*************************************************************************************************/
TState uThreadDelete(TThread* pThread, TError* pError)
{
TState state = eFailure;
TError error = THREAD_ERR_STATUS;
if (pThread->Status == eThreadDormant)
{
#if ((TCLC_IPC_ENABLE) && (TCLC_IPC_MUTEX_ENABLE))
if (pThread->LockList)
{
error = THREAD_ERR_FAULT;
state = eFailure;
}
else
#endif
{
uThreadLeaveQueue(pThread->Queue, pThread);
#if (TCLC_TIMER_ENABLE)
uTimerDelete(&(pThread->Timer));
#endif
/* 如果当前线程在ISR里先被deactivate,然后被deinit，那么在退出isr时，会发生线程切换，
还会有一次针对当前线程的栈操作，所以这里最好不要对被deinit的线程结构做内存清零操作，
除非在汇编代码里对此问题进行处理，对deinit后的当前线程不做上下文入栈操作 */
memset(pThread, 0, sizeof(pThread));
error = THREAD_ERR_NONE;
state = eSuccess;
}
}
*pError = error;
return state;
}
/*************************************************************************************************
* 功能：将线程从挂起状态转换到就绪态，使得线程能够参与内核调度 *
* 参数：(1) pThread 线程结构地址 *
* 返回：(1) eFailure *
* (2) eSuccess *
* 说明：函数名的前缀'u'(communal)表示本函数是全局函数 *
*************************************************************************************************/
void uThreadResumeFromISR(TThread* pThread)
{
/*
* 操作线程，完成线程队列和状态转换,注意只有中断处理时，
* 当前线程才会处在内核线程辅助队列里(因为还没来得及线程切换)
* 当前线程返回就绪队列时，一定要回到相应的队列头
* 当线程进出就绪队列时，不需要处理线程的时钟节拍数
*/
if (pThread->Status == eThreadSuspended)
{
uThreadLeaveQueue(&ThreadAuxiliaryQueue, pThread);
if (pThread == uKernelVariable.CurrentThread)
{
uThreadEnterQueue(&ThreadReadyQueue, pThread, eQuePosHead);
pThread->Status = eThreadRunning;
}
else
{
uThreadEnterQueue(&ThreadReadyQueue, pThread, eQuePosTail);
pThread->Status = eThreadReady;
}
}
#if (TCLC_IRQ_ENABLE)
else
{
if (pThread->Property &THREAD_PROP_ASR)
{
pThread->SyncValue = 1U;
}
}
#endif
}
/*************************************************************************************************
* 功能：线程注销 *
* 参数：(1) pThread 线程结构地址 *
* 返回：(1) eFailure *
* (2) eSuccess *
* 说明：初始化线程和定时器线程不能被注销 *
*************************************************************************************************/
TState uThreadDelete(TThread* pThread, TError* pError)
{
TState state = eFailure;
TError error = THREAD_ERR_STATUS;
if (pThread->Status == eThreadDormant)
{
#if ((TCLC_IPC_ENABLE) && (TCLC_IPC_MUTEX_ENABLE))
if (pThread->LockList)
{
error = THREAD_ERR_FAULT;
state = eFailure;
}
else
#endif
{
uThreadLeaveQueue(pThread->Queue, pThread);
#if (TCLC_TIMER_ENABLE)
uTimerDelete(&(pThread->Timer));
#endif
memset(pThread, 0, sizeof(pThread));
error = THREAD_ERR_NONE;
state = eSuccess;
}
}
*pError = error;
return state;
}
/*************************************************************************************************
* 功能：将线程从指定的状态转换到就绪态，使得线程能够参与内核调度 *
* 参数：(1) pThread 线程结构地址 *
* (2) status 线程当前状态，用于检查 *
* (3) pError 保存操作结果 *
* 返回：(1) eFailure *
* (2) eSuccess *
* 说明：函数名的前缀'u'(communal)表示本函数是全局函数 *
*************************************************************************************************/
static TState SetThreadReady(TThread* pThread, TThreadStatus status, TBool* pHiRP, TError* pError)
{
TState state = eFailure;
TError error = THREAD_ERR_STATUS;
/* 线程状态校验,只有状态符合的线程才能被操作 */
if (pThread->Status == status)
{
/*
* 操作线程，完成线程队列和状态转换,注意只有中断处理时，
* 当前线程才会处在内核线程辅助队列里(因为还没来得及线程切换)
* 当前线程返回就绪队列时，一定要回到相应的队列头
* 当线程进出就绪队列时，不需要处理线程的时钟节拍数
*/
uThreadLeaveQueue(&ThreadAuxiliaryQueue, pThread);
if (pThread == uKernelVariable.CurrentThread)
{
uThreadEnterQueue(&ThreadReadyQueue, pThread, eQuePosHead);
pThread->Status = eThreadRunning;
}
else
{
uThreadEnterQueue(&ThreadReadyQueue, pThread, eQuePosTail);
pThread->Status = eThreadReady;
}
state = eSuccess;
error = THREAD_ERR_NONE;
/* 因为是在线程环境下，所以此时pThread一定不是当前线程 */
if (pThread->Priority < uKernelVariable.CurrentThread->Priority)
{
*pHiRP = eTrue;
}
#if (TCLC_TIMER_ENABLE)
/* 如果是取消定时操作则需要停止线程定时器 */
if ((state == eSuccess) && (status == eThreadDelayed))
{
uTimerStop(&(pThread->Timer));
}
#endif
}
*pError = error;
return state;
}
/* 中断或者线程都有可能调用本函数 */
TState uThreadSetReady(TThread* pThread, TThreadStatus status, TError* pError)
{
TState state = eFailure;
TError error = THREAD_ERR_STATUS;
TBool HiRP = eFalse;
/* 线程状态校验,只有状态符合的线程才能被操作 */
if (pThread->Status == status)
{
/* 操作线程，完成线程队列和状态转换,注意只有中断处理时，
当前线程才会处在内核线程辅助队列里(因为还没来得及线程切换) */
uThreadLeaveQueue(&ThreadAuxiliaryQueue, pThread);
uThreadEnterQueue(&ThreadReadyQueue, pThread, eQuePosTail);
/* 当线程离开就绪队列时，已经放弃它的本轮执行，哪怕时间片并未耗尽。
当线程再次进入就绪队列时，需要恢复线程的时钟节拍数，重新计算其分享处理器时间的能力 */
pThread->Ticks = pThread->BaseTicks;
pThread->Status = eThreadReady;
state = eSuccess;
error = THREAD_ERR_NONE;
/* 如果是在线程环境下，那么此时pThread一定不是当前线程；
如果是在中断环境下，那么
第一，当前线程不一定在就绪队列里，不能作为任务调度的比较标准
第二，中断在最后一级返回时统一做线程调度检查，这里得到的HiPR无意义 */
if (pThread->Priority < uKernelVariable.CurrentThread->Priority)
{
HiRP = eTrue;
}
/* 尝试发起线程抢占 */
uThreadPreempt(HiRP);
#if (TCLC_TIMER_ENABLE)
/* 如果是取消定时操作则需要停止线程定时器 */
if ((state == eSuccess) && (status == eThreadDelayed))
{
uTimerStop(&(pThread->Timer));
}
#endif
}
*pError = error;
return state;
}
void uThreadSuspendSelf(void)
{
/* 操作目标是当前线程 */
TThread* pThread = uKernelVariable.CurrentThread;
/* 将当前线程挂起，如果内核此时禁止线程调度，那么当前线程不能被操作 */
if (uKernelVariable.Schedulable == eTrue)
{
uThreadLeaveQueue(&ThreadReadyQueue, pThread);
uThreadEnterQueue(&ThreadAuxiliaryQueue, pThread, eQuePosTail);
pThread->Status = eThreadSuspended;
uThreadSchedule();
}
else
{
uKernelVariable.Diagnosis |= KERNEL_DIAG_SCHED_ERROR;
pThread->Diagnosis |= THREAD_DIAG_NORMAL;
uDebugPanic("", __FILE__, __FUNCTION__, __LINE__);
}
}
/*************************************************************************************************
* 功能：唤醒IPC阻塞队列中指定的线程 *
* 参数：(1) pThread 线程地址 *
* (2) state 线程资源访问返回结果 *
* (3) error 详细调用结果 *
* (4) pHiRP 是否因唤醒更高优先级而导致需要进行线程调度的标记 *
* 返回：无 *
* 说明： *
*************************************************************************************************/
void uIpcUnblockThread(TIpcContext* pContext, TState state, TError error, TBool* pHiRP)
{
TThread* pThread;
TQueuePos pos = eQuePosTail;
TThreadStatus newStatus = eThreadReady;
/*
* 将线程从IPC资源的阻塞队列中移出，加入到内核线程就绪队列,
* 如果当前线程刚刚被阻塞到阻塞队列中，但还未发生线程切换，
* 而在此时被ISR打断并且ISR又将当前线程唤醒，则当前线程也不必返回就绪队列头
*/
pThread = (TThread*)(pContext->Owner);
/* 只有处于阻塞状态的线程才可以被解除阻塞 */
if (pThread->Status != eThreadBlocked)
{
uDebugPanic("", __FILE__, __FUNCTION__, __LINE__);
}
/*
* 操作线程，完成线程队列和状态转换,注意只有中断处理时，
* 当前线程才会处在内核线程辅助队列里(因为还没来得及线程切换)
* 当前线程返回就绪队列时，一定要回到相应的队列头
* 当线程进出就绪队列时，不需要处理线程的时钟节拍数
*/
uThreadLeaveQueue(uKernelVariable.ThreadAuxiliaryQueue, pThread);
if (pThread == uKernelVariable.CurrentThread)
{
pos = eQuePosHead;
newStatus = eThreadRunning;
}
uThreadEnterQueue(uKernelVariable.ThreadReadyQueue, pThread, pos);
pThread->Status = newStatus;
/* 将线程从阻塞队列移出 */
LeaveBlockedQueue(pContext->Queue, pContext);
/* 设置线程访问资源的结果和错误代码 */
*(pContext->State) = state;
*(pContext->Error) = error;
/* 如果线程是以时限方式访问资源则取消该线程的时限定时器 */
#if ((TCLC_IPC_TIMER_ENABLE) && (TCLC_TIMER_ENABLE))
if ((pContext->Option & IPC_OPT_TIMED) && (error != IPC_ERR_TIMEO))
{
KNL_ASSERT((pThread->Timer.Type == eIpcTimer), "");
uTimerStop(&(pThread->Timer));
}
#endif
/* 设置线程调度请求标记,此标记只在线程环境下有效。
在ISR里，当前线程可能在任何队列里，
跟当前线程相比较优先级也是无意义的 */
/*
* 在线程环境下，如果当前线程的优先级已经不再是线程就绪队列的最高优先级，
* 并且内核此时并没有关闭线程调度，那么就需要进行一次线程抢占
*/
if (pThread->Priority < uKernelVariable.CurrentThread->Priority)
{
*pHiRP = eTrue;
}
}
/*************************************************************************************************
* 功能：内核定时器执行处理函数 *
* 参数：(1) pTimer 定时器 *
* 返回：无 *
* 说明: (1)线程延时的时候，线程被放入内核线程延时队列中 *
* (2)线程以时限方式访问资源的时候，如果得不到资源会被放入资源的线程阻塞队列 *
* 这里虽然有线程队列操作但是不进行调度，是因为这个函数是在中断中调用的， *
* 在最后一层中断返回后，会尝试进行一次线程切换，所以在这里做切换的话是白白浪费时间 *
*************************************************************************************************/
static void DispatchTimer(TTimer* pTimer)
{
TThread* pThread;
#if ((TCLC_IPC_ENABLE) && (TCLC_IPC_TIMER_ENABLE))
TBool HiRP = eFalse;
#endif
/* 如果定时器是线程延时类型的定时器 */
if (pTimer->Type == eThreadTimer)
{
/* 将定时器从活动队列中移出,将定时器放到休眠队列里 */
uObjListRemoveNode(pTimer->ObjNode.Handle, &(pTimer->ObjNode));
uObjListAddNode(&(TimerList.DormantHandle), &(pTimer->ObjNode), eQuePosHead);
pTimer->Status = eTimerDormant;
/* 如果定时器所在的线程处于延时状态则把线程放入内核线程活动队列 */
pThread = (TThread*)(pTimer->Owner);
KNL_ASSERT((pThread->Status == eThreadDelayed), "");
uThreadLeaveQueue(uKernelVariable.ThreadAuxiliaryQueue, pThread);
uThreadEnterQueue(uKernelVariable.ThreadReadyQueue, pThread, eQuePosTail);
/* 当线程离开就绪队列时，已经放弃它的本轮执行，哪怕时间片并未耗尽。
当线程再次进入就绪队列时，需要恢复线程的时钟节拍数，
重新计算其分享处理器时间的能力 */
pThread->Ticks = pThread->BaseTicks;
pThread->Status = eThreadReady;
}
/* 如果定时器是用户定时器类型 */
else if (pTimer->Type == eUserTimer)
{
#if (TCLC_TIMER_DAEMON_ENABLE)
/* 紧急的定时器直接在ISR里处理回调事务;
否则将定时器放入内核定时器期满列表，最后由定时器守护线程处理 */
if (pTimer->Property & TIMER_PROP_URGENT)
{
pTimer->Routine(pTimer->Argument);
ResetTimer(pTimer);
}
else
{
uObjListRemoveNode(pTimer->ObjNode.Handle, &(pTimer->ObjNode));
uObjListAddNode(&(TimerList.ExpiredHandle), &(pTimer->ObjNode), eQuePosTail);
pTimer->Status = eTimerExpired;
}
#else
/* 在ISR里直接处理定时器回调事务 */
pTimer->Routine(pTimer->Argument);
ResetTimer(pTimer);
#endif
}
#if ((TCLC_IPC_ENABLE) && (TCLC_IPC_TIMER_ENABLE))
/* 如果定时器是线程阻塞类型的定时器（时限方式访问资源）则将线程从阻塞队列中唤醒 */
else if (pTimer->Type == eIpcTimer)
{
/* 将定时器从活动队列中移出,将定时器放到休眠队列里 */
uObjListRemoveNode(pTimer->ObjNode.Handle, &(pTimer->ObjNode));
uObjListAddNode(&(TimerList.DormantHandle), &(pTimer->ObjNode), eQuePosHead);
pTimer->Status = eTimerDormant;
/* IPC代码确保不会再次停止timer */
pThread = (TThread*)(pTimer->Owner);
KNL_ASSERT((pThread->Status == eThreadBlocked), "");
uIpcUnblockThread(&(pThread->IpcContext), eFailure, IPC_ERR_TIMEO, &HiRP);
}
#endif
else
{
uDebugPanic("", __FILE__, __FUNCTION__, __LINE__);
}
}
/*************************************************************************************************
* 功能：更改线程优先级 *
* 参数：(1) pThread 线程结构地址 *
* (2) priority 线程优先级 *
* (3) flag 是否被SetPriority API调用 *
* (4) pError 保存操作结果 *
* 返回：(1) eFailure 更改线程优先级失败 *
* (2) eSuccess 更改线程优先级成功 *
* 说明：如果是临时修改优先级，则不修改线程结构的基本优先级 *
*************************************************************************************************/
TState uThreadSetPriority(TThread* pThread, TPriority priority, TBool flag, TError* pError)
{
TState state = eFailure;
TError error = THREAD_ERR_PRIORITY;
TPriority temp;
/* 本函数只会被线程调用 */
KNL_ASSERT((uKernelVariable.State == eThreadState), "");
if (pThread->Priority != priority)
{
if (pThread->Status == eThreadBlocked)
{
uIpcSetPriority(&(pThread->IpcContext), priority);
state = eSuccess;
error = THREAD_ERR_NONE;
}
/* 就绪线程调整优先级时，可以直接调整其在就绪线程队列中的分队列
对于处于就绪线程队列中的当前线程，如果修改它的优先级，
因为不会把它移出线程就绪队列，所以即使内核不允许调度也没问题 */
else if (pThread->Status == eThreadReady)
{
uThreadLeaveQueue(&ThreadReadyQueue, pThread);
pThread->Priority = priority;
uThreadEnterQueue(&ThreadReadyQueue, pThread, eQuePosTail);
if ((flag == eTrue) && (uKernelVariable.Schedulable == eTrue))
{
/* 得到当前就绪队列的最高就绪优先级，因为就绪线程(包括当前线程)
在线程就绪队列内的折腾会导致当前线程可能不是最高优先级。 */
if (priority < uKernelVariable.CurrentThread->Priority)
{
uThreadSchedule();
}
}
state = eSuccess;
error = THREAD_ERR_NONE;
}
else if (pThread->Status == eThreadRunning)
{
/* 假设当前线程优先级最高且唯一，假如调低它的优先级之后仍然是最高，
但是在新的优先级里有多个就绪线程，那么最好把当前线程放在新的就绪队列
的头部，这样不会引起隐式的时间片轮转；当前线程先后被多次调整优先级时，只有
每次都把它放在队列头才能保证它最后一次调整优先级后还处在队列头。 */
uThreadLeaveQueue(&ThreadReadyQueue, pThread);
pThread->Priority = priority;
uThreadEnterQueue(&ThreadReadyQueue, pThread, eQuePosHead);
if ((flag == eTrue) && (uKernelVariable.Schedulable == eTrue))
{
/* 因为当前线程在线程就绪队列内的折腾会导致当前线程可能不是最高优先级，
所以需要重新计算当前就绪队列的最高就绪优先级。*/
uThreadCalcHiRP(&temp);
if (temp < uKernelVariable.CurrentThread->Priority)
{
pThread->Status = eThreadReady;
uThreadSchedule();
}
}
state = eSuccess;
error = THREAD_ERR_NONE;
}
else
{
/*其它状态的线程都在辅助队列里，可以直接修改优先级*/
pThread->Priority = priority;
state = eSuccess;
error = THREAD_ERR_NONE;
}
/* 如果需要则修改线程固定优先级 */
if (flag == eTrue)
{
pThread->BasePriority = priority;
}
}
*pError = error;
return state;
}
/*************************************************************************************************
* 功能：更改线程优先级 *
* 参数：(1) pThread 线程结构地址 *
* (2) priority 线程优先级 *
* (3) flag 是否被SetPriority API调用 *
* (4) pError 保存操作结果 *
* 返回：(1) eFailure 更改线程优先级失败 *
* (2) eSuccess 更改线程优先级成功 *
* 说明：如果是临时修改优先级，则不修改线程结构的基本优先级 *
*************************************************************************************************/
TState uThreadSetPriority(TThread* pThread, TPriority priority, TBool flag, TBool* pHiRP, TError* pError)
{
TState state = eFailure;
TError error = THREAD_ERR_PRIORITY;
TPriority newPrio;
if (pThread->Priority != priority)
{
if (pThread->Status == eThreadBlocked)
{
uIpcSetPriority(&(pThread->IpcContext), priority);
state = eSuccess;
error = THREAD_ERR_NONE;
}
/*
* 就绪线程调整优先级时，可以直接调整其在就绪线程队列中的分队列
* 对于处于就绪线程队列中的当前线程，如果修改它的优先级，
* 因为不会把它移出线程就绪队列，所以即使内核不允许调度也没问题
*/
else if (pThread->Status == eThreadReady)
{
uThreadLeaveQueue(&ThreadReadyQueue, pThread);
pThread->Priority = priority;
uThreadEnterQueue(&ThreadReadyQueue, pThread, eQuePosTail);
/*
* 得到当前就绪队列的最高就绪优先级，因为就绪线程(包括当前线程)
* 在线程就绪队列内的折腾会导致当前线程可能不是最高优先级。
*/
if (priority < uKernelVariable.CurrentThread->Priority)
{
*pHiRP = eTrue;
}
state = eSuccess;
error = THREAD_ERR_NONE;
}
else if (pThread->Status == eThreadRunning)
{
/*
* 假设当前线程优先级最高且唯一，假如调低它的优先级之后仍然是最高，
* 但是在新的优先级里有多个就绪线程，那么最好把当前线程放在新的就绪队列
* 的头部，这样不会引起隐式的时间片轮转；当前线程先后被多次调整优先级时，只有
* 每次都把它放在队列头才能保证它最后一次调整优先级后还处在队列头。
*/
uThreadLeaveQueue(&ThreadReadyQueue, pThread);
pThread->Priority = priority;
uThreadEnterQueue(&ThreadReadyQueue, pThread, eQuePosHead);
/*
* 因为当前线程在线程就绪队列内的折腾会导致当前线程可能不是最高优先级，
* 所以需要重新计算当前就绪队列的最高就绪优先级。
*/
CalcThreadHiRP(&newPrio);
if (newPrio < uKernelVariable.CurrentThread->Priority)
{
*pHiRP = eTrue;
}
state = eSuccess;
error = THREAD_ERR_NONE;
}
else
{
/*其它状态的线程都在辅助队列里，可以直接修改优先级*/
pThread->Priority = priority;
state = eSuccess;
error = THREAD_ERR_NONE;
}
/* 如果需要则修改线程固定优先级 */
if (flag == eTrue)
{
pThread->BasePriority = priority;
}
}
*pError = error;
return state;
}