elfmodule.c

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

		pMod->uRef ++;	//ref increase!!!	
		//RETAILMSG(TONE_TEST, ("Ref<:%x\r\n", pMod->uRef));
		/*if((pMod->uType == CREATE_LIBRARY) || 
			((pMod->uType == CREATE_EXE) && (pMod->lpHandle->uMode == MODULE_EXEC))){	

			pMod->lpHandle->uRef ++;	//ref increase!!!	
		}*/
		if(uResult)
			*uResult = FIND_MODULE;

		RETAILMSG(TONE_TEST, ( "find:%x:%s\r\n",pMod->uRef,lpszFileName) );
		//RETAILMSG(TONE_TEST, ("uRef:%x:%s\n", pMod->uRef,lpszFileName));		
	}else{
		if(uResult)
			*uResult = NEW_MODULE;

		RETAILMSG(TONE_TEST, ( "new:%s\r\n",lpszFileName) );
		pMod = CreateModuleNode(lpszFileName, flag);

		ASSERT(pMod);
	}
	
	RETAILMSG(TONE_MOD, ("FindOrCreateModule: >\n"));

	return pMod;
}

MY_STATIC PMODULE_CLIENT	CreateModuleClient( LPCTSTR lpszFileName, HANDLE hProcess, UINT uiCreateFlag)
{
	PMODULE_CLIENT		pClient;
	//UINT				len;

	pClient = (PMODULE_CLIENT)KHeap_Alloc( sizeof( MODULE_CLIENT ));	
	
	if(pClient == NULL){			
		RETAILMSG(TONE_ERROR, ( "CreateModuleClient: alloc fail!\r\n") );			
		return NULL;
	}
	memset(pClient, 0, sizeof(MODULE_CLIENT));

	//len = strlen( lpszFileName ) + 1;
	//pClient->lpszModuleName = KHeap_Alloc( len * sizeof( TCHAR ) );
	pClient->lpszModuleName = KHeap_AllocString( strlen( lpszFileName ) + 1 );
	
	if( pClient->lpszModuleName == NULL ){
		KHeap_Free( pClient, sizeof( MODULE_CLIENT ) );
		//KL_LeaveCriticalSection( &csModuleList );	 
		RETAILMSG(TONE_ERROR, ("ELF_CreateModule: KHeap_Alloc fail>1\n"));
		return NULL;
	}
	strcpy( pClient->lpszModuleName, lpszFileName );	

	pClient->hProc = hProcess;

	pClient->uCreateFlag = uiCreateFlag;

	/*if(strstr(lpszFileName, KING_PATH)){
		if(uiCreateFlag == CREATE_LIBRARY)
			pClient->uCreateFlag = ROM_MODULE_DLL;
		else
			pClient->uCreateFlag = ROM_MODULE_EXE;
	}else{
		if(uiCreateFlag == CREATE_LIBRARY)
			pClient->uCreateFlag = NORMAL_MODULE_DLL;
		else
			pClient->uCreateFlag = NORMAL_MODULE_EXE;
	}*/

	InsertClient(pClient);

	//RETAILMSG(TONE_ERROR, ("CreateModuleClient: >OK\n"));

	return pClient;
}

#define DEBUG_CreateModuleHandle 0
MY_STATIC PMODULE_HANDLE CreateModuleHandle(PMODULE_NODE pMod, UINT uMode, HANDLE hProcess)
{
	PMODULE_HANDLE		pModHandle;

	RETAILMSG(TONE_MOD|DEBUG_CreateModuleHandle, ( "CreateModuleHandle:< for %s, uMode:%x \r\n", pMod->lpszApName, uMode) );
	
	pModHandle = (PMODULE_HANDLE)KHeap_Alloc( sizeof( MODULE_HANDLE ));	
	
	if(pModHandle == NULL){			
		RETAILMSG(TONE_MOD, ( "ELF_CreateModule: alloc fail!\r\n") );			
		return NULL;
	}
	//init the members of struct MODULE_NODE.
	memset(pModHandle, 0, sizeof(MODULE_HANDLE));
	
	pModHandle->uRef = 1;
	//pModHandle->uRef++;
	//pModHandle->uMode = MODULE_EXEC;	
	pModHandle->uMode = uMode;	
	pModHandle->hProc = hProcess;
	
	pModHandle->lpModule = pMod;
	pModHandle->lpNext = NULL;

	/*if(pMod->lpBase != NULL){				//new add...
		//RETAILMSG(TONE_TEST, ( "ELF_CreateModule: %s ref base!\r\n", pMod->lpszApName) );			
		RETAILMSG(TONE_TEST, ( ">> %s\r\n", pMod->lpszApName) );			
		pModHandle->lpRef = pMod->lpBase;
		pMod->lpBase->uRef ++;
	}else if(((pMod->uType == CREATE_EXE) && (uMode == MODULE_EXEC)) ||
				(pMod->uType == CREATE_LIBRARY)){
		//RETAILMSG(TONE_TEST, ( "ELF_CreateModule: %s new base!\r\n", pMod->lpszApName) );			
		RETAILMSG(TONE_TEST, ( "<< %s\r\n", pMod->lpszApName) );			
		pMod->lpBase = pModHandle;
	}*/
	
	if(pMod->lpHandle){
		PMODULE_HANDLE	pTmp = pMod->lpHandle;		
		
		/*if(pMod->lpHandle->uMode != MODULE_EXEC){
			pModHandle->lpNext = pMod->lpHandle;
			pMod->lpHandle = pModHandle;
			RETAILMSG(TONE_MOD, ( "CreateModuleHandle: insert head \r\n") );
		}else{*/				
			while(pTmp->lpNext)
				pTmp = pTmp->lpNext;

			pTmp->lpNext = pModHandle;
			RETAILMSG(TONE_MOD, ( "CreateModuleHandle: insert tail \r\n") );
		//}
		
	}else{
		RETAILMSG(TONE_MOD, ( "CreateModuleHandle: insert first \r\n") );
		pMod->lpHandle = pModHandle;
	}			
	
	RETAILMSG(TONE_MOD, ( "CreateModuleHandle:> \r\n") );

	return pModHandle;
}
MY_STATIC void InsertEmptyHandleList(PMODULE_CLIENT pmodule,PMODULE_HANDLE lpHandle)
{
	PHANDLE_LIST	ptemp;
	PHANDLE_LIST	ptemp2;

	RETAILMSG(TONE_MOD, ("InsertEmptyHandleList: <!\n"));

	ptemp2 = ptemp = pmodule->pHandlelist;

	while(ptemp){
		ptemp2 = ptemp;
		if(ptemp2->pHandle == NULL){
			ptemp2->pHandle = lpHandle;			
			return ;
		}
		ptemp = ptemp->pnext;
	}
	RETAILMSG(TONE_MOD, ("InsertEmptyHandleList: NO find empty client solt!\n"));
	return ;
}

MY_STATIC void InsertHandleList(PMODULE_CLIENT pmodule, PMODULE_HANDLE pModHandle)
{
	PHANDLE_LIST	plist;
	PHANDLE_LIST	ptemp;
	PHANDLE_LIST	ptemp2;

	ASSERT(pmodule);

	ASSERT(pmodule->pModule);
	//ASSERT(pModHandle);

	//RETAILMSG(TONE_MOD, ( "InsertHandleList: < %s!\r\n", pmodule->pModule->lpszApName) );			

	plist = (PHANDLE_LIST)KHeap_Alloc( sizeof( HANDLE_LIST ));	
	
	if(plist == NULL){			
		RETAILMSG(TONE_MOD, ( "InsertHandleList: alloc fail!\r\n") );			
		return ;
	}
	plist->pHandle = pModHandle;
	plist->pnext   = NULL;

	//Insert 在最后！
	ptemp2 = ptemp = pmodule->pHandlelist;
	//RETAILMSG(TONE_MOD, ( "InsertHandleList: pmodule->pHandlelist: %x!\r\n",pmodule->pHandlelist) );			

	if(pmodule->pHandlelist == NULL)
		pmodule->pHandlelist = plist;
	else{
		while(ptemp->pnext){
			ptemp2 = ptemp;
			ptemp = ptemp->pnext;
		}
		//if(ptemp2)
			ptemp2->pnext = plist;
		//else
		//	pmodule->pHandlelist = plist;
	}
	RETAILMSG(TONE_MOD, ( "InsertHandleList: >!\r\n") );			
	return;
}


//#define		FIND_ONLY			1
//#define		FIND_NON_XIP		2
//#define		FIND_NON_XIP_REF	3

PMODULE_HANDLE FindLoadedHandle(PMODULE_NODE pMod, UINT flag)
{
	PMODULE_HANDLE		ptemp;

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

/*	if(pMod->uPos != XIP_MODULE){
		RETAILMSG(TONE_MOD, ( "FindLoadedHandle: XIP_MODULE >!\r\n") );			
		return NULL;
	}*/

	ptemp = pMod->lpHandle;
	//RETAILMSG(1, ( "FindLoadedHandle: ptemp=%x.\r\n", ptemp ) );			
	while(ptemp){
		RETAILMSG(TONE_MOD, ( "FindLoadedHandle:pMod->uType=%d,ptemp->uMode=%d.\r\n", pMod->uType, ptemp->uMode ) );			
		if(pMod->uType == CREATE_LIBRARY)
			break;
		if((pMod->uType == CREATE_EXE)&&(ptemp->uMode == MODULE_EXEC))
			break;
		//add for fix bug...
		ptemp = ptemp->lpNext;
	}
	if(!ptemp){
		RETAILMSG(TONE_MOD, ( "FindLoadedHandle: >no handle!\r\n") );			
		return NULL;
	}
	//if(flag == 

	if(flag == FIND_ONLY){
		return ptemp;
	}
	if(pMod->uPos == XIP_MODULE){
		RETAILMSG(TONE_TEST, ( "XIP:%s\r\n", pMod->lpszApName) );			
		return NULL;
	}

	if(flag == FIND_NON_XIP_REF){
		//RETAILMSG(TONE_TEST, ( "FindLoadedHandle: find loaded %s!\r\n", pMod->lpszApName) );			
		ptemp->uRef++;
		RETAILMSG(TONE_TEST, ( "->%x:%s\r\n", ptemp->uRef, pMod->lpszApName) );			
	}	

	RETAILMSG(TONE_MOD, ( "FindLoadedHandle: >\r\n") );			
	return ptemp;
}

void ReleaseMapHandle(PMODULE_NODE	pNode)
{
	PMODULE_HANDLE	ptemp;

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

	ptemp = FindLoadedHandle(pNode, FIND_NON_XIP);

	if(ptemp){
		ptemp->uRef --;
		//RETAILMSG(TONE_TEST, ( "ReleaseMapHandle: release ref for %s\r\n", pNode->lpszApName) );			
		RETAILMSG(TONE_TEST, ( "<-%x:%s\r\n", ptemp->uRef,pNode->lpszApName) );			
	}

	RETAILMSG(TONE_MOD, ( "ReleaseMapHandle: >\r\n") );			
	return;	
}

void InsertClient(PMODULE_CLIENT pClient)
{
	//RETAILMSG(TONE_MOD|TONE_TEST, ( "InsertClient: <\r\n") );			

	KL_EnterCriticalSection( &csClientList );	

	pClient->pNext = lpClientList;
	lpClientList = pClient;

	KL_LeaveCriticalSection( &csClientList );	
	//RETAILMSG(TONE_MOD|TONE_TEST, ( "InsertClient: >\r\n") );			
}

BOOL RemoveClient(PMODULE_CLIENT pClient)
{
	PMODULE_CLIENT	ptemp;
	BOOL			bResult = FALSE;

	KL_EnterCriticalSection( &csClientList );	

	ASSERT(lpClientList);

	if(pClient == lpClientList){
		lpClientList = lpClientList->pNext;
		bResult = TRUE;
		goto removeclient_exit;
		//return TRUE;
	}

	ptemp = lpClientList;

	ASSERT(ptemp);

	while(ptemp->pNext){
		if(ptemp->pNext == pClient){
			ptemp->pNext = pClient->pNext;
			bResult = TRUE;
			goto removeclient_exit;
			//return TRUE;
		}
		ptemp = ptemp->pNext;
	}
	
removeclient_exit:
	KL_LeaveCriticalSection( &csClientList );	
	return bResult;		
}

UINT GetNewProcAddr(PMODULE_HANDLE pHandle, LPCSTR lpProcName)
{
		const ElfW(Sym)		*symtab;
		const char			*strtab;
//		const ElfW(Half)	*verstab;
//		Elf_Symndx			symidx;
		int					i = 0;
		const ElfW(Sym)		*sym;
		char				*name;
		PFUNCTION_SYM		pFun;
		UINT				len;

		
		RETAILMSG(TONE_EXEC, ("syn len: %x\r\n", sizeof(ElfW(Sym))));

//		symtab = (const void *) D_PTR (module, l_info[DT_SYMTAB]);
//		strtab = (const void *) D_PTR (module, l_info[DT_STRTAB]);
		symtab = (const void *) pHandle->info->symtab;
		strtab = (const void *) pHandle->info->strtab;

//		verstab = module->l_versyms;

		/* Search the appropriate hash bucket in this object's symbol table
		for a definition for the same symbol name.  */
		//RETAILMSG(TONE_EXEC, ("module->l_nchain: %x\r\n", module->l_nchain));
		RETAILMSG(TONE_EXEC, ("module->l_nchain: %x\r\n", pHandle->info->l_nchain));

		for(i = 0; i < pHandle->info->l_nchain; i++){

			sym = &symtab[i];

			//RETAILMSG(TONE_EXEC, ("GetProcAddr  111\r\n");

			if(sym == NULL)
				continue;

			 /* No value.  */
			if (sym->st_value == 0 )
				continue;
			
			//RETAILMSG(TONE_EXEC, ("GetProcAddr  222\r\n");

			/* Ignore all but STT_NOTYPE, STT_OBJECT and STT_FUNC entries
			since these are no code/data definitions.  */
			if ( ELF32_ST_TYPE(sym->st_info) != STT_FUNC)
				continue;
			
			/* Not the symbol we are looking for.  */
//			if (sym != ref && strcmp (strtab + sym->st_name, undef_name))
//				continue;
			
			//RETAILMSG(TONE_EXEC, ("GetProcAddr  333\r\n");

			/* There cannot be another entry for this symbol so stop here.  */
			switch (ELF32_ST_BIND(sym->st_info))
			{
//			case STB_WEAK:
			case STB_GLOBAL:
				{

				if(strcmp(lpProcName, (strtab + sym->st_name)) != 0)
					continue;

				pFun = (PFUNCTION_SYM)KHeap_Alloc(sizeof(FUNCTION_SYM));

				if(pFun == NULL){
						KL_DebugOutString("alloc fail!\n");
						return 0;
				}				

				len = strlen( (strtab + sym->st_name) ) + 1;
				pFun->lpFuncName = KHeap_Alloc( len * sizeof( TCHAR ) );
				
				if( pFun->lpFuncName == NULL ){
					KHeap_Free( pFun, sizeof( FUNCTION_SYM ) );
					//KL_LeaveCriticalSection( &csModuleList );	 
					RETAILMSG(TONE_MOD, ("GetProcAddr: >1\n"));
					return 0;
				}
				strcpy( pFun->lpFuncName, (strtab + sym->st_name) );	

				pFun->lpNext = pHandle->lpProc;
				pHandle->lpProc = pFun;

				/* Global definition.  Just what we need.  */
				//strcpy(pFun->lpszFunName, (strtab + sym->st_name));
				//name = strtab + sym->st_name;
			
				RETAILMSG(TONE_EXEC, ("funname: %s\r\n", pFun->lpFuncName));

				//pFun->lpProc = __dllookup_value((const char*)pFun->lpszFunName, module);
				pFun->lpProc = sym->st_value + pHandle->info->addr;

				}
//				result->s = sym;
//				result->m = module;
//				return 1;
//			default:
				/* Local symbols are ignored.  */
//				break;
			}
		}//while (1);

		RETAILMSG(TONE_EXEC, ("GetProcAddr: >ok\r\n"));

		return pFun->lpProc;		
}