📄 elfmodule.c

📁 深圳市微逻辑电子有限公司巨果&#8226 Kingmos&reg 系统核心
💻 C
📖 第 1 页 / 共 5 页
字号:
	*uReturn = LOAD_OK;
	return pLoadMod;	
}

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

	ASSERT(lp);

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

	KL_EnterCriticalSection( &csLoadModule );	

/*	RETAILMSG(TONE_CS, ( "-)6\n"));
	KL_EnterCriticalSection( &csModuleList);
	//lp->pModule = FindOrCreateModule(lp->lpszModuleName, NULL, lp->uCreateFlag);
	lp->pModule = FindOrCreateModule(lp->lpszModuleName, NULL, CREATE_EXE);
	KL_LeaveCriticalSection( &csModuleList);		
	RETAILMSG(TONE_CS, ( "7(-\n"));
*/
	//we think the module is loadable always...
	/*if(lp->uMode != MODULE_EXEC){
		RETAILMSG(TONE_MOD,( "The module can't be exec!\r\n" ));
		goto	exec_exit;
		//return NULL;
	}*/

	//KL_EnterCriticalSection( &csLoadExe );	 
	//KL_EnterCriticalSection( &csModuleList);
	if(uLoadMode == MODULE_EXEC){
		RETAILMSG(TONE_CS, ( "-)6\n"));
		KL_EnterCriticalSection( &csModuleList);
		//lp->pModule = FindOrCreateModule(lp->lpszModuleName, NULL, lp->uCreateFlag);
		lp->pModule = FindOrCreateModule(lp->lpszModuleName, NULL, CREATE_EXE);
		// lilin add code -2004-04-13
		if( lp->pModule )
		// lilin 2004-04-13
		{
		//KL_LeaveCriticalSection( &csModuleList);		
		//RETAILMSG(TONE_CS, ( "7(-\n"));
		
		//RETAILMSG(TONE_CS, ( "-)7\n"));
		//KL_EnterCriticalSection( &csModuleList);
		//ptemp = FindLoadedHandle(lp->pModule, FIND_MODULE);
			ptemp = FindLoadedHandle(lp->pModule, FIND_NON_XIP_REF);
			KL_LeaveCriticalSection( &csModuleList);		
			RETAILMSG(TONE_CS, ( "8(-\n"));
		 
			if(ptemp){
				pmod = elf_exec(lp->pModule->lpszApName, ptemp, MODULE_EXEC);
			}else{
				pmod = elf_exec(lp->pModule->lpszApName, NULL, MODULE_EXEC);
			}
		}
		// lilin add code -2004-04-13		
		else
		{
			KL_LeaveCriticalSection( &csModuleList);
		}
		// lilin
	}else{
		RETAILMSG(TONE_CS, ( "-)6\n"));
		KL_EnterCriticalSection( &csModuleList);
		//lp->pModule = FindOrCreateModule(lp->lpszModuleName, NULL, lp->uCreateFlag);
		lp->pModule = FindOrCreateModule(lp->lpszModuleName, NULL, CREATE_EXE);
		KL_LeaveCriticalSection( &csModuleList);		
		RETAILMSG(TONE_CS, ( "7(-\n"));
		if( lp->pModule )
		{		
		    pmod = elf_exec(lp->pModule->lpszApName, NULL, MODULE_LOAD);
		}
	}
	/*if(lp->pModule->lpBase){
		pmod = elf_exec(lp->pModule->lpszApName, lp->pModule->lpBase, MODULE_EXEC);
	}else{
		pmod = elf_exec(lp->pModule->lpszApName, NULL, MODULE_EXEC);
	}*/


	if(!pmod){
		RETAILMSG(TONE_MOD,( "elf_load_binary fail!\r\n" ));
		//ReleaseModule(lp->pModule);		
		//KL_LeaveCriticalSection( &csLoadExe );	 
		
		KL_LeaveCriticalSection( &csLoadModule );	 
		RETAILMSG(TONE_CS, ( "4<===\n"));
		//KL_LeaveCriticalSection( &csModuleList);
		//goto	exec_exit;
		RETAILMSG(TONE_MOD, ( "LoadExeModule: > fail %s\r\n", lp->lpszModuleName) );
		*uReturn = LOAD_FAIL;
		return NULL;
	}

	RETAILMSG(TONE_CS, ( "-)8\n"));
	KL_EnterCriticalSection( &csModuleList);

	if(uLoadMode == MODULE_EXEC){
		ReleaseMapHandle(lp->pModule);
	}

	lpHandle = CreateModuleHandle(lp->pModule, uLoadMode, lp->hProc);

	if(lpHandle == NULL){
		KL_LeaveCriticalSection( &csModuleList);
		RETAILMSG(TONE_CS, ( "9(-\n"));
		//KL_LeaveCriticalSection( &csLoadExe );	 
		
		KL_LeaveCriticalSection( &csLoadModule );	 
		RETAILMSG(TONE_CS, ( "5<===\n"));
		//goto	exec_exit;
		RETAILMSG(TONE_MOD, ( "LoadExeModule: > fail %s\r\n", lp->lpszModuleName) );
		*uReturn = LOAD_FAIL;
		return pmod;
	}

	if(uLoadMode == MODULE_EXEC)
		uType = MODULE_EXEC_EXE;
	else
		uType = MODULE_LOAD_EXE;

	if(!SetModuleHandle(lpHandle, pmod, NULL, uType)){
		KL_LeaveCriticalSection( &csModuleList);
		RETAILMSG(TONE_CS, ( "10(-\n"));
		//KL_LeaveCriticalSection( &csLoadExe );	 
		
		KL_LeaveCriticalSection( &csLoadModule );	 
		RETAILMSG(TONE_CS, ( "6<===\n"));
		//goto	exec_exit; 
		RETAILMSG(TONE_MOD|TONE_ERROR, ( "LoadExeModule: > fail %s\r\n", lp->lpszModuleName) );
		*uReturn = LOAD_FAIL;
		return pmod;

	}

	//if(uLoadMode == MODULE_EXEC)
	//	InsertEmptyHandleList(lp, lpHandle);
	//else
		InsertHandleList(lp, lpHandle);

	//lp->pHandle = lpHandle;

	KL_LeaveCriticalSection( &csModuleList);
	RETAILMSG(TONE_CS, ( "11(-\n"));
	//KL_LeaveCriticalSection( &csLoadExe );	 
	
	KL_LeaveCriticalSection( &csLoadModule );	 
	RETAILMSG(TONE_CS, ( "7<===\n"));

	RETAILMSG(TONE_MOD, ( "LoadExeModule: > Ok %s\r\n", lp->lpszModuleName) );
	*uReturn = LOAD_OK;
	return pmod;
}

MY_STATIC UINT ELF_LoadModule( HANDLE hModule, HANDLE hInst, LPCTSTR lpszCommandLine, UINT uiLoadFlag )
{
	//PMODULE_NODE	lp = (PMODULE_NODE)hModule;
	PMODULE_CLIENT	lp = (PMODULE_CLIENT)hModule;
//	PMODULE_HANDLE	lp = (PMODULE_HANDLE)hModule;
	struct exe_module	*pmod;
	PMODULE_HANDLE	lpHandle;
	PMODULE_HANDLE	ptemp;
	LPSTART			pstart;
	UINT			uResult;
	UINT			uEntry;
	UINT			flag;
	BOOL			bRet;

	struct __dlmodule	*__dl_mod;
//	struct __dlmodule	*__dl_temp;
//	struct __dlmodule	*__dl_temp2;
//	PMODULE_NODE		pNode ;
//	PMODULE_HANDLE		ptemp ;

	//RETAILMSG(TONE_MOD, ( "ELF_LoadModule: < %s\r\n", lp->pModule->lpszApName) );
	RETAILMSG(TONE_MOD, ( "ELF_LoadModule: < %s\r\n", lp->lpszModuleName) );

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

	if(uiLoadFlag&LF_LOAD_TO_MEM){
		if(uiLoadFlag & LF_EXEC){
			//RETAILMSG(TONE_MOD, ( "ELF_LoadModule: exec a module\n"));
			if(lp->uCreateFlag == CREATE_LIBRARY)
				flag = MODULE_LOAD;			
			else
				flag = MODULE_EXEC;		
		}else{
			//RETAILMSG(TONE_MOD, ( "ELF_LoadModule: load a module\n"));
			flag = MODULE_LOAD;			
		}
	}

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

	bRet = LoadModule(lp, flag, &uEntry);

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

	if(!bRet){
		RETAILMSG(TONE_MOD, ( "ELF_LoadModule: > fail!\r\n") );
		return 0;
	}

	if((flag == MODULE_EXEC)&&(lp->uCreateFlag == CREATE_EXE)){
//		extern void CallUserStartupCode( DWORD ip );

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

		pstart = (LPSTART)(uEntry);

		RETAILMSG(1, ( "ELF_LoadModule: start exec %s, 0x%x.\r\n", lp->lpszModuleName, pstart ) );
//        pstart();
		CallUserStartupCode( pstart, 0 ); // 2004-02-26, add by lilin
	}

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

	return 0;
}




PMODULE_NODE FindLoadedMod( LPCTSTR lpcszApName )
{
	char			*modulename;
	char			*pApName;
	PMODULE_NODE	lp;
	
	modulename = FormatModuleName(lpcszApName);

	//KL_EnterCriticalSection( &csModuleList );	 

	lp = lpElfModList;

	while( lp )
	{
		RETAILMSG(TONE_MOD, ( "FindLoadedMod: %s <==> %s\r\n",lp->lpszApName, modulename ) );
		//if( stricmp( lp->lpszApName, lpcszApName ) == 0 )		

		//note: 2003-09-16...zb
		//if( strstr( lp->lpszApName, modulename ) != NULL )
		pApName = FormatModuleName(lp->lpszApName);
		if(stricmp(pApName, modulename) == 0)
		//note: 2003-09-16...zb
		{
			RETAILMSG(TONE_MOD, ( "FindLoadedMod: find\r\n") );

			//RETAILMSG(TONE_TEST, ( "find:%s\r\n",lpcszApName) );

			//KL_LeaveCriticalSection( &csModuleList );	 
			return lp;
		}
		lp = lp->lpNext;
	}
	//KL_LeaveCriticalSection( &csModuleList );	 

	//RETAILMSG(TONE_TEST, ( "0find:%s\r\n",lpcszApName) );
	RETAILMSG(TONE_MOD, ( "FindLoadedMod: don't load it!\r\n") );
	return NULL;
}


MY_STATIC DWORD  ELF_GetModuleSectionOffset( HANDLE hModule, LPCTSTR lpcszSectionName )
{
	//PMODULE_HANDLE	lpmod = (PMODULE_HANDLE)hModule;
	PMODULE_CLIENT				lpmod = (PMODULE_CLIENT)hModule;
	int				i;
	int				inum = 0;
	struct module_seg		*seg_info;

	RETAILMSG(TONE_MOD, ( "ELF_GetModuleSectionOffset:< %s\r\n",lpcszSectionName ) );


	ASSERT(strcmp(lpcszSectionName, ".res") == 0);

	/*if(lpmod->uMode != MODULE_LOAD){
		RETAILMSG(TONE_MOD, ("The module is n't load memory by way of MODULE_LOAD!\n"));
		return 0;
	}*/

	//RETAILMSG(TONE_MOD, ("lpmod->seg_info: %x\n", lpmod->seg_info));

	//seg_info = lpmod->pHandlelist->pHandle->seg_info;
	seg_info = lpmod->pModule->seg_info;

	while(seg_info){
		RETAILMSG(TONE_MOD, ("seg_info->sh_name: %s\n", seg_info->sh_name));

		if(strcmp(seg_info->sh_name, lpcszSectionName) == 0){
			RETAILMSG(TONE_MOD, ( "ELF_GetModuleSectionOffset:> find \r\n") );
			return seg_info->sh_offset;
		}
		seg_info = seg_info->lpNext;
	}

	RETAILMSG(TONE_MOD, ( "ELF_GetModuleSectionOffset:> fail \r\n") );
	return 0;
}

/*
MY_STATIC HANDLE ELF_FindModuleRes(HANDLE hModule,LPCTSTR lpName, LPCTSTR lpType)
{


}

MY_STATIC HANDLE ELF_LoadModuleRes(HANDLE hModule, HANDLE hResInfo)
{

}*/


//#define		LOAD_MODULE_NEW		1
//#define		LOAD_MODULE_REF		2

//extern struct module_seg *GetSegInfo(HANDLE hFile, Elf32_Ehdr	*ehdr);


//MY_STATIC PMODULE_HANDLE LoadModule(PMODULE_NODE pMod, HANDLE hProc,UINT uLoadMode, PMODULE_CLIENT pClient)
MY_STATIC BOOL LoadModule(PMODULE_CLIENT pClient, UINT	uLoadFlag, UINT	*lpEntry)
{
	struct __dlmodule* pLoadMod;
	struct __dlmodule* dl_mod;
	PMODULE_HANDLE	   pModHandle;
	struct exe_module	*pmod;
	PMODULE_HANDLE		ptmp;
	UINT				uResult;
	struct __dlmodule	*__dl_mod;

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

	ASSERT(lpEntry);
//	ASSERT(pMod);
	ASSERT(pClient);
	//ASSERT(pClient->pModule);

	if((uLoadFlag == MODULE_EXEC)&&(pClient->uCreateFlag == CREATE_EXE)){

		pmod = LoadExeModule(pClient, MODULE_EXEC, &uResult);
		
		if(uResult == LOAD_FAIL){
			RETAILMSG(TONE_MOD, ( "ELF_LoadModule: > fail %s\r\n", pClient->lpszModuleName) );
			return 0;
		}
		
		if(pmod->entry == DL_DYN_ENTRY){
			
			//RETAILMSG(TONE_MOD, ( "ELF_LoadModule: => 1\n"));
			
			//__dl_mod = LoadDllModule(pClient, pmod, LOAD_DLL_QUIETLY, &uResult);
			__dl_mod = LoadDllModule(pClient, pmod, MODULE_EXEC, &uResult);
			
			if(uResult == LOAD_FAIL){
				RETAILMSG(TONE_MOD, ( "ELF_LoadModule: > fail %s\r\n", pClient->lpszModuleName) );
				return 0;
			}
			
			*lpEntry = __dl_mod->l_entry;
			//pstart = (LPSTART)(__dl_mod->l_entry);
			
		}else	
			//The codes is test code, future these will be changed ...
		{
			*lpEntry = pmod->exe_info->entry;
			//pstart = (LPSTART)pmod->exe_info->entry;
			
			//RETAILMSG(TONE_MOD,( "entry the app process!\r\n" ));		
		}
		
		return TRUE;
	}

	if(pClient->uCreateFlag == CREATE_EXE){
		LoadExeModule(pClient, uLoadFlag, &uResult);
	}else{
		//LoadDllModule(pClient, MODULE_LOAD, &uResult);
		//LoadDllModule(pClient, NULL, LOAD_DLL_CLEARLY, &uResult);
		RETAILMSG(TONE_TEST, ( "->>3\r\n"));
		LoadDllModule(pClient, NULL, uLoadFlag, &uResult);
	}

	if(uResult == LOAD_FAIL){
		RETAILMSG(TONE_MOD, ( "LoadModule:> FAIL\r\n") );
		return FALSE;
	}else{
		RETAILMSG(TONE_MOD, ( "LoadModule:> OK\r\n") );
		return TRUE;
	}
}

/*MY_STATIC BOOL GetModuleType(PMODULE_NODE pMod, UINT flag)
{
	char	*pTmp = NULL;
	int		ch = '.';


	//RETAILMSG(TONE_MOD, ( "GetModuleType:< %s\r\n", pMod->lpszApName) );

	if(!(pTmp = strrchr(pMod->lpszApName, ch))){

		if(flag == MODULE_LOAD){
			pMod->uType = CREATE_LIBRARY;
			//strcat(pMod->lpszApName, DLL_EXTENSION);
		}
		else {
			pMod->uType = CREATE_EXE;
			//strcat(pMod->lpszApName, EXE_EXTENSION);
		}

		//RETAILMSG(TONE_MOD, ( "GetModuleType:>1 :%x:\r\n", pMod->uType) );
		return TRUE;
	}
	pTmp++;


	//RETAILMSG(TONE_MOD, ( "GetModuleType: %s\r\n", pTmp));

	if(!strcmp(pTmp, EXE_EXTENSION))
		pMod->uType = CREATE_EXE;
	else if(!strcmp(pTmp, DLL_EXTENSION))
		pMod->uType = CREATE_LIBRARY;
	else{
		//RETAILMSG(TONE_MOD,("The file is not support format!\n"));
		return FALSE;
	}

	//RETAILMSG(TONE_MOD, ( "GetModuleType:>2 :%x:\r\n", pMod->uType) );
	return TRUE;		
}*/
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -