symbols.c

Linux下的类似softice的调试工具

/******************************************************************************
 *
 * Copyright (c) 2003 Gerhard W. Gruber
 *
 * PROJECT: pICE
 * $Source: /cvsroot/pice/pice/module/symbols.c,v $
 * $Revision: 1.5 $
 * $Date: 2004/02/17 23:07:37 $
 * $Author: lightweave $
 * $Name:  $
 *
 * $Log: symbols.c,v $
 * Revision 1.5  2004/02/17 23:07:37  lightweave
 *
 * Improved the DEBUG facillity and replaced the configuration handler with a
 * new code which now can read MS Windows INI style files. See CHANGES.txt for
 * more details.
 * Also added a macro which prevents compiling for kernels before 2.4.19.
 *
 * Revision 1.4  2003/06/18 22:00:22  lightweave
 * DEBUG and DEBUG_SERIAL added
 *
 *
 *****************************************************************************/

static char *ident = "$Header: /cvsroot/pice/pice/module/symbols.c,v 1.5 2004/02/17 23:07:37 lightweave Exp $";


/*++

Copyright (c) 1998-2001 Klaus P. Gerlicher

Module ModuleName:

    symbols.c

Abstract:

Environment:

    Kernel mode only

Author:

    Klaus P. Gerlicher

Revision History:

    19-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 "remods.h"

#include <linux/elf.h>
#include <linux/vmalloc.h>
#include <asm/io.h>
#include <asm/page.h>
#include <asm/pgtable.h>
#include <linux/fs.h>
#include <linux/vmalloc.h>
#include <asm/uaccess.h>
#include <asm/delay.h>
#include <linux/ctype.h>

#include "stab_gnu.h"
#include "precomp.h"
#include "config.h" 
#include "utils.h"

PVOID pSystemMap = NULL;
ULONG ulSystemMapSize = 0;

LOCAL_VARIABLE local_vars[512];

ULONG ulNumSymbolsLoaded=0;
PICE_SYMBOLFILE_HEADER *apSymbols[32]={NULL,};

ULONG kernel_end=0;

// artificial module structure if address is in kernel
struct module fake_kernel_module;

static char tempSym[1024]; // temp buffer for output
static char SymbolFileName[256];

typedef struct _VRET
{
	ULONG value;
	ULONG type;
	ULONG father_type;
	ULONG error;
	ULONG file;
    ULONG size;
    ULONG address;
    char name[256];
    char type_name[256];
    BOOLEAN bPtrType;
    BOOLEAN bStructType;
    BOOLEAN bArrayType;
	PICE_SYMBOLFILE_HEADER* pSymbols;
} VRET, *PVRET;

ULONG ulIndex;
LPSTR pExpression;
VRET vr;
VRET vrStructMembers[1024];
ULONG ulNumStructMembers;

BOOLEAN Expression(PVRET pvr);

//************************************************************************* 
// InitFakeKernelModule() 
// 
//************************************************************************* 
BOOLEAN InitFakeKernelModule(void)
{
    struct module* pMod;

    ENTER_FUNC();
    
    if(pmodule_list)
    {
	    DPRINT(PICE_DEBUG, DBT_SYMBOLS, DBL_INFO, "InitFakeKernelModule(): pmodule_list = %x pmodule_list = %x\n", (ULONG)pmodule_list,(ULONG)pmodule_list);
		if(IsAddressValid((ULONG)pmodule_list) )
		{
			pMod = pmodule_list;
			DPRINT(PICE_DEBUG, DBT_SYMBOLS, DBL_INFO, "start pMod = %x\n", (ULONG)pMod);
			do
			{
				if(!pMod->size)
				{
					DPRINT(PICE_DEBUG, DBT_SYMBOLS, DBL_INFO, "pMod = %x\n", (ULONG)pMod);
					fake_kernel_module = * pMod;
					PICE_strcpy((LPSTR)(fake_kernel_module.name), "vmlinux");
					fake_kernel_module.size = kernel_end - KERNEL_START;
				    DPRINT(PICE_DEBUG, DBT_SYMBOLS, DBL_INFO, "SUCCESS\n");
                    LEAVE_FUNC();
					return TRUE;
				}
			}while((pMod = pMod->next));
		}
    }
    else
    {
		DPRINT(PICE_DEBUG, DBT_SYMBOLS, DBL_INFO, "pModuleList = NULL\n");
    }
    LEAVE_FUNC();
	return FALSE;
}

///////////////////////////////////////////////////////////////////////////
/// SYMBOL STUFF
///////////////////////////////////////////////////////////////////////////

//************************************************************************* 
// ScanSystemMap() 
// 
//************************************************************************* 
BOOLEAN ScanSystemMap(const char *pFind,PULONG pValue)
{
	char temp[256];
	LPSTR pStr=NULL;
	LPSTR pExp = pSystemMap;
	BOOLEAN bResult = FALSE;

	ENTER_FUNC();

nomatch:
	if(pSystemMap)
		pStr = strstr(pExp,pFind);

	if(pStr)
	{
		LPSTR p;
		ULONG state;
		LPSTR pOldStr = pStr;

		for(;*pStr!=0x0a && (ULONG)pStr>=(ULONG)pSystemMap;pStr--);
		pStr++;
		p = temp;
		for(;*pStr!=0x0a;)
			 *p++=*pStr++;
		*p=0;
		p = strtok(temp, " ");
		state=0;
		while(p)
		{
			switch(state)
			{
				case 0:
				{
				   ConvertTokenToHex(p,pValue);
				}
				break;
				case 1:
				break;
				case 2:
				{
					 if(strcmp(p, (char *)pFind)!=0)
					 {
						  pExp = pOldStr+1;	
						  goto nomatch;
					 }
					 state = -1;
					 bResult = TRUE;
					 DPRINT(PICE_DEBUG, DBT_SYMBOLS, DBL_INFO, "%s @ %x\n", pFind,*pValue);
				}
				break;
			}
			state++;
			p = strtok(NULL, " ");
		}
	}

	LEAVE_FUNC();
	return bResult;
}

//************************************************************************* 
// ScanExportLine() 
// 
//************************************************************************* 
BOOLEAN ScanExportLine(LPSTR p,PULONG ulValue,LPSTR* ppPtrToSymbol)
{
    BOOLEAN bResult = FALSE;

    if(ReadHex(p,ulValue))
    {
        p += 11;
        *ppPtrToSymbol += 11;
        bResult = TRUE;
    }

    return bResult;
}

//************************************************************************* 
// ValidityCheckSymbols() 
// 
//************************************************************************* 
BOOLEAN ValidityCheckSymbols(PICE_SYMBOLFILE_HEADER* pSymbols)
{
	BOOLEAN bRet;

	ENTER_FUNC();

	bRet = (((ULONG)pSymbols>=TASK_SIZE) &&
			IsRangeValid((ULONG)pSymbols + pSymbols->ulOffsetToHeaders,pSymbols->ulSizeOfHeader) &&
		    IsRangeValid((ULONG)pSymbols + pSymbols->ulOffsetToGlobals,pSymbols->ulSizeOfGlobals) &&
		    IsRangeValid((ULONG)pSymbols + pSymbols->ulOffsetToGlobalsStrings,pSymbols->ulSizeOfGlobalsStrings) &&
		    IsRangeValid((ULONG)pSymbols + pSymbols->ulOffsetToStabs,pSymbols->ulSizeOfStabs) &&
		    IsRangeValid((ULONG)pSymbols + pSymbols->ulOffsetToStabsStrings,pSymbols->ulSizeOfStabsStrings) );

    DPRINT(PICE_DEBUG, DBT_SYMBOLS, DBL_INFO, "symbols are %s\n", bRet?"VALID":"NOT VALID");

	LEAVE_FUNC();
	return bRet;
}

//************************************************************************* 
// SanityCheckSystemMap() 
// 
//************************************************************************* 
BOOLEAN SanityCheckSystemMap(void)
{
    BOOLEAN bResult = FALSE;
    ULONG i,ulValue,incr;

    Print(OUTPUT_WINDOW, "pICE: sanity-checking System.map...\n");

    if(fake_kernel_module.nsyms && fake_kernel_module.syms)
    {
        incr = (fake_kernel_module.nsyms/4);
        if(!incr)incr = 1;
        for(i=0;i<fake_kernel_module.nsyms;i+=incr)
        {
            if(ScanSystemMap((char*)fake_kernel_module.syms[i].name,&ulValue) )
            {
                if(!(i%25))
                {
                    ClrLines(wWindow[OUTPUT_WINDOW].y + wWindow[OUTPUT_WINDOW].usCurY,1);
                    PICE_sprintf(tempSym, "pICE: sanity-checking System.map %u/%u", 
                                          i,
                                          fake_kernel_module.nsyms);
                    PutChar(tempSym,1,wWindow[OUTPUT_WINDOW].y + wWindow[OUTPUT_WINDOW].usCurY);
                }

                if(fake_kernel_module.syms[i].value != ulValue)
                {
                    PICE_sprintf(tempSym, "pICE: %s doesn't match (%.8X != %.8X)\n", 
                                 fake_kernel_module.syms[i].name,
                                 fake_kernel_module.syms[i].value,
                                 ulValue);
                    Print(OUTPUT_WINDOW,tempSym);

                    return FALSE;
                }
            }
        }

        bResult = TRUE;
    }

    return bResult;
}

//************************************************************************* 
// LoadSystemMap() 
// 
//************************************************************************* 
BOOLEAN LoadSystemMap(void)
{
	struct file *pf;
    BOOLEAN bResult = TRUE;

	ENTER_FUNC();
	
    Print(OUTPUT_WINDOW, "pICE: loading System.map...\n");
	pf = filp_open("/boot/System.map", O_RDONLY,S_IRUSR);

	if(IS_ERR(pf))
    {
        Print(OUTPUT_WINDOW, "pICE: no System.map in /boot\n");
	    pf = filp_open("/System.map", O_RDONLY,S_IRUSR);
    }

    if(!IS_ERR(pf))
	{
		size_t len;

        if(pf->f_op)
        {
		    len = pf->f_dentry->d_inode->i_size;
            if(len)
            {
		        DPRINT(PICE_DEBUG, DBT_SYMBOLS, DBL_INFO, "file len = %d\n", len);

				pSystemMap = PICE_HeapAlloc(len+1);

		        DPRINT(PICE_DEBUG, DBT_SYMBOLS, DBL_INFO, "pSystemMap = %p\n", pSystemMap);

                PICE_sprintf(tempSym, "pICE: System.map loaded @ %p (size %x)\n", pSystemMap, len);
		        Print(OUTPUT_WINDOW,tempSym);
		        
                if(pSystemMap)
		        {
                    ulSystemMapSize = len;
			        ((PUCHAR)pSystemMap)[len]=0;
			        if(len == kernel_read(pf, 0, pSystemMap, len))
			        {
				        DPRINT(PICE_DEBUG, DBT_SYMBOLS, DBL_INFO, "success reading system map!\n");
			        }
		        }
            }
        }

		filp_close(pf,0);
	}
    else
    {
        Print(OUTPUT_WINDOW, "pICE: also no System.map in /\n");
        bResult = FALSE;
    }

    LEAVE_FUNC();

    return bResult;
}

//************************************************************************* 
// UnloadSystemMap() 
// 
//************************************************************************* 
void UnloadSystemMap(void)
{
	ENTER_FUNC();
	if(pSystemMap)
	{	
		DPRINT(PICE_DEBUG, DBT_SYMBOLS, DBL_INFO, "freeing %p\n", pSystemMap);
		PICE_HeapFree(pSystemMap);
        pSystemMap = NULL;