elfmodule.c

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

#define DEBUG_ELF_FreeModule 0
MY_STATIC BOOL ELF_FreeModule( HANDLE hModule )
{
	//PMODULE_HANDLE	lp = (PMODULE_HANDLE)hModule;
	PMODULE_CLIENT			lp = (PMODULE_CLIENT)hModule;
	PHANDLE_LIST	lplist;
	PHANDLE_LIST	lpltTemp;


	RETAILMSG(TONE_MOD|DEBUG_ELF_FreeModule, ( "ELF_FreeModule: entry,hModule=0x%x,lp->lpszModuleName=%s.\r\n",hModule, lp->lpszModuleName) );

	//KL_EnterCriticalSection( &csModuleList );	
//	RETAILMSG(TONE_MOD, ( "ELF_FreeModule: free module %s\r\n", lp->lpszModuleName) );

	if(!RemoveClient(lp)){
		ERRORMSG(TONE_MOD, ( "ELF_FreeModule:> no the client\r\n") );
		return FALSE;
	}
	lplist = lp->pHandlelist;
	//Add for fix bug...by zb ...2003-07-08.
	if(lplist == NULL){
		KL_EnterCriticalSection( &csLoadModule );			
		KL_EnterCriticalSection( &csModuleList );	
		RETAILMSG(TONE_MOD, ( "<->\r\n") );
		ReleaseModule(lp->pModule);

		KL_LeaveCriticalSection( &csModuleList );	
		KL_LeaveCriticalSection( &csLoadModule );			
		
	}
	else
	//Add for fix bug...by zb ...2003-07-08.
	{
		RETAILMSG(TONE_MOD|DEBUG_ELF_FreeModule, ( "ELF_FreeModule: lplist:%x\r\n", lplist) );
		while(lplist){			
			//RETAILMSG(TONE_TEST, ( "||\r\n") );
			
			lpltTemp = lplist;
			lplist = lplist->pnext;		//fix bug
			
			ReleaseRef(lp, lpltTemp->pHandle);
			KHeap_Free(lpltTemp, sizeof(HANDLE_LIST));			
			//lplist = lplist->pnext;
		}
	}
	//RETAILMSG(TONE_MOD, ( "||\r\n") );

	//KHeap_Free(lp, sizeof(MODULE_HANDLE));
	//len = strlen( lpszFileName ) + 1;
	//pClient->lpszModuleName = KHeap_Alloc( len * sizeof( TCHAR ) );
	KHeap_FreeString( lp->lpszModuleName );
	lp->lpszModuleName = NULL;

	KHeap_Free(lp, sizeof(MODULE_CLIENT));

	//KL_LeaveCriticalSection( &csModuleList );	

	RETAILMSG(TONE_MOD, ( "ELF_FreeModule: >\r\n") );

	return TRUE;
}

MY_STATIC HANDLE ELF_GetModuleFileHandle( HANDLE hModule )
{
	//PMODULE_HANDLE	lp = (PMODULE_HANDLE)hModule;
	PMODULE_CLIENT				lp = (PMODULE_CLIENT)hModule;
	
	RETAILMSG(TONE_MOD, ( "ELF_GetModuleFileHandle:< :%x:\r\n", lp));	
	if(lp){		
		RETAILMSG(TONE_MOD, ( "ELF_GetModuleFileHandle:< :%x:\r\n", lp->pHandlelist));	
		RETAILMSG(TONE_MOD, ( "ELF_GetModuleFileHandle:< :%s:\r\n", lp->lpszModuleName));	
		if(lp->pHandlelist){
			RETAILMSG(TONE_MOD, ( "ELF_GetModuleFileHandle:< :%x:\r\n", lp->pHandlelist->pHandle));	
			if(lp->pHandlelist->pHandle){
				RETAILMSG(TONE_MOD, ( "ELF_GetModuleFileHandle:< :%x:\r\n", lp->pHandlelist->pHandle->hFile));	
			}
		}
	}

	RETAILMSG(TONE_MOD, ( "ELF_GetModuleFileHandle:> %x\r\n", lp->pHandlelist->pHandle->hFile) );

	return lp->pHandlelist->pHandle->hFile;
}

MY_STATIC LPCTSTR ELF_GetModuleFileName( HANDLE hModule )
{
	PMODULE_CLIENT				lp = (PMODULE_CLIENT)hModule;

	RETAILMSG(TONE_MOD, ( "ELF_GetModuleFileName:< \r\n"));

	//RETAILMSG(TONE_MOD, ( "ELF_GetModuleFileName:> %s\r\n", lp->lpszModuleName));

	//return lp->pModule->lpszApName;
	return lp->lpszModuleName;
}

MY_STATIC LPVOID ELF_GetModuleProcAddress( HANDLE hModule, LPCSTR lpProcName )
{
	//PMODULE_HANDLE	lp = (PMODULE_HANDLE)hModule;
	PMODULE_CLIENT				lp = (PMODULE_CLIENT)hModule;
	PFUNCTION_SYM	pTmp;
	UINT			lpProcAddr;

	RETAILMSG(TONE_MOD, ( "ELF_GetModuleProcAddress:< \r\n"));

	RETAILMSG(TONE_MOD, ( "ELF_GetModuleProcAddress:< %s\r\n", lpProcName) );

	//RETAILMSG(TONE_TEST, ( "->3\r\n"));

	ASSERT(lp->pModule);
	ASSERT(lp->pHandlelist);
	ASSERT(lp->pHandlelist->pHandle);

	//RETAILMSG(TONE_MOD|TONE_TEST, ( "uType:%x, uMode:%x \r\n",lp->pModule->uType,lp->pHandlelist->pHandle->uMode));
	//RETAILMSG(TONE_MOD|TONE_TEST, ( "module:%s\r\n",lp->pModule->lpszApName));

	ASSERT(lp->pModule->uType == CREATE_LIBRARY);
	ASSERT(lp->pHandlelist->pHandle->uMode == MODULE_LOAD);

	/*if((lp->pModule->uType != CREATE_LIBRARY) || (lp->pHandlelist->pHandle->uMode != MODULE_LOAD)){
		RETAILMSG(TONE_MOD, ( "ELF_GetModuleProcAddress: the module don't support the function!\r\n") );
		RETAILMSG(TONE_MOD, ( "ELF_GetModuleProcAddress:>\r\n") );
		return NULL;
	}*/
	
	//RETAILMSG(TONE_TEST, ( "->4\r\n"));
	//ASSERT(lp->pHandlelist->pHandle->lpProc);

	RETAILMSG(TONE_MOD, ( "ELF_GetModuleProcAddress: -> 2 \r\n"));
	pTmp = lp->pHandlelist->pHandle->lpProc; 

	while(pTmp)
	{
		if(strcmp((const char *)pTmp->lpFuncName, lpProcName) == 0){
			RETAILMSG(TONE_MOD, ( "ELF_GetModuleProcAddress: find!\r\n") );
			RETAILMSG(TONE_MOD, ( "ELF_GetModuleProcAddress:>\r\n") );
			//RETAILMSG(TONE_TEST, ( "->5\r\n"));
			return (LPVOID)pTmp->lpProc;
		}
		else
			pTmp = pTmp->lpNext;
	}

	RETAILMSG(TONE_MOD, ( "ELF_GetModuleProcAddress: find new symbol!\n"));

	lpProcAddr = GetNewProcAddr(lp->pHandlelist->pHandle, lpProcName);

	if(lpProcAddr == NULL){
		RETAILMSG(TONE_MOD, ( "ELF_GetModuleProcAddress:> not find!\r\n") );
		//RETAILMSG(TONE_TEST, ( "->6\r\n"));
	}
	
	//RETAILMSG(TONE_TEST, ( "->7\r\n"));
	return (LPVOID)lpProcAddr;
}

MY_STATIC UINT CheckNewModule(struct __dlmodule *__dl_mod, PMODULE_CLIENT lp, UINT	uLoadMode, struct __dlmodule *except_mod)
{
	//struct __dlmodule	*__dl_mod;
	struct __dlmodule	*__dl_temp;
	struct __dlmodule	*__dl_temp2;
	PMODULE_NODE		pNode ;
	PMODULE_HANDLE		ptemp ;
	UINT				uModuleNum = 0;
	UINT				uType;
	//UINT				uIndex =0;

	RETAILMSG(TONE_MOD, ("CheckNewModule : <\n"));

	ASSERT(__dl_mod);
	ASSERT(lp);	
	ASSERT(lp->pModule);

	__dl_temp = __dl_mod;	
	
	while(__dl_temp ){
		__dl_temp2 = __dl_temp;
		__dl_temp = __dl_temp->l_next;
		
		RETAILMSG(TONE_MOD, ("__dl_temp:%x, module name: %s\n", __dl_temp2,__dl_temp2->l_name));
		
		if(__dl_temp2 != except_mod){	
			
			uModuleNum++;
			//ptemp = GetNewModule(__dl_temp2, lp->hProc, MODULE_EXEC);	//??
			
			ASSERT(lp->pModule); 

			//RETAILMSG(TONE_MOD, ("ELF_ExecModule =>12\n"));
			RETAILMSG(TONE_CS, ( "-)3\n"));
			KL_EnterCriticalSection( &csModuleList);
			
			pNode = FindLoadedMod(__dl_temp2->l_name);
			//pNode = CreateModuleNode(__dl_temp2->l_name, ptemp, MODULE_EXEC);				

			ASSERT(pNode);

			ReleaseMapHandle(pNode);

			ptemp = CreateModuleHandle(pNode, uLoadMode, lp->hProc);				
			if(ptemp == NULL){
				KL_LeaveCriticalSection( &csModuleList);
				RETAILMSG(TONE_CS, ( "3(-\n"));
				//KL_LeaveCriticalSection( &csLoadDll );	 
				return 0;
			}			
			
			if(uLoadMode == MODULE_LOAD)
				uType = MODULE_LOAD_DLL;
			else
				uType = MODULE_EXEC_DLL;

			//uType = uLoadMode;

			RETAILMSG(TONE_MOD, ("-->CheckNewModule: uLoadMode:%x\n", uLoadMode));

			SetModuleHandle(ptemp, NULL, __dl_temp2, uType);

			KL_LeaveCriticalSection( &csModuleList);
			RETAILMSG(TONE_CS, ( "4(-\n"));
			
			InsertHandleList(lp, ptemp);

			if(!ModuleInitFini(lp, ptemp, MODULE_INIT)){
				RETAILMSG(TONE_ERROR, ("Module init fail:%s\r\n", lp->lpszModuleName));
			}

			//RETAILMSG(TONE_ERROR, ("Module init fail:%s\r\n", lp->lpszModuleName));

		}
		
		//RETAILMSG(TONE_MOD, ("ELF_ExecModule =>131\n"));
		
		//The line commit to test...
		//__dlclean_module(__dl_temp2);
		__dl_temp2 = NULL;
	}
	
	//if(__dl_temp2 != NULL)
	//	__dlclean_module(__dl_temp2);
	
	//RETAILMSG(TONE_MOD, ("ELF_ExecModule =>14\n"));
	//		__dlfree(__dl_temp);
	
	//__dl_loaded = NULL;
	//__dl_nloaded = 0;

	RETAILMSG(TONE_MOD, ("CheckNewModule : find and create %x new module\n", uModuleNum));
	RETAILMSG(TONE_MOD, ("CheckNewModule : >\n"));

	return uModuleNum;	
}

typedef BOOL (*__init_fun) (PMODULE_CLIENT, DWORD, LPVOID);
typedef BOOL (*__fini_fun) (PMODULE_CLIENT, DWORD, LPVOID);

BOOL ModuleInitFini(PMODULE_CLIENT lp, PMODULE_HANDLE ptemp, UINT flag )
{
	//NOTE: 2003-08-20...zb
	// Fix a bug: no init value...
	//BOOL	result;
	BOOL	result = TRUE;
	//NOTE: 2003-08-20...zb

	RETAILMSG(TONE_MOD|TONE_TEST, ("ModuleInitFini : <\n"));

	
	if(ptemp->lpModule->uType != CREATE_LIBRARY){
		//ASSERT(!ptemp->info);
		RETAILMSG(TONE_MOD|TONE_TEST, ("ModuleInitFini >:%s NON dll\n", lp->lpszModuleName));		
		return FALSE;
	}

	ASSERT(ptemp->info);

	RETAILMSG(TONE_MOD|TONE_TEST, ("ModuleInitFini:%x:%s\n",flag, lp->lpszModuleName));

	if(flag == MODULE_INIT)
	{
		if (ptemp->info->initproc != NULL)
		{
			__init_fun init = (__init_fun)(ptemp->info->addr + ptemp->info->initproc);
			
			//RETAILMSG(TONE_MOD|TONE_TEST, ("init:<\n"));
			result = init (lp, DLL_PROCESS_ATTACH, 0);
			//RETAILMSG(TONE_MOD|TONE_TEST, ("init:>\n"));

			ASSERT(result);
		}else{
			RETAILMSG(TONE_MOD|TONE_TEST, ("Non init:\r\n"));
		}
	}else{
		if (ptemp->info->finiproc != NULL)
		{
			__fini_fun fini = (__fini_fun)(ptemp->info->addr + ptemp->info->finiproc);
	
			//RETAILMSG(TONE_MOD|TONE_TEST, ("fini:<\n"));
			result = fini (lp, DLL_PROCESS_DETACH, 0);
			//RETAILMSG(TONE_MOD|TONE_TEST, ("fini:>\n"));

			ASSERT(result);
		}else{
			RETAILMSG(TONE_MOD|TONE_TEST, ("Non fini:\r\n"));
		}
	}	

	RETAILMSG(TONE_MOD|TONE_TEST, ("ModuleInitFini : >\n"));

	return result;
}

MY_STATIC void CleanLoadedDll()
{
	ASSERT(__dl_loaded);

	//note: 2003-09-04...zb
	//fix a bug of free.
	//__dlclean_module(__dl_loaded);
	__dlclean_module(__dl_loaded, FALSE);
	//note: 2003-09-04...zb

	__dl_loaded = NULL;

	__dl_nloaded = 0;
}


struct __dlmodule *LoadDllModule(PMODULE_CLIENT lp, struct exe_module *pmod, UINT uLoadMode, UINT *uReturn)
{	
	PMODULE_HANDLE		ptemp;
//	struct exe_module	*pmod;
	struct __dlmodule	*pLoadMod = NULL; // lilin init it with NULL -2004-04-13 
	struct __dlmodule	*dl_mod;
	UINT				uType;

	ASSERT(lp);

	DEBUGMSG(TONE_MOD, ( "LoadDllModule: entry( %s ).\r\n", lp->lpszModuleName) );

	KL_EnterCriticalSection( &csLoadModule );	 

	/*
	RETAILMSG(TONE_CS, ( "-)4\n"));
	KL_EnterCriticalSection( &csModuleList);
	//lp->pModule = FindOrCreateModule(lp->lpszModuleName, NULL, lp->uCreateFlag);
	lp->pModule = FindOrCreateModule(lp->lpszModuleName, NULL, CREATE_LIBRARY);
	KL_LeaveCriticalSection( &csModuleList);		
	RETAILMSG(TONE_CS, ( "5(-\n"));*/

	//if(uLoadMode == LOAD_DLL_CLEARLY){
	if(uLoadMode == MODULE_LOAD){
		RETAILMSG(TONE_CS, ( "-)4\n"));
		KL_EnterCriticalSection( &csModuleList);
		//lp->pModule = FindOrCreateModule(lp->lpszModuleName, NULL, lp->uCreateFlag);
		lp->pModule = FindOrCreateModule(lp->lpszModuleName, NULL, CREATE_LIBRARY);
		// lilin add 2004-04-13
		if( lp->pModule )
		{
		// lilin 2004-04-13
			//KL_LeaveCriticalSection( &csModuleList);		
			//RETAILMSG(TONE_CS, ( "5(-\n"));
		
			RETAILMSG(TONE_MOD, ( "LoadDllModule: => 1\n"));

			//RETAILMSG(TONE_CS, ( "-)5\n"));
			//KL_EnterCriticalSection( &csModuleList);
			//ptemp = FindLoadedHandle(lp->pModule, FIND_MODULE);
			ptemp = FindLoadedHandle(lp->pModule, FIND_NON_XIP_REF);
			KL_LeaveCriticalSection( &csModuleList);		
			RETAILMSG(TONE_CS, ( "6(-\n"));

			if(ptemp != NULL)
				pLoadMod = elf_load(ptemp, lp->pModule->lpszApName, 0);
			else
				pLoadMod = elf_load(NULL, lp->pModule->lpszApName, 0);
		}
		// lilin add 2004-04-13		
		else
		{
			KL_LeaveCriticalSection( &csModuleList);
		}
		// lilin

	//}else if(uLoadMode == LOAD_DLL_QUIETLY){
	}else if(uLoadMode == MODULE_EXEC){

		ASSERT(pmod);
		//RETAILMSG(TONE_MOD, ( "LoadDllModule: => 2\n"));

		RETAILMSG(TONE_MOD, ("dldyn_start: loading quietly!\n"));

		pLoadMod = dldyn_start(pmod->exe_info, lp->pModule->lpszApName);

		RETAILMSG(TONE_MOD, ("Exec_module: ->1!\n"));
	}

	RETAILMSG(TONE_MOD, ( "LoadDllModule: => 3\n"));

	//if(!(pLoadMod = elf_load(pMod, pMod->lpszApName, 0))){
	if(!pLoadMod){
		
		RETAILMSG(TONE_MOD, ( "LoadDllModule: > fail!  %s\r\n", lp->lpszModuleName) );
		//KL_LeaveCriticalSection( &csLoadDll );	 
		
		KL_LeaveCriticalSection( &csLoadModule );	 
		RETAILMSG(TONE_CS, ( "2<===\n"));
		*uReturn = LOAD_FAIL;
		return NULL;
	}

	

	//if(uLoadMode == LOAD_DLL_CLEARLY){
	if(uLoadMode == MODULE_LOAD){
		dl_mod = pLoadMod;
		
		while(dl_mod->l_prev){
			dl_mod = dl_mod->l_prev;
		}
		CheckNewModule(dl_mod, lp, uLoadMode, NULL);
	}else
		CheckNewModule(pLoadMod, lp, uLoadMode, pLoadMod);
	
	CleanLoadedDll();
	
	
	//KL_LeaveCriticalSection( &csLoadDll );	 		
	KL_LeaveCriticalSection( &csLoadModule );	 
	RETAILMSG(TONE_CS, ( "3<===\n"));
	
	RETAILMSG(TONE_MOD, ( "LoadDllModule: > OK!  %s\r\n", lp->lpszModuleName) );
	//RETAILMSG(TONE_MOD, ( "->%s:> loaded dll!\r\n", pMod->lpszApName) );