DBGFAddrSpace.cpp revision 9939c713bffcfc4305d99d994552aa2ad9bce097
/* $Id$ */
/** @file
* DBGF - Debugger Facility, Address Space Management.
*/
/*
* Copyright (C) 2008 Sun Microsystems, Inc.
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
* Clara, CA 95054 USA or visit http://www.sun.com if you need
* additional information or have any questions.
*/
/** @page pg_dbgf_addr_space DBGFAddrSpace - Address Space Management
*
* What's an address space? It's mainly a convenient way of stuffing
* module segments and ad-hoc symbols together. It will also help out
* when the debugger gets extended to deal with user processes later.
*
* There are two standard address spaces that will always be present:
* - The physical address space.
* - The global virtual address space.
*
* Additional address spaces will be added and removed at runtime for
* guest processes. The global virtual address space will be used to
* track the kernel parts of the OS, or at least the bits of the kernel
* that is part of all address spaces (mac os x and 4G/4G patched linux).
*
*/
/*******************************************************************************
* Header Files *
*******************************************************************************/
#define LOG_GROUP LOG_GROUP_DBGF
#include "DBGFInternal.h"
/*******************************************************************************
* Structures and Typedefs *
*******************************************************************************/
/**
* Address space database node.
*/
typedef struct DBGFASDBNODE
{
/** The node core for DBGF::AsHandleTree, the key is the address space handle. */
/** The node core for DBGF::AsPidTree, the key is the process id. */
/** The node core for DBGF::AsNameSpace, the string is the address space name. */
} DBGFASDBNODE;
/** Pointer to an address space database node. */
typedef DBGFASDBNODE *PDBGFASDBNODE;
/**
* For dbgfR3AsLoadImageOpenData and dbgfR3AsLoadMapOpenData.
*/
typedef struct DBGFR3ASLOADOPENDATA
{
const char *pszModName;
/**
* Callback for dbgfR3AsSearchPath and dbgfR3AsSearchEnvPath.
*
* @returns VBox status code. If success, then the search is completed.
* @param pszFilename The file name under evaluation.
* @param pvUser The user argument.
*/
/** Pointer to a FNDBGFR3ASSEARCHOPEN. */
typedef FNDBGFR3ASSEARCHOPEN *PFNDBGFR3ASSEARCHOPEN;
/*******************************************************************************
* Defined Constants And Macros *
*******************************************************************************/
/** Locks the address space database for writing. */
#define DBGF_AS_DB_LOCK_WRITE(pVM) \
do { \
} while (0)
/** Unlocks the address space database after writing. */
#define DBGF_AS_DB_UNLOCK_WRITE(pVM) \
do { \
} while (0)
/** Locks the address space database for reading. */
#define DBGF_AS_DB_LOCK_READ(pVM) \
do { \
} while (0)
/** Unlocks the address space database after reading. */
#define DBGF_AS_DB_UNLOCK_READ(pVM) \
do { \
} while (0)
/**
* Initializes the address space parts of DBGF.
*
* @returns VBox status code.
* @param pVM The VM handle.
*/
{
/*
* Create the semaphore.
*/
/*
* Create the standard address spaces.
*/
return VINF_SUCCESS;
}
/**
* Callback used by dbgfR3AsTerm / RTAvlPVDestroy to release an address space.
*
* @returns 0.
* @param pNode The address space database node.
* @param pvIgnore NULL.
*/
{
/* Don't bother freeing it here as MM will free it soon and MM is much at
it when doing it wholesale instead of piecemeal. */
return 0;
}
/**
* Terminates the address space parts of DBGF.
*
* @param pVM The VM handle.
*/
{
/*
* Create the semaphore.
*/
/*
* Release all the address spaces.
*/
{
}
}
/**
* Relocates the RC address space.
*
* @param pVM The VM handle.
* @param offDelta The relocation delta.
*/
{
/** @todo */
}
/**
* Adds the address space to the database.
*
* @returns VBox status code.
* @param pVM The VM handle.
* @param hDbgAs The address space handle. The reference of the
* caller will NOT be consumed.
* @param ProcId The process id or NIL_RTPROCESS.
*/
{
/*
* Input validation.
*/
if (!pszName)
return VERR_INVALID_HANDLE;
if (cRefs == UINT32_MAX)
return VERR_INVALID_HANDLE;
/*
* Allocate a tracking node.
*/
int rc = VERR_NO_MEMORY;
if (pDbNode)
{
{
{
return VINF_SUCCESS;
}
/* bail out */
}
}
return rc;
}
/**
* Delete an address space from the database.
*
* The address space must not be engaged as any of the standard aliases.
*
* @returns VBox status code.
* @retval VERR_SHARING_VIOLATION if in use as an alias.
* @retval VERR_NOT_FOUND if not found in the address space database.
*
* @param pVM The VM handle.
* @param hDbgAs The address space handle. Aliases are not allowed.
*/
{
/*
* Input validation. Retain the address space so it can be released outside
* the lock as well as validated.
*/
if (hDbgAs == NIL_RTDBGAS)
return VINF_SUCCESS;
if (cRefs == UINT32_MAX)
return VERR_INVALID_HANDLE;
/*
* You cannot delete any of the aliases.
*/
{
return VERR_SHARING_VIOLATION;
}
/*
* Ok, try remove it from the database.
*/
if (!pDbNode)
{
return VERR_NOT_FOUND;
}
/*
* Free the resources.
*/
return VINF_SUCCESS;
}
/**
* Changes an alias to point to a new address space.
*
* Not all the aliases can be changed, currently it's only DBGF_AS_GLOBAL
* and DBGF_AS_KERNEL.
*
* @returns VBox status code.
* @param pVM The VM handle.
* @param hAlias The alias to change.
* @param hAliasFor The address space hAlias should be an alias for.
* This can be an alias. The caller's reference to
* this address space will NOT be consumed.
*/
{
/*
* Input validation.
*/
if (hRealAliasFor == NIL_RTDBGAS)
return VERR_INVALID_HANDLE;
/*
* Make sure the handle has is already in the database.
*/
int rc = VERR_NOT_FOUND;
{
/*
* Update the alias table and release the current address space.
*/
ASMAtomicXchgHandle(&pVM->dbgf.s.ahAsAliases[DBGF_AS_ALIAS_2_INDEX(hAlias)], hRealAliasFor, &hAsOld);
rc = VINF_SUCCESS;
}
return rc;
}
/**
* Resolves the address space handle into a real handle if it's an alias.
*
* @returns Real address space handle. NIL_RTDBGAS if invalid handle.
*
* @param pVM The VM handle.
* @param hAlias The possibly address space alias.
*
* @remarks Doesn't take any locks.
*/
{
if (iAlias < DBGF_AS_COUNT)
return hAlias;
}
/**
* Resolves the address space handle into a real handle if it's an alias,
* and retains whatever it is.
*
* @returns Real address space handle. NIL_RTDBGAS if invalid handle.
*
* @param pVM The VM handle.
* @param hAlias The possibly address space alias.
*/
{
if (iAlias < DBGF_AS_COUNT)
{
if (DBGF_AS_IS_FIXED_ALIAS(hAlias))
{
/* Won't ever change, no need to grab the lock. */
}
else
{
/* May change, grab the lock so we can read it safely. */
}
}
else
/* Not an alias, just retain it. */
}
/**
* Query an address space by name.
*
* @returns Retained address space handle if found, NIL_RTDBGAS if not.
*
* @param pVM The VM handle.
* @param pszName The name.
*/
{
/*
* Validate the input.
*/
/*
* Look it up in the string space and retain the result.
*/
if (pNode)
{
}
return hDbgAs;
}
/**
* Query an address space by process ID.
*
* @returns Retained address space handle if found, NIL_RTDBGAS if not.
*
* @param pVM The VM handle.
* @param ProcId The process ID.
*/
{
/*
* Validate the input.
*/
/*
* Look it up in the PID tree and retain the result.
*/
if (pNode)
{
}
return hDbgAs;
}
/**
* Searches for the file in the path.
*
* The file is first tested without any path modification, then we walk the path
* looking in each directory.
*
* @returns VBox status code.
* @param pszFilename The file to search for.
* @param pszPath The search path.
* @param pfnOpen The open callback function.
* @param pvUser User argument for the callback.
*/
static int dbgfR3AsSearchPath(const char *pszFilename, const char *pszPath, PFNDBGFR3ASSEARCHOPEN pfnOpen, void *pvUser)
{
char szFound[RTPATH_MAX];
/* Check the filename length. */
if (cchFilename >= sizeof(szFound))
return VERR_FILENAME_TOO_LONG;
if (!pszName)
return VERR_IS_A_DIRECTORY;
/*
* Try default location first.
*/
if (RT_SUCCESS(rc))
return rc;
/*
* Walk the search path.
*/
while (*psz)
{
/* Skip leading blanks - no directories with leading spaces, thank you. */
while (RT_C_IS_BLANK(*psz))
psz++;
/* Fine the end of this element. */
const char *pszNext;
if (!pszEnd)
else
{
{
/** @todo RTPathCompose, RTPathComposeN(). This code isn't right
* for 'E:' on DOS systems. It may also create unwanted double slashes. */
if (RT_SUCCESS(rc2))
return rc2;
&& ( rc == VERR_FILE_NOT_FOUND
|| rc == VERR_OPEN_FAILED))
}
}
/* advance */
}
/*
* Walk the path once again, this time do a depth search.
*/
/** @todo do a depth search using the specified path. */
/* failed */
return rc;
}
/**
* Same as dbgfR3AsSearchEnv, except that the path is taken from the environment.
*
* It the environment variable doesn't exist, the current directory is searched instead.
*
* @returns VBox status code.
* @param pszFilename The filename.
* @param pszEnvVar The environment variable name.
* @param pfnOpen The open callback function.
* @param pvUser User argument for the callback.
*/
static int dbgfR3AsSearchEnvPath(const char *pszFilename, const char *pszEnvVar, PFNDBGFR3ASSEARCHOPEN pfnOpen, void *pvUser)
{
if (!pszPath)
pszPath = ".";
}
/**
* Callback function used by DBGFR3AsLoadImage.
*
* @returns VBox status code.
* @param pszFilename The filename under evaluation.
* @param pvUser Use arguments (DBGFR3ASLOADOPENDATA).
*/
{
}
/**
* Load symbols from an executable module into the specified address space.
*
* If an module exist at the specified address it will be replaced by this
* call, otherwise a new module is created.
*
* @returns VBox status code.
*
* @param pVM The VM handle.
* @param hDbgAs The address space.
* @param pszFilename The filename of the executable module.
* @param pszModName The module name. If NULL, then then the file name
* base is used (no extension or nothing).
* @param pModAddress The load address of the module.
* @param iModSeg The segment to load, pass NIL_RTDBGSEGIDX to load
* the whole image.
* @param fFlags Flags reserved for future extensions, must be 0.
*/
VMMR3DECL(int) DBGFR3AsLoadImage(PVM pVM, RTDBGAS hDbgAs, const char *pszFilename, const char *pszModName, PCDBGFADDRESS pModAddress, RTDBGSEGIDX iModSeg, uint32_t fFlags)
{
/*
* Validate input
*/
if (hRealAS == NIL_RTDBGAS)
return VERR_INVALID_HANDLE;
/*
* Do the work.
*/
Data.uSubtrahend = 0;
if (RT_FAILURE(rc))
if (RT_SUCCESS(rc))
{
if (RT_FAILURE(rc))
}
return rc;
}
/**
* Callback function used by DBGFR3AsLoadMap.
*
* @returns VBox status code.
* @param pszFilename The filename under evaluation.
* @param pvUser Use arguments (DBGFR3ASLOADOPENDATA).
*/
{
return RTDbgModCreateFromMap(&pData->hMod, pszFilename, pData->pszModName, pData->uSubtrahend, pData->fFlags);
}
/**
* Load symbols from a map file into a module at the specified address space.
*
* If an module exist at the specified address it will be replaced by this
* call, otherwise a new module is created.
*
* @returns VBox status code.
*
* @param pVM The VM handle.
* @param hDbgAs The address space.
* @param pszFilename The map file.
* @param pszModName The module name. If NULL, then then the file name
* base is used (no extension or nothing).
* @param pModAddress The load address of the module.
* @param iModSeg The segment to load, pass NIL_RTDBGSEGIDX to load
* the whole image.
* @param uSubtrahend Value to to subtract from the symbols in the map
* file. This is useful for the linux System.map and
* @param fFlags Flags reserved for future extensions, must be 0.
*/
VMMR3DECL(int) DBGFR3AsLoadMap(PVM pVM, RTDBGAS hDbgAs, const char *pszFilename, const char *pszModName,
{
/*
* Validate input
*/
if (hRealAS == NIL_RTDBGAS)
return VERR_INVALID_HANDLE;
/*
* Do the work.
*/
if (RT_FAILURE(rc))
if (RT_SUCCESS(rc))
{
if (RT_FAILURE(rc))
}
return rc;
}
/**
* Wrapper around RTDbgAsModuleLink, RTDbgAsModuleLinkSeg and DBGFR3AsResolve.
*
* @returns VBox status code.
* @param pVM The VM handle.
* @param hDbgAs The address space handle.
* @param hMod The module handle.
* @param pModAddress The link address.
* @param iModSeg The segment to link, NIL_RTDBGSEGIDX for the entire image.
* @param fFlags Flags to pass to the link functions, see RTDBGASLINK_FLAGS_*.
*/
VMMR3DECL(int) DBGFR3AsLinkModule(PVM pVM, RTDBGAS hDbgAs, RTDBGMOD hMod, PCDBGFADDRESS pModAddress, RTDBGSEGIDX iModSeg, uint32_t fFlags)
{
/*
* Input validation.
*/
if (hRealAS == NIL_RTDBGAS)
return VERR_INVALID_HANDLE;
/*
* Do the job.
*/
int rc;
if (iModSeg == NIL_RTDBGSEGIDX)
else
return rc;
}