mirror of
https://github.com/reactos/reactos.git
synced 2024-08-13 22:56:37 +00:00
1002 lines
31 KiB
C
1002 lines
31 KiB
C
/*++
|
|
|
|
Copyright (c) 1998-2001 Klaus P. Gerlicher
|
|
|
|
Module Name:
|
|
|
|
main.c
|
|
|
|
Abstract:
|
|
|
|
loader/translator for pIce LINUX
|
|
|
|
Environment:
|
|
|
|
User mode only
|
|
|
|
Author:
|
|
|
|
Klaus P. Gerlicher
|
|
Reactos Port by Eugene Ingerman
|
|
|
|
Revision History:
|
|
|
|
04-Aug-1998: created
|
|
15-Nov-2000: general cleanup of source files
|
|
|
|
Copyright notice:
|
|
|
|
This file may be distributed under the terms of the GNU Public License.
|
|
|
|
--*/
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
// includes
|
|
#include "stdinc.h"
|
|
#include <wchar.h>
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
// constant defines
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
// global variables
|
|
char SrcFileNames[2048][2048];
|
|
ULONG ulCurrentSrcFile = 0;
|
|
|
|
HANDLE debugger_file;
|
|
|
|
ULONG ulGlobalVerbose = 0;
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
// process_stabs()
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
void process_stabs(
|
|
char* pExeName, // name of exe
|
|
HANDLE fileout, // symbol file handle
|
|
PIMAGE_SECTION_HEADER section, //Elf32_Shdr* pSHdr,
|
|
int sectionHeadersSize, //int nSHdrSize,
|
|
void* p, // ptr to memory where whole exe was read
|
|
PSTAB_ENTRY pStab, // ptr to stabs
|
|
int nStabLen, // size of stabs
|
|
char* pStr, // ptr to stabs strings
|
|
int nStrLen, // sizeof stabs strings
|
|
char* pGlobals, // ptr to global symbols
|
|
int nGlobalLen, // sizeof of globals
|
|
char* pGlobalsStr, // ptr to global strings
|
|
int nGlobalStrLen) // size of global strings
|
|
{
|
|
unsigned i,strLen;
|
|
int nOffset=0,nNextOffset=0;
|
|
PSTAB_ENTRY pStabCopy = pStab;
|
|
char* pName,szCurrentPath[2048];
|
|
PICE_SYMBOLFILE_HEADER SymbolFileHeader;
|
|
LPSTR pSlash,pDot;
|
|
char temp[2048];
|
|
char* pCopyExeName = temp;
|
|
WCHAR tempstr[64];
|
|
DWORD wrote;
|
|
|
|
//printf("LOADER: enter process_stabs()\n");
|
|
|
|
//get the name of the executable file
|
|
memset((void*)&SymbolFileHeader,0,sizeof(SymbolFileHeader));
|
|
SymbolFileHeader.magic = PICE_MAGIC;
|
|
strcpy(temp,pExeName);
|
|
pSlash = strrchr(temp,'\\');
|
|
pDot = strchr(temp,'.');
|
|
if(pDot)
|
|
{
|
|
*pDot = 0;
|
|
}
|
|
if(pSlash)
|
|
{
|
|
pCopyExeName = pSlash+1;
|
|
}
|
|
strLen = MultiByteToWideChar(CP_ACP, NULL, pCopyExeName, -1, tempstr, 64 );
|
|
if( !strLen )
|
|
printf("Cannot convert string to multibyte: %s\n", pCopyExeName );
|
|
wcscpy(SymbolFileHeader.name,tempstr);
|
|
|
|
for(i=0;i<(nStabLen/sizeof(STAB_ENTRY));i++)
|
|
{
|
|
pName = &pStr[pStabCopy->n_strx + nOffset];
|
|
|
|
#if 0
|
|
//printf("LOADER: \n%.8x %.2x %.2x %.4x %.8x %s\n",
|
|
pStabCopy->n_strx,
|
|
pStabCopy->n_type,
|
|
pStabCopy->n_other,
|
|
pStabCopy->n_desc,
|
|
pStabCopy->n_value,
|
|
pName
|
|
);
|
|
#endif
|
|
switch(pStabCopy->n_type)
|
|
{
|
|
case N_UNDF:
|
|
nOffset += nNextOffset;
|
|
nNextOffset = pStabCopy->n_value;
|
|
//printf("LOADER: changing string offset %x %x\n",nOffset,nNextOffset);
|
|
break;
|
|
case N_SO:
|
|
if((strLen = strlen(pName)))
|
|
{
|
|
if(pName[strLen-1]!='/')
|
|
{
|
|
if(strlen(szCurrentPath))
|
|
{
|
|
//printf("LOADER: ###########################################################################\n");
|
|
strcat(szCurrentPath,pName);
|
|
//printf("LOADER: changing source file %s\n",szCurrentPath);
|
|
strcpy(SrcFileNames[ulCurrentSrcFile++],szCurrentPath);
|
|
szCurrentPath[0]=0;
|
|
}
|
|
else
|
|
{
|
|
//printf("LOADER: ###########################################################################\n");
|
|
//printf("LOADER: changing source file %s\n",pName);
|
|
strcpy(SrcFileNames[ulCurrentSrcFile++],pName);
|
|
}
|
|
}
|
|
else
|
|
strcpy(szCurrentPath,pName);
|
|
}
|
|
else
|
|
{
|
|
//printf("LOADER: END source file\n");
|
|
//printf("LOADER: ###########################################################################\n");
|
|
}
|
|
break;
|
|
/* case N_SLINE:
|
|
//printf("LOADER: code source line number #%u for addr. %x\n",pStabCopy->n_desc,pStabCopy->n_value);
|
|
break;
|
|
case N_DSLINE:
|
|
//printf("LOADER: data source line number #%u for addr. %x\n",pStabCopy->n_desc,pStabCopy->n_value);
|
|
break;
|
|
case N_BSLINE:
|
|
//printf("LOADER: BSS source line number #%u for addr. %x\n",pStabCopy->n_desc,pStabCopy->n_value);
|
|
break;
|
|
case N_GSYM:
|
|
//printf("LOADER: global symbol %s @ addr. %x (%x)\n",pName,pStabCopy->n_value,pStabCopy->n_desc);
|
|
break;
|
|
case N_BINCL:
|
|
//printf("LOADER: include file %s\n",pName);
|
|
break;
|
|
case N_EINCL:
|
|
break;
|
|
case N_FUN:
|
|
if(strlen(pName))
|
|
//printf("LOADER: function %s @ addr. %x (%x)\n",pName,pStabCopy->n_value,pStabCopy->n_desc);
|
|
else
|
|
//printf("LOADER: text segment %x (%x)\n",pName,pStabCopy->n_value,pStabCopy->n_desc);
|
|
break;
|
|
case N_PSYM:
|
|
//printf("LOADER: parameter %s @ [EBP%+d] (%x)\n",pName,pStabCopy->n_value,pStabCopy->n_desc);
|
|
break;
|
|
case N_RSYM:
|
|
//printf("LOADER: register variable %s @ reg. %x (%x)\n",pName,pStabCopy->n_value,pStabCopy->n_desc);
|
|
break;
|
|
case N_LBRAC:
|
|
//printf("LOADER: lexical block %s @ reg. %x (%x)\n",pName,pStabCopy->n_value,pStabCopy->n_desc);
|
|
break;
|
|
case N_RBRAC:
|
|
//printf("LOADER: END of lexical block %s @ reg. %x (%x)\n",pName,pStabCopy->n_value,pStabCopy->n_desc);
|
|
break;
|
|
case N_STSYM:
|
|
//printf("LOADER: static variable %s @ %x (%x)\n",pName,pStabCopy->n_value,pStabCopy->n_desc);
|
|
break;
|
|
case N_LCSYM:
|
|
//printf("LOADER: BSS variable %s @ %x (%x)\n",pName,pStabCopy->n_value,pStabCopy->n_desc);
|
|
break;
|
|
case N_LSYM:
|
|
if(pStabCopy->n_value)
|
|
{
|
|
//printf("LOADER: stack variable %s @ [EBP%+d] (%x)\n",pName,pStabCopy->n_value,pStabCopy->n_desc);
|
|
}
|
|
else
|
|
{
|
|
//printf("LOADER: global variable %s \n",pName);
|
|
}
|
|
break;
|
|
*/
|
|
}
|
|
|
|
pStabCopy++;
|
|
}
|
|
|
|
//printf("LOADER: SymbolFileHeader.ulSizeOfHeader= %x (%x)\n",nSHdrSize,(LPSTR)pSHdr-(LPSTR)p);
|
|
//printf("LOADER: SymbolFileHeader.ulSizeOfGlobals = %x (%x)\n",nGlobalLen,(LPSTR)pGlobals-(LPSTR)p);
|
|
//printf("LOADER: SymbolFileHeader.ulSizeOfGlobalsStrings = %x (%x)\n",nGlobalStrLen,(LPSTR)pGlobalsStr-(LPSTR)p);
|
|
//printf("LOADER: SymbolFileHeader.ulSizeOfStabs = %x (%x)\n",nStabLen,(LPSTR)pStab-(LPSTR)p);
|
|
//printf("LOADER: SymbolFileHeader.ulSizeOfStabsStrings = %x (%x)\n",nStrLen,(LPSTR)pStr-(LPSTR)p);
|
|
|
|
SymbolFileHeader.ulOffsetToHeaders = sizeof(PICE_SYMBOLFILE_HEADER);
|
|
SymbolFileHeader.ulSizeOfHeader = sectionHeadersSize;
|
|
SymbolFileHeader.ulOffsetToGlobals = sizeof(PICE_SYMBOLFILE_HEADER)+sectionHeadersSize;
|
|
SymbolFileHeader.ulSizeOfGlobals = nGlobalLen;
|
|
SymbolFileHeader.ulOffsetToGlobalsStrings = sizeof(PICE_SYMBOLFILE_HEADER)+sectionHeadersSize+nGlobalLen;
|
|
SymbolFileHeader.ulSizeOfGlobalsStrings = nGlobalStrLen;
|
|
SymbolFileHeader.ulOffsetToStabs = sizeof(PICE_SYMBOLFILE_HEADER)+sectionHeadersSize+nGlobalLen+nGlobalStrLen;
|
|
SymbolFileHeader.ulSizeOfStabs = nStabLen;
|
|
SymbolFileHeader.ulOffsetToStabsStrings = sizeof(PICE_SYMBOLFILE_HEADER)+sectionHeadersSize+nGlobalLen+nGlobalStrLen+nStabLen;
|
|
SymbolFileHeader.ulSizeOfStabsStrings = nStrLen;
|
|
SymbolFileHeader.ulOffsetToSrcFiles = sizeof(PICE_SYMBOLFILE_HEADER)+sectionHeadersSize+nGlobalLen+nGlobalStrLen+nStabLen+nStrLen;
|
|
SymbolFileHeader.ulNumberOfSrcFiles = ulCurrentSrcFile;
|
|
|
|
printf("sectionHeaderSize: %ld, nGlobalLen: %ld, nGlobalStrLen: %ld, nStabLen: %ld, "
|
|
"nStrLen: %ld, ulCurrentSrcFile: %ld, ulOffsetToStabs: %ld\n",
|
|
sectionHeadersSize, nGlobalLen, nGlobalStrLen,
|
|
nStabLen, nStrLen, ulCurrentSrcFile, SymbolFileHeader.ulOffsetToStabs);
|
|
|
|
WriteFile(fileout,&SymbolFileHeader,sizeof(PICE_SYMBOLFILE_HEADER),&wrote, NULL);
|
|
WriteFile(fileout,section,sectionHeadersSize,&wrote, NULL);
|
|
WriteFile(fileout,pGlobals,nGlobalLen,&wrote, NULL);
|
|
WriteFile(fileout,pGlobalsStr,nGlobalStrLen,&wrote, NULL);
|
|
WriteFile(fileout,pStab,nStabLen,&wrote, NULL);
|
|
WriteFile(fileout,pStr,nStrLen,&wrote, NULL);
|
|
|
|
for(i=0;i<ulCurrentSrcFile;i++)
|
|
{
|
|
HANDLE file;
|
|
int len;
|
|
PVOID pFile;
|
|
PICE_SYMBOLFILE_SOURCE pss;
|
|
|
|
file = CreateFile(SrcFileNames[i],GENERIC_READ , 0, NULL, OPEN_EXISTING, 0, 0);
|
|
//printf("Trying To Open: %s, result: %x\n", SrcFileNames[i], file );
|
|
|
|
|
|
if( file == INVALID_HANDLE_VALUE ){
|
|
//let's try win format drive:/file
|
|
char srctmp[2048];
|
|
strcpy(srctmp, SrcFileNames[i] );
|
|
if(strncmp(srctmp,"//",2)==0){
|
|
*(srctmp) = *(srctmp+2);
|
|
*(srctmp+1) = ':';
|
|
*(srctmp+2) = '/';
|
|
file = CreateFile(srctmp,GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, 0);
|
|
//printf("Trying To Open: %s, handle: %x\n", srctmp, file );
|
|
if( file == INVALID_HANDLE_VALUE )
|
|
printf("Can't open file: %s\n", srctmp );
|
|
}
|
|
}
|
|
if(file != INVALID_HANDLE_VALUE)
|
|
{
|
|
//printf("LOADER: [%u] opened %s as FD %x\n",i,SrcFileNames[i],file);
|
|
|
|
len = SetFilePointer(file,0,NULL,FILE_END);
|
|
//printf("LOADER: length = %d\n",(int)len);
|
|
|
|
SetFilePointer(file,0,NULL,FILE_BEGIN);
|
|
|
|
strcpy(pss.filename,SrcFileNames[i]);
|
|
pss.ulOffsetToNext = len+sizeof(PICE_SYMBOLFILE_SOURCE);
|
|
|
|
pFile = malloc(len+1);
|
|
//printf("LOADER: memory for file @ %x\n",pFile);
|
|
if(pFile)
|
|
{
|
|
//printf("LOADER: reading file...\n");
|
|
ReadFile(file,pFile,len+1,&wrote,NULL);
|
|
//printf("read: %d, error: %d\n", wrote, GetLastError());
|
|
WriteFile(fileout,&pss,sizeof(PICE_SYMBOLFILE_SOURCE),&wrote, NULL);
|
|
WriteFile(fileout,pFile,len,&wrote, NULL);
|
|
//printf("LOADER: writing file...%d\n%s\n",wrote,pFile );
|
|
free(pFile);
|
|
}
|
|
|
|
CloseHandle(file);
|
|
}
|
|
|
|
}
|
|
|
|
//printf("LOADER: leave process_stabs()\n");
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
// find_stab_sections()
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
void find_stab_sections(void* p,PIMAGE_SECTION_HEADER section, unsigned cSections,
|
|
PSTAB_ENTRY* ppStab,int* pLen,char** ppStr,int* pnStabStrLen)
|
|
{
|
|
unsigned i;
|
|
//printf("LOADER: enter find_stab_sections()\n");
|
|
*ppStab = 0;
|
|
*ppStr = 0;
|
|
|
|
for ( i=1; i <= cSections; i++, section++ )
|
|
{
|
|
|
|
if(strcmp(section->Name,".stab") == 0)
|
|
{
|
|
*ppStab = (PSTAB_ENTRY)((int)p + section->PointerToRawData);
|
|
*pLen = section->SizeOfRawData;
|
|
printf("LOADER: .stab @ %x (offset %x) len = %x\n",*ppStab,section->PointerToRawData,section->SizeOfRawData);
|
|
}
|
|
else if(strncmp(section->Name,".stabstr",strlen(".stabstr")) == 0)
|
|
{
|
|
*ppStr = (char*)((int)p + section->PointerToRawData);
|
|
*pnStabStrLen = section->SizeOfRawData;
|
|
printf("LOADER: .stabstr @ %x (offset %x) len = %x\n",*ppStab,section->PointerToRawData,section->SizeOfRawData);
|
|
}
|
|
}
|
|
|
|
//printf("LOADER: leave find_stab_sections()\n");
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
// process_pe()
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
int process_pe(char* filename,int file,void* p,int len)
|
|
{
|
|
|
|
PIMAGE_DOS_HEADER pDosHeader;
|
|
PIMAGE_NT_HEADERS pNTHeaders;
|
|
|
|
char* pStr;
|
|
PSTAB_ENTRY pStab;
|
|
DWORD nStabLen,nSym;
|
|
char* pStrTab;
|
|
char* pSymTab;
|
|
|
|
char szSymName[2048];
|
|
HANDLE fileout;
|
|
int nSymStrLen,nStabStrLen;
|
|
int iRetVal = 0;
|
|
|
|
pDosHeader = (PIMAGE_DOS_HEADER)p;
|
|
pNTHeaders = (PIMAGE_NT_HEADERS)((DWORD)p + pDosHeader->e_lfanew);
|
|
|
|
if ((pDosHeader->e_magic == IMAGE_DOS_SIGNATURE)
|
|
&& (pDosHeader->e_lfanew != 0L)
|
|
&& (pNTHeaders->Signature == IMAGE_NT_SIGNATURE))
|
|
{
|
|
if( pNTHeaders->FileHeader.PointerToSymbolTable ){
|
|
|
|
pSymTab = (char*)((DWORD)p + pNTHeaders->FileHeader.PointerToSymbolTable);
|
|
nSym = pNTHeaders->FileHeader.NumberOfSymbols;
|
|
//string table follows immediately after symbol table. first 4 bytes give the length of the table
|
|
//references to string table include the first 4 bytes.
|
|
pStrTab = (char*)((PIMAGE_SYMBOL)pSymTab + nSym);
|
|
nSymStrLen = *((DWORD*)pStrTab);
|
|
find_stab_sections(p,IMAGE_FIRST_SECTION(pNTHeaders),pNTHeaders->FileHeader.NumberOfSections,
|
|
&pStab,&nStabLen,&pStr,&nStabStrLen);
|
|
|
|
if(pStab && nStabLen && pStr && nStabStrLen)
|
|
{
|
|
LPSTR pDot;
|
|
|
|
strcpy(szSymName,filename);
|
|
//printf("LOADER: file name = %s\n",szSymName);
|
|
if((pDot = strchr(szSymName,'.')))
|
|
{
|
|
*pDot = 0;
|
|
strcat(pDot,".dbg");
|
|
}
|
|
else
|
|
{
|
|
strcat(szSymName,".dbg");
|
|
}
|
|
//printf("LOADER: symbol file name = %s\n",szSymName);
|
|
printf("LOADER: creating symbol file %s for %s\n",szSymName,filename);
|
|
|
|
fileout = CreateFile(szSymName,
|
|
GENERIC_READ | GENERIC_WRITE,
|
|
0,
|
|
NULL,
|
|
CREATE_ALWAYS,
|
|
0,
|
|
0);
|
|
|
|
if(fileout != INVALID_HANDLE_VALUE)
|
|
{
|
|
printf("NumberOfSections: %d, size: %d\n", pNTHeaders->FileHeader.NumberOfSections,sizeof(IMAGE_SECTION_HEADER));
|
|
process_stabs(szSymName,
|
|
fileout,
|
|
IMAGE_FIRST_SECTION(pNTHeaders),
|
|
pNTHeaders->FileHeader.NumberOfSections*sizeof(IMAGE_SECTION_HEADER),
|
|
p,
|
|
pStab,
|
|
nStabLen,
|
|
pStr,
|
|
nStabStrLen,
|
|
(char*)pSymTab,
|
|
nSym*sizeof(IMAGE_SYMBOL),
|
|
pStrTab,
|
|
nSymStrLen);
|
|
|
|
CloseHandle(fileout);
|
|
}
|
|
else
|
|
{
|
|
printf("LOADER: creation of symbol file %s failed\n",szSymName);
|
|
iRetVal = 2;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
printf("LOADER: file %s has no data inside symbol tables\n",filename);
|
|
if( ulGlobalVerbose )
|
|
{
|
|
if( !pStab || !nStabLen )
|
|
printf("LOADER: - symbol table is empty or not present\n");
|
|
if( !pStr || !nStabStrLen )
|
|
printf("LOADER: - string table is empty or not present\n");
|
|
}
|
|
iRetVal = 2;
|
|
}
|
|
}
|
|
else{
|
|
printf("LOADER: file %s does not have a symbol table\n",filename);
|
|
iRetVal = 2;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
printf("LOADER: file %s is not an ELF binary\n",filename);
|
|
iRetVal = 1;
|
|
}
|
|
|
|
//printf("LOADER: leave process_pe()\n");
|
|
return iRetVal;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
// process_file()
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
int process_file(char* filename)
|
|
{
|
|
int file;
|
|
void* p;
|
|
off_t len;
|
|
int iRetVal=0;
|
|
|
|
//printf("LOADER: enter process_file()\n");
|
|
file = _open(filename,O_RDONLY|_O_BINARY);
|
|
if(file>0)
|
|
{
|
|
//printf("LOADER: opened %s as FD %x\n",filename,file);
|
|
|
|
len = _lseek(file,0,SEEK_END);
|
|
printf("LOADER: file %s is %u bytes\n",filename,(int)len);
|
|
|
|
_lseek(file,0,SEEK_SET);
|
|
|
|
p = malloc(len+16);
|
|
if(p)
|
|
{
|
|
long count;
|
|
//printf("LOADER: malloc'd @ %x\n",p);
|
|
memset(p,0,len+16);
|
|
if(len == (count = _read(file,p,len)))
|
|
{
|
|
//printf("LOADER: trying ELF format\n");
|
|
iRetVal = process_pe(filename,file,p,len);
|
|
}
|
|
}
|
|
_close(file);
|
|
}
|
|
else
|
|
{
|
|
printf("LOADER: file %s could not be opened\n",filename);
|
|
iRetVal = 1;
|
|
}
|
|
|
|
//printf("LOADER: leave process_file()\n");
|
|
return iRetVal;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
// open_debugger()
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
HANDLE open_debugger(void)
|
|
{
|
|
debugger_file = CreateFile("\\Device\\Pice",GENERIC_READ,0,NULL,OPEN_EXISTING,NULL,NULL);
|
|
if(debugger_file == INVALID_HANDLE_VALUE)
|
|
{
|
|
printf("LOADER: debugger is not loaded. Last Error: %ld\n", GetLastError());
|
|
}
|
|
|
|
return debugger_file;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
// close_debugger()
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
void close_debugger(void)
|
|
{
|
|
if( !CloseHandle(debugger_file) ){
|
|
printf("Error closing debugger handle: %ld\n", GetLastError());
|
|
}
|
|
}
|
|
|
|
int ioctl( HANDLE device, DWORD ioctrlcode, PDEBUGGER_STATUS_BLOCK psb)
|
|
{
|
|
DEBUGGER_STATUS_BLOCK tsb;
|
|
DWORD bytesreturned;
|
|
if( !DeviceIoControl( device, ioctrlcode, psb, sizeof(DEBUGGER_STATUS_BLOCK),
|
|
&tsb, sizeof(DEBUGGER_STATUS_BLOCK),&bytesreturned, NULL) ){
|
|
printf("Error in DeviceIoControl: %ld\n", GetLastError());
|
|
return -EINVAL;
|
|
}
|
|
else{
|
|
memcpy( psb, &tsb, sizeof(DEBUGGER_STATUS_BLOCK) );
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
// banner()
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
void banner(void)
|
|
{
|
|
printf("#########################################################\n");
|
|
printf("#### Symbols LOADER/TRANSLATOR for PICE ####\n");
|
|
printf("#########################################################\n");
|
|
}
|
|
|
|
#define ACTION_NONE 0
|
|
#define ACTION_LOAD 1
|
|
#define ACTION_UNLOAD 2
|
|
#define ACTION_TRANS 3
|
|
#define ACTION_RELOAD 4
|
|
#define ACTION_INSTALL 5
|
|
#define ACTION_UNINSTALL 6
|
|
#define ACTION_STATUS 7
|
|
#define ACTION_BREAK 8
|
|
#define ACTION_TERMINAL 9
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
// change_symbols()
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
void change_symbols(int action,char* pfilename)
|
|
{
|
|
int iRetVal = 0;
|
|
DEBUGGER_STATUS_BLOCK sb;
|
|
|
|
strcpy(sb.filename, pfilename);
|
|
|
|
switch(action)
|
|
{
|
|
case ACTION_LOAD:
|
|
printf("LOADER: loading symbols from %s\n",pfilename);
|
|
if(open_debugger() != INVALID_HANDLE_VALUE)
|
|
{
|
|
iRetVal = ioctl(debugger_file,PICE_IOCTL_LOAD,&sb);
|
|
close_debugger();
|
|
}
|
|
break;
|
|
case ACTION_UNLOAD:
|
|
printf("LOADER: unloading symbols from %s\n",pfilename);
|
|
if(open_debugger() != INVALID_HANDLE_VALUE)
|
|
{
|
|
iRetVal = ioctl(debugger_file,PICE_IOCTL_UNLOAD,&sb);
|
|
close_debugger();
|
|
}
|
|
break;
|
|
case ACTION_RELOAD:
|
|
printf("LOADER: reloading all symbols\n");
|
|
if(open_debugger() != INVALID_HANDLE_VALUE)
|
|
{
|
|
ioctl(debugger_file,PICE_IOCTL_RELOAD,NULL);
|
|
close_debugger();
|
|
printf("LOADER: reloading DONE!\n");
|
|
}
|
|
break;
|
|
default :
|
|
printf("LOADER: an internal error has occurred at change_symbols\n");
|
|
}
|
|
|
|
switch( iRetVal )
|
|
{
|
|
case -EINVAL :
|
|
printf("LOADER: debugger return value = -EINVAL, operation has failed\n");
|
|
break;
|
|
case 0 :
|
|
// success - silently proceed
|
|
break;
|
|
default :
|
|
printf("LOADER: debugger return value = %i, operation possibly failed\n",iRetVal);
|
|
}
|
|
}
|
|
|
|
// Dynamic install to be added later
|
|
#if 0
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
// tryinstall()
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
int tryinstall(void)
|
|
{
|
|
char *argv[]={"/sbin/insmod","pice.o",NULL};
|
|
int err = 0;
|
|
int pid,status;
|
|
|
|
banner();
|
|
printf("LOADER: trying to install debugger...\n");
|
|
|
|
if( open_debugger() != INVALID_HANDLE_VALUE )
|
|
{
|
|
printf("LOADER: debugger already installed...\n");
|
|
close_debugger();
|
|
return 0;
|
|
}
|
|
|
|
// create a separate thread
|
|
pid = fork();
|
|
switch(pid)
|
|
{
|
|
case -1:
|
|
// error when forking, i.e. out E_NOMEM
|
|
err = errno;
|
|
printf("LOADER: fork failed for execution of '%s' (errno = %u).\n",argv[0],err);
|
|
break;
|
|
case 0:
|
|
// child process handler
|
|
execve(argv[0],argv,NULL);
|
|
// returns only on error, with return value -1, errno is set
|
|
printf("LOADER: couldn't execute '%s' (errno = %u)\n",argv[0],errno);
|
|
exit(255);
|
|
break;
|
|
default:
|
|
// parent process handler
|
|
printf("LOADER: waiting for debugger to load...\n");
|
|
pid = waitpid(pid, &status, 0); // suspend until child is done
|
|
if( (pid>0) && WIFEXITED(status) && (WEXITSTATUS(status) == 0) )
|
|
printf("LOADER: debugger loaded!\n");
|
|
else if( pid<=0 )
|
|
{
|
|
printf("LOADER: Error on loading debugger! (waitpid() = %i)\n",pid);
|
|
err = -1;
|
|
}
|
|
else if( !WIFEXITED(status) )
|
|
{
|
|
printf("LOADER: Error on loading debugger! (ifexited = %i)\n",WIFEXITED(status));
|
|
err = -1;
|
|
}
|
|
else
|
|
{
|
|
printf("LOADER: Error on loading debugger! (exitstatus = %u)\n",WEXITSTATUS(status));
|
|
err = WEXITSTATUS(status);
|
|
}
|
|
break;
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
// tryuninstall()
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
int tryuninstall(void)
|
|
{
|
|
char *argv[]={"/sbin/rmmod","pice",NULL};
|
|
int err = 0;
|
|
int pid,status;
|
|
|
|
banner();
|
|
printf("LOADER: trying to remove debugger...\n");
|
|
|
|
// check for loaded debugger
|
|
if(open_debugger() == INVALID_HANDLE_VALUE)
|
|
{
|
|
return -1;
|
|
}
|
|
// don't to close, else we'll have a reference count != 0
|
|
close_debugger();
|
|
|
|
// create a separate thread
|
|
pid = fork();
|
|
switch(pid)
|
|
{
|
|
case -1:
|
|
// error when forking, i.e. out E_NOMEM
|
|
err = errno;
|
|
printf("LOADER: fork failed for execution of '%s' (errno=%u).\n",argv[0],err);
|
|
break;
|
|
case 0:
|
|
// child process handler
|
|
execve(argv[0],argv,NULL);
|
|
// returns only on error, with return value -1, errno is set
|
|
printf("LOADER: couldn't execute '%s' (errno = %u)\n",argv[0],errno);
|
|
exit(255);
|
|
break;
|
|
default:
|
|
// parent process handler
|
|
printf("LOADER: waiting for debugger to unload...\n");
|
|
pid = waitpid(pid, &status, 0); // suspend until child is done
|
|
|
|
if( (pid>0) && WIFEXITED(status) && (WEXITSTATUS(status) == 0) )
|
|
printf("LOADER: debugger removed!\n");
|
|
else if( pid<=0 )
|
|
{
|
|
printf("LOADER: Error on removing debugger! (waitpid() = %i)\n",pid);
|
|
err = -1;
|
|
}
|
|
else if( !WIFEXITED(status) )
|
|
{
|
|
printf("LOADER: Error on removing debugger! (ifexited = %i)\n",WIFEXITED(status));
|
|
err = -1;
|
|
}
|
|
else
|
|
{
|
|
printf("LOADER: Error on removing debugger! (exitstatus = %u)\n",WEXITSTATUS(status));
|
|
err = WEXITSTATUS(status);
|
|
}
|
|
break;
|
|
}
|
|
return err;
|
|
}
|
|
#endif
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
// showstatus()
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
void showstatus(void)
|
|
{
|
|
DEBUGGER_STATUS_BLOCK sb;
|
|
int iRetVal;
|
|
|
|
if(open_debugger() != INVALID_HANDLE_VALUE)
|
|
{
|
|
iRetVal = ioctl(debugger_file,PICE_IOCTL_STATUS,&sb);
|
|
|
|
//printf("LOADER: Test = %X\n",sb.Test);
|
|
close_debugger();
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
// dobreak()
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
void dobreak(void)
|
|
{
|
|
int iRetVal;
|
|
|
|
if(open_debugger() != INVALID_HANDLE_VALUE)
|
|
{
|
|
iRetVal = ioctl(debugger_file,PICE_IOCTL_BREAK,NULL);
|
|
close_debugger();
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
// doterminal()
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
#if 0
|
|
void doterminal(void)
|
|
{
|
|
if(SetupSerial(2,B115200))
|
|
{
|
|
DebuggerShell();
|
|
CloseSerial();
|
|
}
|
|
}
|
|
#endif
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
// process_switches()
|
|
//
|
|
// returns !=0 in case of a commandline error
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
int process_switches(int argc,char* argv[])
|
|
{
|
|
int i;
|
|
char* parg,*pfilename = NULL;
|
|
int action = ACTION_NONE;
|
|
int error = 0;
|
|
|
|
// parse commandline arguments
|
|
for(i=1;i<argc;i++)
|
|
{
|
|
parg = argv[i];
|
|
if(*parg == '-')
|
|
{
|
|
int new_action=ACTION_NONE;
|
|
|
|
parg++;
|
|
if(strcmp(parg,"load")==0 || strcmp(parg,"l")==0)
|
|
{
|
|
new_action = ACTION_LOAD;
|
|
}
|
|
else if(strcmp(parg,"unload")==0 || strcmp(parg,"u")==0)
|
|
{
|
|
new_action = ACTION_UNLOAD;
|
|
}
|
|
else if(strcmp(parg,"trans")==0 || strcmp(parg,"t")==0)
|
|
{
|
|
new_action = ACTION_TRANS;
|
|
}
|
|
else if(strcmp(parg,"reload")==0 || strcmp(parg,"r")==0)
|
|
{
|
|
new_action = ACTION_RELOAD;
|
|
}
|
|
else if(strcmp(parg,"verbose")==0 || strcmp(parg,"v")==0)
|
|
{
|
|
if( ulGlobalVerbose+1 > ulGlobalVerbose )
|
|
ulGlobalVerbose++;
|
|
}
|
|
else if(strcmp(parg,"install")==0 || strcmp(parg,"i")==0)
|
|
{
|
|
new_action = ACTION_INSTALL;
|
|
}
|
|
else if(strcmp(parg,"uninstall")==0 || strcmp(parg,"x")==0)
|
|
{
|
|
new_action = ACTION_UNINSTALL;
|
|
}
|
|
else if(strcmp(parg,"status")==0 || strcmp(parg,"s")==0)
|
|
{
|
|
new_action = ACTION_STATUS;
|
|
}
|
|
else if(strcmp(parg,"break")==0 || strcmp(parg,"b")==0)
|
|
{
|
|
new_action = ACTION_BREAK;
|
|
}
|
|
else if(strcmp(parg,"serial")==0 || strcmp(parg,"ser")==0)
|
|
{
|
|
new_action = ACTION_TERMINAL;
|
|
}
|
|
else
|
|
{
|
|
printf("LOADER: error: unknown switch %s", argv[i]);
|
|
error = 1;
|
|
}
|
|
|
|
if( new_action != ACTION_NONE )
|
|
{
|
|
if( action == ACTION_NONE )
|
|
action = new_action;
|
|
else
|
|
if( action == new_action )
|
|
{
|
|
// identical, just ignore
|
|
}
|
|
else
|
|
{
|
|
printf("LOADER: error: conflicting switch %s", argv[i]);
|
|
error = 1;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( pfilename )
|
|
{
|
|
printf("LOADER: error: additional filename %s", parg);
|
|
error = 1;
|
|
}
|
|
pfilename = parg;
|
|
}
|
|
}
|
|
|
|
// check number of required parameters
|
|
switch( action )
|
|
{
|
|
case ACTION_TRANS :
|
|
case ACTION_LOAD :
|
|
case ACTION_UNLOAD :
|
|
if( !pfilename )
|
|
{
|
|
printf("LOADER: error: missing filename\n");
|
|
error = 1;
|
|
}
|
|
break;
|
|
case ACTION_RELOAD :
|
|
/* filename parameter is optional */
|
|
break;
|
|
#if 0
|
|
case ACTION_UNINSTALL:
|
|
close_debugger();
|
|
tryuninstall();
|
|
break;
|
|
case ACTION_INSTALL:
|
|
tryinstall();
|
|
break;
|
|
#endif
|
|
case ACTION_STATUS:
|
|
showstatus();
|
|
break;
|
|
case ACTION_BREAK:
|
|
dobreak();
|
|
break;
|
|
#if 0
|
|
case ACTION_TERMINAL:
|
|
doterminal();
|
|
break;
|
|
#endif
|
|
case ACTION_NONE :
|
|
printf("LOADER: no action specified specifed on commandline\n");
|
|
error = 1;
|
|
|
|
break;
|
|
default :
|
|
printf("LOADER: an internal error has occurred at commandline parsing\n");
|
|
error = 1;
|
|
}
|
|
|
|
if( !error ) // commandline was fine, now start processing
|
|
{
|
|
switch( action )
|
|
{
|
|
case ACTION_TRANS :
|
|
printf("LOADER: trying to translate file %s...\n",pfilename);
|
|
if( process_file(pfilename)==0 )
|
|
printf("LOADER: file %s has been translated\n",pfilename);
|
|
else
|
|
printf("LOADER: error while translating file %s\n",pfilename);
|
|
break;
|
|
case ACTION_LOAD :
|
|
case ACTION_UNLOAD :
|
|
case ACTION_RELOAD :
|
|
change_symbols(action,pfilename);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
// showhelp()
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
void showhelp(void)
|
|
{
|
|
banner();
|
|
printf("LOADER: Syntax:\n");
|
|
printf("LOADER: loader [switches] [executable/object file path]\n");
|
|
printf("LOADER: Switches:\n");
|
|
printf("LOADER: -trans (-t): translate from exe to sym\n");
|
|
printf("LOADER: -load (-l): load symbols\n");
|
|
printf("LOADER: -unload (-u): unload symbols\n");
|
|
printf("LOADER: -reload (-r): reload some/all symbols\n");
|
|
printf("LOADER: -verbose (-v): be a bit more verbose\n");
|
|
printf("LOADER: -install (-i): install pICE debugger\n");
|
|
printf("LOADER: -uninstall (-x): uninstall pICE debugger\n");
|
|
printf("LOADER: -break (-b): break into debugger\n");
|
|
printf("LOADER: -serial (-ser): start serial line terminal\n");
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
// showpermission()
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
void showpermission(void)
|
|
{
|
|
banner();
|
|
printf("LOADER: You must be superuser!\n");
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
// main()
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
int main(int argc,char* argv[])
|
|
{
|
|
if(argc==1 || argc>3)
|
|
{
|
|
showhelp();
|
|
|
|
return 1;
|
|
}
|
|
|
|
return process_switches(argc,argv);
|
|
}
|