execelf.c

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

			if (lp->p_memsz > lp->p_filesz)
			{
				memset (seg_addr+lp->p_filesz, 0, lp->p_memsz-lp->p_filesz);
			}
		}
			break;
		case PT_PHDR:
			module_phdr = (Elf32_Phdr *)(lp->p_vaddr + addr_offset);
			break;
		case PT_DYNAMIC:
			module_dyn  = (Elf32_Dyn *)(lp->p_vaddr + addr_offset);
			module_ndyn = lp->p_memsz / sizeof (Elf32_Dyn);
			break;
		}
	}
	
	//__KFREE_INTERPRET();

	RETAILMSG(TONE_EXEC, ("--load segment ok \n "));

	if (romfileType == ET_EXEC)
	{
		module_phdr = (Elf32_Phdr *)(MODULE_EXE_PHDR_START);

		info = module->exe_info;

		if (have_inter)
		{
			//changed for test...
			//entry_addr = elf_load_binary (module, interpret);
			entry_addr = DL_DYN_ENTRY;

			if (entry_addr == INVALID_ADDR)
				goto error_out;
		}else{
			//entry_addr = ehdr.e_entry;
			entry_addr = romfileEntry;
		}
		//info->entry		= ehdr.e_entry;;
		info->entry		= romfileEntry;
	}
	else
	{
		module_phdr = (Elf32_Phdr *)(MODULE_DLL_PHDR_START);

		module->inter = 1;
		info = module->dll_info;

		entry_addr = romfileEntry + addr_offset;
		info->entry		= entry_addr;
	}
	//__KFREE_INTERPRET();

	//memcpy (module_phdr, phdr, ehdr.e_phentsize*ehdr.e_phnum);
	memcpy (module_phdr, phdr, E_PHENTSIZE*romphnum);

	info->addr		= addr_offset;
	info->start		= load_addr;
	info->end		= load_addr + (start - end);
	info->ld		= module_dyn;
	info->nld		= module_ndyn;
	info->phdr		= module_phdr;
	info->nphdr		= romphnum;
	info->alloced	= module_phdr_allocated;

	//info->hFile		= hFile;	//zb add...
	//module->hFile	= hFile;	
	
	//RETAILMSG(TONE_EXEC, ("--%s entry : %x \n", name, entry_addr);
	RETAILMSG(TONE_EXEC, ("--%s entry : %x \n", name, info->entry));

	retval = entry_addr;

	RETAILMSG(TONE_EXEC, ("load_binary_file => 1!\n"));

//rom file will go to here:
rom_run:

	//module->entry = retval;

error_out:
	if(!bRomModule){
		RETAILMSG(TONE_EXEC, ("load_binary_file => 2!\n"));

		if (phdr != NULL)
			_kfree (phdr);
		
		__KFREE_INTERPRET();
		RETAILMSG(TONE_EXEC, ("load_binary_file => 3!\n"));
		if (interpret != NULL){
			RETAILMSG(TONE_EXEC, ("--PT_INTERP:%x \n", interpret));
			_kfree (interpret);
		}
	}

	RETAILMSG(TONE_EXEC, ("load_binary_file => 31!\n"));
	if (! retval)
	{
		RETAILMSG(TONE_EXEC, ("load_binary_file => 4!\n"));
		VirtualFree ((LPVOID)load_addr, start-end, MEM_DECOMMIT|MEM_RELEASE);

		RETAILMSG(TONE_EXEC, ("load_binary_file => 5!\n"));
		CloseHandle (hFile);
		RETAILMSG(TONE_ERROR, ("load_binary_file fail!\n"));

		return retval;
	}

	//CloseHandle (hFile);

	RETAILMSG(TONE_EXEC, ("load_binary_file OK!\n"));
	return retval;

}

typedef unsigned int (*LPSTART)(void *);
/* load the execute module and his interpret
 * this function will alloc resource for process's module and init the main
 * thread cpu context, when this function return, the process is live
 */
struct exe_module  *elf_exec (const char * name, PMODULE_HANDLE lpHandle, UINT	flag)
{
	unsigned int entry;
	/* execute binary module need fix address */
	struct exe_module *module = (struct exe_module *)VirtualAlloc (NULL,//(LPVOID)MODULE_INFO_START,
		MODULE_INFO_SIZE, MEM_COMMIT|MEM_RESERVE, PAGE_READWRITE);

	if (module == NULL)
	{
		DWORD dw = KL_GetLastError ();
		RETAILMSG(TONE_ERROR, ("--%x elf_load: can't alloc memory !\n", dw));
		return 0;
	}
	/*//add for test...
	module->pbuf = (UINT *)VirtualAlloc (NULL,
		sizeof(UINT)*10, MEM_COMMIT|MEM_RESERVE, PAGE_READWRITE);
	if (module->pbuf == NULL)
	{
		DWORD dw = KL_GetLastError ();
		RETAILMSG(TONE_EXEC, ("--%x elf_load: can't alloc memory !\n", dw);
		return 0;
	}
	{
		int	i;

		for(i = 0; i<10; i++){
			module->pbuf[i] = i;
		}
	}
//	module->myinfo->addr	= 0x1111;	
//	module->myinfo->start	= 0x2222;	
	*/
	
	RETAILMSG(TONE_EXEC, ("--elf_load: alloc memory at: %x OK !\n", (unsigned int)module));

	memset(module, 0, sizeof(struct exe_module));

	module->exe_info = (struct module_info *)(module + 1);
	module->dll_info = (struct module_info *)(module->exe_info + 1);

	/*{
		struct module_info	*ptmp = (struct module_info *)(module->dll_info + 1);
		RETAILMSG(TONE_EXEC, ("ptmp: %x\n", ptmp);
	}*/
	entry = elf_load_binary (module, name, lpHandle, flag);
	if (entry != INVALID_ADDR)
	{
		RETAILMSG(TONE_EXEC, ("--elf_load_binary ok \n "));
		
		module->entry = entry;
		
		/*{
			LPSTART pstart = (LPSTART)entry;
			RETAILMSG(TONE_EXEC, ("--_start address:%x \n", pstart);
			return pstart(module->exe_info);
		}*/
		return module;
	}
	
	VirtualFree ((LPVOID)module, MODULE_INFO_SIZE, MEM_DECOMMIT|MEM_RELEASE);

	return NULL;
}


//BOOL GetProcAddr(struct __dlmodule* module, PMODULE_HANDLE pHandle, LPCSTR lpProcName)
/*BOOL GetProcAddr(struct __dlmodule* module, PMODULE_HANDLE pHandle)
{

		const ElfW(Sym)		*symtab;
		const char			*strtab;
//		const ElfW(Half)	*verstab;
//		Elf_Symndx			symidx;
		int					i = 0;
		const ElfW(Sym)		*sym;
		char				*name;

		
		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]);
//		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));

		for(i = 0; i < module->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:
				{
				PFUNCTION_SYM	pFun;
				UINT			len;

				//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 FALSE;
				}				

				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 NULL;
					return FALSE;
				}
				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->lpszFunName));

				pFun->lpProc = __dllookup_value((const char*)pFun->lpszFunName, module);
				

				}
//				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;
		return TRUE;
}*/


extern struct __dlmodule* __dlload_module (PMODULE_HANDLE lpHandle, const char * name);

struct __dlmodule* elf_load (PMODULE_HANDLE pHandle,const char * name, UINT flag)
{
	struct __dlmodule* loadmodule;
	//PMODULE_INFO pModInfo = &pmod->ModInfo;

	/*if(flag == LOAD_MODULE_NEW){
		loadmodule = __dlload_module(NULL, name);
	}else{
		loadmodule = __dlload_module(pmod->lpHandle, name);
	}*/

//	if(pmod->lpBase == NULL)
		//RETAILMSG(TONE_TEST, ("--elf_load new module! \n "));
//		RETAILMSG(TONE_TEST, ("-)%s\n",name));
//	else
		//RETAILMSG(TONE_TEST, ("--elf_load ref module! \n "));
//		RETAILMSG(TONE_TEST, ("-(%s\n",name));

//	loadmodule = __dlload_module(pmod->lpBase, name);
	loadmodule = __dlload_module(pHandle, name);

	if(loadmodule == NULL)
	{
		RETAILMSG(TONE_ERROR, ("--__dlload_module fail! \n "));
		//return FALSE;
		return NULL;
	}

	RETAILMSG(TONE_EXEC, ("--__dlload_module OK! \n "));

	return loadmodule;
	//return TRUE;
}

#define	NO_SHOW_ELF

void SHOW_ELF_HEADER(Elf32_Ehdr *ehdr)
{
#ifndef NO_SHOW_ELF
	RETAILMSG(TONE_EXEC, ("------------------------------------\n"));
	RETAILMSG(TONE_EXEC, ("ehdr->e_entry: 0x%x\n", ehdr->e_entry));
	RETAILMSG(TONE_EXEC, ("ehdr->e_phoff: 0x%x\n", ehdr->e_phoff));
	RETAILMSG(TONE_EXEC, ("ehdr->e_shoff: 0x%x\n", ehdr->e_shoff));
	RETAILMSG(TONE_EXEC, ("ehdr->e_ehsize: 0x%x\n", ehdr->e_ehsize));
	RETAILMSG(TONE_EXEC, ("ehdr->e_phentsize: 0x%x\n", ehdr->e_phentsize));
	RETAILMSG(TONE_EXEC, ("ehdr->e_phnum: 0x%x\n", ehdr->e_phnum));
	RETAILMSG(TONE_EXEC, ("ehdr->e_shentsize: 0x%x\n", ehdr->e_shentsize));
	RETAILMSG(TONE_EXEC, ("ehdr->e_shnum: 0x%x\n", ehdr->e_shnum));
	RETAILMSG(TONE_EXEC, ("ehdr->e_shstrndx: 0x%x\n", ehdr->e_shstrndx));
	RETAILMSG(TONE_EXEC, ("ehdr->e_type: 0x%x\n", ehdr->e_type));
#endif
}

void SHOW_ELF_PHDR(Elf32_Phdr	*phdr, UINT	phnum)
{

#ifndef NO_SHOW_ELF

	UINT		i;

	for(i = 0; i < phnum; i++)
	{
		Elf32_Phdr	*lp = phdr + i;
		
		RETAILMSG(TONE_EXEC, ("\n"));
		RETAILMSG(TONE_EXEC, ("-----------------------------\n"));
		if(lp->p_type == PT_LOAD)
			RETAILMSG(TONE_EXEC, ("lp->p_type: PT_LOAD\n"));					
		else if(lp->p_type == PT_PHDR)
			RETAILMSG(TONE_EXEC, ("lp->p_type: PT_PHDR\n"));
		else if(lp->p_type == PT_DYNAMIC)
			RETAILMSG(TONE_EXEC, ("lp->p_type: DYNAMIC\n"));
		
		RETAILMSG(TONE_EXEC, ("lp->p_offset: 0x%x\n", lp->p_offset);
		
		RETAILMSG(TONE_EXEC, ("lp->p_vaddr: 0x%x\n", lp->p_vaddr));
		RETAILMSG(TONE_EXEC, ("lp->p_paddr: 0x%x\n", lp->p_paddr));
		RETAILMSG(TONE_EXEC, ("lp->p_filesz: 0x%x\n", lp->p_filesz));
		RETAILMSG(TONE_EXEC, ("lp->p_memsz: 0x%x\n", lp->p_memsz));					
		RETAILMSG(TONE_EXEC, ("lp->p_align: 0x%x\n", lp->p_align));
		RETAILMSG(TONE_EXEC, ("lp->p_flags: 0x%x\n", lp->p_flags));
		
		if (lp->p_flags & PF_R)
			//nprotect = PAGE_READONLY;
			RETAILMSG(TONE_EXEC, ("PAGE_READONLY\n"));
		if (lp->p_flags & PF_W)
			//nprotect = PAGE_READWRITE; //PAGE_WRITECOPY
			RETAILMSG(TONE_EXEC, ("PAGE_READWRITE\n"));
		if (lp->p_flags & PF_X)
			//nprotect = PAGE_EXECUTE_READWRITE; //PAGE_EXECUTE_WRITECOPY
			RETAILMSG(TONE_EXEC, ("PAGE_EXECUTE_READWRITE\n"));				
	}	
	
	/*for(i = 0; i < info.nshdr; i++)
	{
		Elf32_Shdr	*lp = info.shdr + i;
		
		RETAILMSG(TONE_EXEC, ("\n");
		RETAILMSG(TONE_EXEC, ("-----------------------------\n");
		RETAILMSG(TONE_EXEC, ("lp->sh_name: 0x%x\n", lp->sh_name);
		RETAILMSG(TONE_EXEC, ("lp->sh_type: 0x%x\n", lp->sh_type);
		RETAILMSG(TONE_EXEC, ("lp->sh_flags: 0x%x\n", lp->sh_flags);
		RETAILMSG(TONE_EXEC, ("lp->sh_addr: 0x%x\n", lp->sh_addr);
		RETAILMSG(TONE_EXEC, ("lp->sh_offset: 0x%x\n", lp->sh_offset);
		RETAILMSG(TONE_EXEC, ("lp->sh_size: 0x%x\n", lp->sh_size);
		RETAILMSG(TONE_EXEC, ("lp->sh_link: 0x%x\n", lp->sh_link);
		RETAILMSG(TONE_EXEC, ("lp->sh_info: 0x%x\n", lp->sh_info);
		RETAILMSG(TONE_EXEC, ("lp->sh_addralign: 0x%x\n", lp->sh_addralign);
		RETAILMSG(TONE_EXEC, ("lp->sh_entsize: 0x%x\n", lp->sh_entsize);
	}*/
#endif
	
}