thread.c

深圳市微逻辑电子有限公司 巨果&#8226 Kingmos&reg 系统核心

	lpThread->lpdwThreadUserStack = (LPDWORD)( (LPBYTE)lpStack + dwStackSize - sizeof( UINT ) * 2 );	
	
	lpThread->lpCurProcess = lpThread->lpOwnerProcess = lpProcess;//(LPPROCESS)HandleToPtr(hProcess);
	lpThread->hThread = hThread;
	lpThread->lpfnStartAddress = (LPVOID)lpStartAddress;
	
	DEBUGMSG( DEBUG_InitThreadData, ( "InitThreadData: call _LinkThread.\r\n" ) );
	// 将线程连接进入线程链表	
	_LinkThread( lpThread );
	// 将线程加入进程链表并增加进程的线程数
	AddToProcess( lpThread );
	KL_InterlockedIncrement( (LPLONG)&lpThread->lpOwnerProcess->dwThreadCount );

	DEBUGMSG( DEBUG_InitThreadData, ( "InitThreadData: call InitThreadTSS.\r\n" ) );

#ifdef USE_THREAD_PAGE_TABLE
	{
		extern VOID InitThreadPageTable( LPTHREAD lpThread );
		InitThreadPageTable( lpThread );
	}
#endif
	InitThreadTSS( lpThread, FirstThreadProc, (LPBYTE)lpThread->lpdwThreadUserStack, lpParameter );
	
	return lpThread;
	
ERROR_RETURN:
	// 错误处理
	RETAILMSG( 1, ( "error at InitThreadData: failue.\r\n" ) );
	if( lpThread->lpdwTLS )
	{
		KHeap_Free( lpThread->lpdwTLS,TLS_ALLOC_SIZE );
	}
	if( lpStack )
	{
		FreeThreadStack( lpProcess, lpStack, lpThread->dwThreadStackSize );
	}
	if( lpThread->lpsemExit )
	{
		_CloseSemaphoreObj( lpThread->lpsemExit, 0 );//_SemaphoreDelete( lpThread->lpsemExit );
	}
	if( lpThread->lppsemWait )
	{
		KHeap_Free( lpThread->lppsemWait, MAX_WAITOBJS_PTR_SIZE );
	}

//	if( lpThread->lpCpuPTS == NULL )
//	{
//		FreeCPUPTS( lpThread->lpCpuPTS );
//	}
    if( lpThread->lpCallStack )
		KHeap_Free( lpThread->lpCallStack, sizeof( CALLSTACK ) ); 
	return 0;
}

// ********************************************************************
// 声明：void ThreadSelfExit( void )
// 参数：
//		无
// 返回值：
//		无
// 功能描述：
//		当线程不是当前线程时， 用调用 MakeThreadToDie 将该线程的IP设为ThreadSelfExit
//		使需要被杀死的线程成为当前线程
// 引用：
//		内部使用
// ********************************************************************
#define DEBUG_ThreadSelfExit 0
static void ThreadSelfExit( void )
{
	KL_ExitThread( lpCurThread->dwExitCode );
	ERRORMSG( DEBUG_ThreadSelfExit, ( "ThreadSelfExit: error.\r\n" ) );	
}


// ********************************************************************
// 声明：static void MakeThreadToDie( LPTHREAD lpThread, DWORD dwExitCode )
// 参数：
//		IN lpThread - 线程结构指针
//		IN dwExitCode - 线程退出代码
// 返回值：
//		无
// 功能描述：
//		处理线程的退出
// 引用：
//		
// ********************************************************************
#define DEBUG_MAKETHREADTODIE 0
static void MakeThreadToDie( LPTHREAD lpThread, DWORD dwExitCode )
{
	DWORD dwState;
	UINT uiSave;

	ASSERT( lpThread != lpCurThread );
	DEBUGMSG( DEBUG_MAKETHREADTODIE, ( "MakeThreadToDie: idThread(0x%x),state(0x%x).\r\n", lpThread->dwThreadId, lpThread->dwState ) );

    LockIRQSave( &uiSave );

    dwState = lpThread->dwState;
    lpThread->dwExitCode = dwExitCode;
    lpThread->nSuspendCount = 0;
	switch( dwState )
	{
	case THREAD_INTERRUPTIBLE:
	case THREAD_UNINTERRUPTIBLE:		
	case THREAD_SUSPENDED:
	    
		SetThreadIP( lpThread, (DWORD)ThreadSelfExit );

		lpThread->dwState = THREAD_RUNNING;		
		AddToRunQueue( lpThread );

		UnlockIRQRestore( &uiSave );				
		
		break;
	case THREAD_RUNNING:
		// 应该判断线程是否在内核态
		/*
		if( lpThread->lpCallStack && 
			( lpThread->lpCallStack->dwCallInfo & CALL_KERNEL ) )
		{	//在内核态
			lpThread->dwSignal |= SIGNAL_EXIT;
			bNeedResched = TRUE;
		}
		else
		{	//非内核态
			SetThreadIP( lpThread, (DWORD)ThreadSelfExit );
		}
		*/
		SetThreadIP( lpThread, (DWORD)ThreadSelfExit );
		UnlockIRQRestore( &uiSave );
		//
		break;
	default:
		ERRORMSG( DEBUG_MAKETHREADTODIE, ("error in MakeThreadToDie: undef thread state(0x%x).\r\n", dwState ) );
		break;
	}	
}


// ********************************************************************
// 声明：void _DoThreadExit( void )
// 参数：
//		无
// 返回值：
//		无
// 功能描述：
//		处理线程退出
// 引用：
//		内部
// ********************************************************************
#define DEBUG_DoThreadExit 0

static void _DoThreadExit( void )
{
	LPVOID lpvTemp;
	DEBUGMSG( DEBUG_DoThreadExit|1, ( "_DoThreadExit pThread(0x%x), idThread(0x%x).\r\n", lpCurThread, lpCurThread->dwThreadId ) );
	// 向所有服务广播线程退出事件
	DEBUGMSG( DEBUG_DoThreadExit, ( "_DoThreadExit:DO SCC_BROADCAST_THREAD_EXIT.\r\n" ) );	
	EnumServerHandler( SCC_BROADCAST_THREAD_EXIT, lpCurThread->dwThreadId, 0 );//( ThreadExitServerNotify, lpCurThread->dwThreadId );
	if( lpCurThread->lpOwnerProcess->lpFirstThread->lpNextThreadInProcess == NULL )
	{  // 这是唯一的线程，需要做所有的清除工作
		LPPROCESS lpProcess = lpCurThread->lpOwnerProcess;
		ASSERT( lpCurThread->lpOwnerProcess == lpCurThread->lpCurProcess );

		// 向所有服务广播进程退出事件
    	DEBUGMSG( DEBUG_DoThreadExit, ( "_DoThreadExit:DO SCC_BROADCAST_PROCESS_EXIT.\r\n" ) );			
		EnumServerHandler( SCC_BROADCAST_PROCESS_EXIT, (WPARAM)lpProcess->hProcess, 0 );
		
		// 释放线程句柄
		if(lpProcess->lpMainThread->hThread)
		    KL_CloseHandle( lpProcess->lpMainThread->hThread );
		DEBUGMSG( DEBUG_DoThreadExit, ( "_DoThreadExit:Module_DeInit.\r\n" ) );
		// 释放模块
		
		Module_DeInit( lpProcess->pModule );

		lpProcess->pModule = NULL;// LN 2003-05-21, add
		
    	DEBUGMSG( DEBUG_DoThreadExit, ( "_DoThreadExit:KL_HeapDestroy.\r\n" ) );
    	
		// 释放进程堆
    	{
    		LPHEAP lpHeap = (LPHEAP)KL_InterlockedExchange( (LPLONG)&lpProcess->lpHeap, 0 );
    		if( lpHeap )
    		{
			#ifdef VIRTUAL_MEM    		
   	 			DoHeapDestroy( lpHeap );
			#else    		
				KL_HeapDestroy( lpHeap );
			#endif
    		}
    	}

		 
		DEBUGMSG( DEBUG_DoThreadExit, ( "_DoThreadExit:Handle_CloseAll.\r\n" ) );
		// 释放所有的句柄
		Handle_CloseAll( lpProcess );
		lpCurThread->hThread = NULL;
		
		lpProcess->lpszCommandLine = NULL;// LN 2003-05-21, add
#ifdef VIRTUAL_MEM
		ASSERT( lpProcess->lpProcessSegments->lpSeg->lpBlks[0] == NULL );
#endif
	}
	if( lpCurThread->hThread )
	{
		SetHandleObjPtr( lpCurThread->hThread, NULL );
	    SetHandleUserInfo( lpCurThread->hThread, lpCurThread->dwExitCode ); // LN, 2002-05-22
		lpCurThread->hThread = NULL; 
	}

	//释放拥有的CS MUTEX
	_Semaphore_HandleThreadExit( lpCurThread );
	// 假如可能，释放 timer
	if( lpCurThread->timer.lpNext )
	{
		DEBUGMSG( DEBUG_DoThreadExit, ( "_DoThreadExit:_DelTimerList.\r\n" ) );
		_DelTimerList(&lpCurThread->timer);
		//lpCurThread->lpTimer = NULL;
	}
	// 假如可能，释放信号量
	{
		int nCount = lpCurThread->nWaitCount;
		LPSEMAPHORE  * lppsemWait = lpCurThread->lppsemWait;
		WAITQUEUE * lpWaitQueue = lpCurThread->lpWaitQueue;
		int i;
		if( nCount )
		{
			DEBUGMSG( DEBUG_DoThreadExit, ( "_DoThreadExit:__RemoveWaitQueue.\r\n" ) );
			for( i = 0; i < nCount; i++, lppsemWait++, lpWaitQueue++ )
			{
				__RemoveWaitQueue( &(*lppsemWait)->lpWaitQueue, lpWaitQueue );
				ReleaseSemaphoreAndUnlock( *lppsemWait ); //2004-08-11
			}			
			KHeap_Free( lpCurThread->lpWaitQueue, nCount * sizeof( WAITQUEUE ) );
		}

		lpCurThread->nWaitCount = 0;
		lpCurThread->lpWaitQueue = NULL;
	}
	DEBUGMSG( DEBUG_DoThreadExit, ( "_DoThreadExit:_SemaphoreRelease.\r\n" ) );
	// 释放线程信号量
	_SemaphoreRelease( lpCurThread->lpsemExit, 1, NULL );

	lpvTemp = (LPVOID)KL_InterlockedExchange( (LPLONG)&lpCurThread->lpsemExit, 0 );
	_CloseSemaphoreObj( (LPSEMAPHORE)lpvTemp, 0 );
	
	DEBUGMSG( DEBUG_DoThreadExit, ( "_DoThreadExit:FreeThreadCallStack.\r\n" ) );
	//释放异常结构
	lpvTemp = (LPVOID)lpCurThread->lpException;
	lpCurThread->lpException = NULL;
    FreeThreadExcaption( (LPEXCEPTION)lpvTemp );	

	// 释放呼叫栈
	lpvTemp = (LPVOID)lpCurThread->lpCallStack;
	lpCurThread->lpCallStack = NULL;
    FreeThreadCallStack( (LPCALLSTACK)lpvTemp );

	{
		LPVOID lpStack;

		if( lpCurThread->lpdwThreadKernelStack == NULL )
		{
			while(1)
			{
				lpStack = KHeap_Alloc( PAGE_SIZE );
				if( lpStack )
					break;
				WARNMSG( DEBUG_DoThreadExit, ( "_DoThreadExit:no enough memory!.\r\n" ) );
				Sleep(10);
			}
			lpCurThread->lpdwThreadKernelStack = lpStack;
		}
		// 
     	INTR_OFF();
	    // 从进程移出
    	lpCurThread->dwThreadId = 0; // 阻止再使用该thread
        RemoveFromProcess( lpCurThread );
		
    	lpCurThread->lpCurProcess = &InitKernelProcess;
		
		lppProcessSegmentSlots[0] = NULL;
		//切换到内核栈
	    SwitchToStackSpace( (LPVOID)( (DWORD)lpStack + PAGE_SIZE - sizeof(long) ) );
		INTR_ON();
	}
    DEBUGMSG( DEBUG_DoThreadExit, ( "_DoThreadExit:_FreeThreadResourceAndReschedule.\r\n" ) );
    _FreeThreadResourceAndReschedule();
}

// ********************************************************************
// 声明：void HandleThreadExit( void )
// 参数：
//		无
// 返回值：
//		无
// 功能描述：
//		处理线程退出
// 引用：
//		该模块 和 process.c 也会调用该函数 
// ********************************************************************
#define DEBUG_HANDLETHREADEXIT 0
void HandleThreadExit( void )
{
	//因为永远不应该返回，所以我切换到新的sp,这样有以下考滤：
	//1。该thread 永远不会返回
	//2。因为exit thread 时会调用 server的 相关清除函数，有可能会用到许多stack
	//
	SwitchToStackSpace( lpCurThread->lpdwThreadUserStack );
	_DoThreadExit();
//	ASSERT(0); //永不返回 
}


// ********************************************************************
// 声明：void WINAPI KL_ExitThread( DWORD dwExitCode )
// 参数：
//		IN dwExitCode - 退出代码
// 返回值：
//		无
// 功能描述：
//		退出当前线程
// 引用：
//		系统API		
// ********************************************************************
void WINAPI KL_ExitThread( DWORD dwExitCode )
{			
	if( lpCurThread->lpOwnerProcess != lpCurThread->lpCurProcess )
	{
		SwitchToProcess( lpCurThread->lpOwnerProcess, NULL );
	}
	ASSERT( lpCurThread->lpOwnerProcess == lpCurThread->lpCurProcess );

	if( lpCurThread->lpCurProcess->lpMainThread == lpCurThread )
	{ // 主线程 main thread
		EdbgOutputDebugString( "Main Thread Exit. now, call ExitProcess.\r\n" );
		KL_ExitProcess( dwExitCode );
	}
	else
	{
		//非主线程
		lpCurThread->dwExitCode = dwExitCode;
		HandleThreadExit();
	}
}

// ********************************************************************
// 声明：BOOL WINAPI KL_TerminateThread( HANDLE hThread, DWORD dwExitCode )
// 参数：
//		IN hThread - 线程句柄
//		IN dwExitCode - 退出代码
// 返回值：
//		成功，返回TRUE；失败，返回FALSE
// 功能描述：
//		非正常终止一个线程
// 引用：
//		系统API
// ********************************************************************
#define DEBUG_TerminateThread 0
BOOL WINAPI KL_TerminateThread( HANDLE hThread, DWORD dwExitCode )
{
	LPTHREAD lpThread = (LPTHREAD)HandleToPtr( hThread, OBJ_THREAD ); // 由句柄得到线程对象指针

	if( lpThread )
	{	
		if( lpThread == lpCurThread )
			KL_ExitThread( dwExitCode );
		else
		{
			WARNMSG( DEBUG_TerminateThread, ( "KL_TerminateThread: kill other thread.\r\n" ) );
            MakeThreadToDie( lpThread, dwExitCode );
		}
		return TRUE;
	}
	return FALSE;
}

// ********************************************************************
// 声明：DWORD WINAPI KL_GetCurrentThreadId( void )
// 参数：
//		无
// 返回值：
//		返回当前线程的ID
// 功能描述：
//		得到当前线程的ID
// 引用：
//		系统API
// ********************************************************************
DWORD WINAPI KL_GetCurrentThreadId( void )
{
    return lpCurThread->dwThreadId;
}

// ********************************************************************
// 声明：HANDLE WINAPI KL_GetCurrentThread( void )
// 参数：
//		无
// 返回值：
//		当前线程的句柄
// 功能描述：
//		得到当前线程的句柄，该句柄是当前线程的别名而不是一个真实的句柄
// 引用：
//		系统API
// ********************************************************************
HANDLE WINAPI KL_GetCurrentThread( void )
{
	return CURRENT_THREAD_HANDLE; 
}