jwl-gtf_mutex.c

基于arm核的RTOS

	{
		tmpMutex=tmpTaskCB->jwl_gtf_Mutex;
		if(tmpMutex->jwl_gtf_Using==tmpTaskCB)
			return jwl_gtf_NotCancelMutex;
		tmpTaskCB->jwl_gtf_RetCode=jwl_gtf_HupUpTaskCancel;
		if(tmpMutex->jwl_gtf_RevOCB==tmpTaskCB)		/*反转优先指定线程的优先级*/
		{
			jwl_gtf_ProiRevert(tmpMutex->jwl_gtf_Using,tmpMutex->jwl_gtf_RevOCB);/*恢复原状态*/
			tmpMutex->jwl_gtf_Status=jwl_gtf_Using;
			tmpMutex->RevOCB=jwl_gtf_NULL;
		}
		if(tmpMutex->jwl_gtf_MutexLink==tmpTaskCB)		/*链表头*/
		{
			if(tmpTaskCB->jwl_gtf_EvenLink->Next==jwl_gtf_NULL)/*只有一个挂起*/
				tmpMutex->jwl_gtf_MutexLink=jwl_gtf_NULL;
			else						/*否则*/
			{
				tmpMutex->jwl_gtf_EvenLink=tmpMutex->jwl_gtf_MutexLink->\
					jwl_gtf_EvenLink->Next;
				tmpMutex->jwl_gtf_EvenLink->jwl_gtf_EvenLink->Pre=tmpMutex->jwl_gtf_EvenLink;
			}
		}
		else if(tmpTaskCB->jwl_gtf_EvenLink->Next=jwl_gtf_NULL)	/*链表尾*/
			tmpTaskCB->jwl_gtf_EvenLink->Pre->jwl_gtf_EvenLink->Next=jwl_gtf_NULL;
		else							/*中间*/
		{
			tmpTaskCB->jwl_gtf_EvenLink->Pre->jwl_gtf_EvenLink->Next=\
				tmpTaskCB->jwl_gtf_EvenLink->Next;
			tmpTaskCB->jwl_gtf_EvenLink->Next->jwl_gtf_EvenLink->Pre=\
				tmpTaskCB->jwl_gtf_EvenLink->Pre;
		}
		tmpTaskCB->jwl_gtf_EvenLink={jwl_gtf_NULL,jwl_gtf_NULL};
		tmpTaskCB->jwl_gtf_Mutex=jwl_gtf_NULL;
		tmpTaskCB->jwl_gtf_TaskStatus=tmpTaskCB->jwl_gtf_TaskStatus&(!jwl_gtf_Mutex);
		if(tmpMutex->jwl_gtf_Using->jwl_gtf_WaitTLink!={jwl_gtf_NULL,jwl_gtf_NULL})
		{
			if(tmpMutex->jwl_gtf_Using->jwl_gtf_WaitTLink->Pre==jwl_gtf_TOutMutex)
			{
				jwl_gtf_TOutMutex=jwl_gtf_TOutMutex->jwl_gtf_WatiTLink->Next;
				jwl_gtf_TOutMutex->jwl_gtf_WaitTLink->Pre=jwl_gtf_TOutMutex;						
			}
			else if(tmpMutex->jwl_gtf_Using->jwl_gtf_WaitTLink->Next==jwl_gtf_NULL)
				tmpMutex->jwl_gtf_Using->jwl_gtf_WaitTLink->Pre->\
				    jwl_gtf_WaitTLink->Next=jwl_gtf_NULL;
			else
			{
				tmpMutex->jwl_gtf_Using->jwl_gtf_WaitTLink->Pre->jwl_gtf_WaitTLink\
				  ->Next=tmpMutex->jwl_gtf_Using->jwl_gtf_WaitTLink->Next;
				tmpMutex->jwl_gtf_Using->jwl_gtf_WaitTLink->Next->jwl_gtf_WaitTLink\
				  ->Pre=tmpMutex->jwl_gtf_Using->jwl_gtf_WaitTLink->Pre;
			}
			tmpMutex->jwl_gtf_Using->jwl_gtf_WaitTLink={jwl_gtf)NULL,jwl_gtf_NULL};
		}
		if(tmpTaskCB->jwl_gtf_TaskPro<jwl_gtf_TaskRun->jwl_gtf_TaskPro)
		{
			tmpExchOCB=tmpTaskCB;
			jwl_gtf_Switch
		}
		return jwl_gtf_Noerror;
	}
}

/********************************************************************************************************
*                                        jwl_gtf_CancelAllMutexLock					*
* 描述:取消所有等待线程											*
* 参数: MutexID		:给出的互斥体ID号								*
*	Mutex		:给出的互斥体指针								*
* 返回: :参看JWL-GTF_error.h										*
*********************************************************************************************************/
jwl_gtf_s8 jwl_gtf_CancelAllMutexLock(jwl_gtf_TaskMutex *Mutex,jwl_gtf_u8 MutexID)
{
	jwl_gtf_TaskMutex *tmpMutex;
	jwl_gtf_TaskCB	  *tmpTaskCB,*oldTaskCB,*TaskCB;
	if(Mutex==jwl_gtf_NULL)
	{
		if(tmpMutex=jwl_gtf_FindMutex(MutexID)==jwl_gtf_NULL)		/*用ID号找互斥体*/
			return	jwl_gtf_NoFindMutex;
	}
	else
		tmpMutex=Mutex;
	if(tmpMutex->jwl_gtf_Status=jwl_gtf_Usable)
		return jwl_gtf_MutexUsef
	else
	{
		if(tmpMutex->jwl_gtf_Using==jwl_gtf_NULL||tmpMutex->jwl_gtf_MutexLink==jwl_gtf_NULL)
			return jwl_gtf_Noerror;
		if(tmpMutex->jwl_gtf_RevOCB!=jwl_gtf_NULL)			/*是否有反转*/
		{
			jwl_gtf_ProiRevert(tmpMutex->jwl_gtf_Using,tmpMutex->jwl_gtf_RevOCB);
			tmpMutex->jwl_gtf_RevPCB=jwl_gtf_NULL:
		}
		tmpTaskC=jwl_gtf_get_idle();
		oldTaskCB=tmpMutex->jwl_gtf_MutexLink;
		jwl_gtf_TOutMutex=jwl_gtf_NULL;
		for(;oldTaskCB!=jwl_gtf_NULL;)
		{
			Task=oldTaskCB;
			oldTaskCB=toldTaskCB->jwl_gtf_EvenLink->Next;
			Task->jwl_gtf_EvenLink={jwl_gtf_NULL,jwl_gtf_NULL};
			Task->jwl_gtf_Mutex=jwl_gtf_NULL:
			Task->jwl_gtf_RetCode=jwl_gtf_HupUpTaskCancel;
			Task->jwl_gtf_TaskStatus=Task->jwl_gtf_TaskStatus&(!jwl_gtf_Mutex);			
			oldTaskCB->jwl_gtf_WaitTLink={jwl_gtf_NULL,jwl_gtf_NULL};		
			if(tmpTaskCB->jwl_gtf_TaskPro<Task->jwl_gtf_TaskPro)
				tmpTaskCB=TaskCB;
		}
		oldTaskCB=tmpMutex->jwl_gtf_Using;
		tmpTaskCB->jwl_gtf_Using=jwl_gtf_NULL;
		tmpMutex->jwl_gtf_Status=jwl_gtf_Usable;
		oldTaskCB->jwl_gtf_EvenLink={jwl_gtf_NULL,jwl_gtf_NULL};
		oldTaskCB->jwl_gtf_TaskStatus=oldTaskCB->jwl_gtf_TaskStatus&(!jwl_gtf_Mutex);
		if(oldTaskCB->jwl_gtf_TaskPro<TaskCB->jwl_gtf_TaskPro)
			tmpTaskCB=oldTaskCB;
		if(tmpTaskCB->jwl_gtf_TaskPro<jwl_gtf_TaskRun->jwl_gtf_TaskPro)
		{
			tmpExchOCB=tmpTaskCB;
			jwl_gtf_Switch
		}
		return jwl_gtf_Noerror;
	}
}

/********************************************************************************************************
*                                        jwl_gtf_SetMutexProtocol					*
* 描述:获得互斥体											*
* 参数: ID		:给出的互斥体ID号								*
*	Mutex		:给出的互斥体指针								*
*	Protocol	:优先级反转处理协议								*
* 返回: :参看JWL-GTF_error.h										*
*********************************************************************************************************/
jwl_gtf_s8 jwl_gtf_SetMutexProtocol(jwl_gtf_u8 ID,jwl_gtf_TaskMutex *Mutex,jwl_gtf_bool Protocol)
{
	jwl_gtf_TaskMutex *tmpMutex;
	jwl_gtf_TaskCB	*tmpTaskCB,*oldTaskCB;
	if(Protocol!=jwl_gtf_MutexNone&&Protocol!=jwl_gtf_MutexInherit)			/*判断参数是否合法*/
		return jwl_gtf_ParaError;
	if(Mutex==jwl_gtf_NULL)
	{
		if(tmpMutex=jwl_gtf_FindMutex(ID)==jwl_gtf_NULL)
			return jwl_gtf_NoFindMutex;
	}
	else
		tmpMutex=Mutex;
	if(tmpMutex->jwl_gtf_MutexProtocol==Protocol)
		return jwl_gtf_Noerror;
	tmpMutex->jwl_gtf_MutexProtocol=Protocol;		
	if(Protocol==jwl_gtf_MutexInherit)							/*变成反转*/
	{
		odlTaskCB=jwl_gtf_get_idle();
		tmpTaskCB=tmpMutex->jwl_gtf_MutexLink;
		for(;tmpTaskCB!=jwl_gtf_NULL;tmpTaskCB=tmpTaskCB->jwl_gtf_EvenLink->Next)
		{
			if(tmpTaskCB->jwl_gtf_TaskPro<oldTaskCB->jwl_gtf_TaskPro)
				oldTaskCB=tmpTaskCB;
		}
		if(oldTaskCB!=jwl_gtf_NULL&&oldTaskCB->jwl_gtf_TaskPro<tmpMutex->\
			jwl_gtf_Using->jwl_gtf_TaskPro)
		{
			jwl_gtf_ProiRevert(odlTaskCB,tmpMutex->jwl_gtf_Using);
			tmpMutex->jwl_gtf_Status=jwl_gtf_ProRev;
			tmpMutex->jwl_gtf_RevOCB=oldTaskCB;
			if(tmpMutex->jwl_gtf_Using->jwl_gtf_TaskPro<jwl_gtf_TaskRun->jwl_gtf_TaskPro)
			{
				tmpExchOCB=tmpMutex->jwl_gtf_Using;
				jwl_gtf_Switch
			}
		}
	}
	else										/*变成没有反转*/
	{
		if(tmpMutex->jwl_gtf_RevOCB!=jwl_gtf_NULL)
		{
			jwl_gtf_ProiRevert(tmpMutex->jwl_gtf_Using,tmpMutex->RevOCB);
			tmpMutex->RevOCB=jwl_gtf_NULL;
			if(jwl_gtf_TaskRun==tmpMutex->jwl_gtf_Using)
			{
				jwl_gtf_FindRunTask();
				jwl_gtf_Switch
			}
			else
			{
				if(tmpMutex->jwl_gtf_Using->jwl_gtf_TaskPro<jwl_gtf_TaskRun->jwl_gtf_TaskPro)
				{
					tmpExchOCB=tmpMutex->jwl_gtf_Using;
					jwl_gtf_Switch	
				}
			}
		}
	}
	return jwl_gtf_Noerror;
}

/********************************************************************************************************
*                                        jwl_gtf_GettMutexInfo						*
* 描述:获得互斥体											*
* 参数: ID		:给出的互斥体ID号								*
*	Mutex		:给出的互斥体指针								*
* 返回: 		:jwl_gtf_MutexInfo指针								*
*********************************************************************************************************/
jwl_gtf_MutexInfo *jwl_gtf_GettMutexInfo(jwl_gtf_u MutexID,jwl_gtf_TaskMutex *Mutex)
{
	jwl_gtf_TaskMutex *tmpMutex;
	jwl_gtf_MutexInfo *Info;
	if(Mutex==jwl_gtf_NULL)
		tmpMutex=jwl_gtf_FindMutex(ID);
	
	else
		tmpMutex=Mutex;
	if(tmpMutex==jwl_gtf_NULL)
		return jwl_gtf_NULL;
	Info->jwl_gtf_Status=tmpMutex->jwl_gtf_Status;
	Info->jwl_gtf_MutexProtocol=tmpMutex->jwl_gtf_MutexProtocol;
	Info->jwl_gtf_WaitStatus=tmpMutex->jwl_gtf_WaitStatus;
	return Info;
}

/********************************************************************************************************
*                                        jwl_gtf_MutexFree						*
* 描述:获得互斥体											*
* 参数: ID		:给出的互斥体ID号								*
*	Mutex		:给出的互斥体指针								*
*	Status		:给出的处理状态									*
* 返回: :参看JWL-GTF_error.h										*
*********************************************************************************************************/
jwl_gtf_s8 jwl_gtf_MutexFree(jwl_gtf_u8 ID,jwl_gtf_TaskMutex *Mutex,jwl_gtf_bool Status)
{
	jwl_gtf_TaskMutex *tmpMute;
	jwl_gtf_TaskCB *tmpOCB;
	jwl_gtf_u8 tmpPro;
	if(Mutex!=jwl_gtf_NULL)						/*是否为空*/
	{
		if(tmpMutex=jwl_gtf_Findmutex(ID)==jwl_gtf_NULL)	/*是空则用ID查找互斥体*/
			return jwl_gtf_NoFindMutex;
	}
	else
		tmpMutex=Mutex;
	if(tmpMutex->jwl_gtf_Using!=jwl_gtf_NULL)			/*有线程在用*/
	{
		if(Status==jwl_gtf_Realse)
			jwl_gtf_CancelAllMutexLock(tmpMutex,0);
		else
			return jwl_gtf_NotCancelMutex
	}
	if(tmpMute->jwl_gtf_Link->Pre=jwl_gtf_MutexUse)
		jwl_gtf_DeleteLinkHead(jwl_gtf_MutexUse);
	else
		jwl_gtf_DeleteLinkHead(tmpMutex);
	jwl_gtf_DeleteLinkTail(jwl_gtf_MutexFree,tmpMutex);
	return jwl_gtf_NULL;
}

/********************************************************************************************************
*                                        jwl_gtf_MutexToutDeal						*
* 描述:获得互斥体											*
* 返回: jwl_gtf_void											*
*********************************************************************************************************/
jwl_gtf_void jwl_gtf_MutexToutDeal()
{
	jwl_gtf_TaskCB *tmpTaskCB,*oldTaskCB,*Task,Task1;
	if(jwl_gtf_TOutMutex==jwl_gtf_NULL)
		return;
	else
	{
		tmpTaskCB=jwl_gtf_TOutMutex;
		for(;tmpTaskCB!=jwl_gtf_NULL;)
		{
			oldTaskCB=tmpTaskCB->jwl_gtf_WaitTLink->Next;
			tmpTaskCB=tmpTaskCB->jwl_gtf_WaitTLink->Pre;
			if(--tmpTaskCB->jwl_gtf_TimeOut==0)
			{
				if(tmpTaskCB->jwl_gtf_Mutex->jwl_gtf_RevOCB==tmpTaskCB)
				{
					jwl_gtf_ProiRevert(jwl_gtf_TimeOut->jwl_gtf_Mutex->jwl_gtf_Using,tmpTaskCB);
					Task=tmpTaskCB->jwl_gtf_Mutex->jwl_gtf_MutexLink;
					Task1=jwl_gtf_get_idle();
					for(;Task!=jwl_gtf_NULL;Task=Task->jwl_gtf_EvenLink->Next)
					{
						if(Task->jwl_gtf_TaskPro<Task1->jwl_gtf_TaskPro&&Task1!=tmpTaskCB\
						   &&Task->jwl_gtf_TimeOut!=2)
							Task1=Task;
					}
					if(Task1!=jwl_gtf_NULL&&Task1->jwl_gtf_TaskPro<tmpTaskCB->jwl_gtf_Mutex->\
					  jwl_gtf_Using->jwl_gtf_TaskPro)
					{
						jwl_gtf_ProiRevert(jwl_gtf_TimeOut->jwl_gtf_Mutex->jwl_gtf_Using,TaskCB1);
						tmpTaskCB->jwl_gtf_Mutex->RevOCB=Task1;
					}
					else
					{
						tmpTaskCB->jwl_gtf_Mutex->jwl_gtf_Status=jwl_gtf_Using;
						tmpTaskCB->jwl_gtf_Mutex->RevOCB=jwl_gtf_NULL;							
					}				
				}
				if(tmpTaskCB->jwl_gtf_WaitTLink->Pre==jwl_gtf_TOutMutex)
				{
					if(tmpTaskCB->jwl_gtf_WaitTLink->Next=jwl_gtf_NULL)
						jwl_gtf_TimeOut=jwl_gtf_NULL;
					else
					{
						jwl_gtf_TimeOut=jwl_gtf_TimeOut->jwl_gtf_WaitTLink->Next;
						jwl_gtf_TimeOut->jwl_gtf_WaitTLink->Pre=jwl_gtf_TimeOut;
					}
				}
				else if(tmpTaskCB->jwl_gtf_WaitTLink->Next=jwl_gtf_NULL)
					tmpTaskCB->jwl_gtfWaitTLink->Pre->jwl_gtf_\
					    WaitTLink->Next=jwl_gtf_NULL;
				else
				{
					tmpTaskCB->jwl_gtfWaitTLink->Pre->jwl_gtf_WaitTLink\
					 ->Next=tmpTaskCB->jwl_gtfWaitTLink->Next;
					tmpTaskCB->jwl_gtfWaitTLink->Next->jwl_gtf_WaitTLink\
					 ->Pre=tmpTaskCB->jwl_gtfWaitTLink->Pre;
				}
				tmpTaskCB->jwl_gtf_WaitTLink={jwl_gtf_NULL,jwl_gtf_NULL};
				tmpTaskCB->jwl_gtf_RetCode=jwl_gtf_HupUpTaskTOut;
				tmpTaskCB->jwl_gtf_TaskStatus=jwl_gtf_Ready;
			}
			tmpTaskCB=oldTaskCB;
		}
	}
	return;
}