Merge much of DFProcess-*-SHM.cpp into DFProcess-SHM.cpp.
Tom Prince
parent
9ba80d517f
commit
c287e54793
@ -0,0 +1,479 @@
|
|||||||
|
/*
|
||||||
|
www.sourceforge.net/projects/dfhack
|
||||||
|
Copyright (c) 2009 Petr Mrázek (peterix), Kenneth Ferland (Impaler[WrG]), dorf
|
||||||
|
|
||||||
|
This software is provided 'as-is', without any express or implied
|
||||||
|
warranty. In no event will the authors be held liable for any
|
||||||
|
damages arising from the use of this software.
|
||||||
|
|
||||||
|
Permission is granted to anyone to use this software for any
|
||||||
|
purpose, including commercial applications, and to alter it and
|
||||||
|
redistribute it freely, subject to the following restrictions:
|
||||||
|
|
||||||
|
1. The origin of this software must not be misrepresented; you must
|
||||||
|
not claim that you wrote the original software. If you use this
|
||||||
|
software in a product, an acknowledgment in the product documentation
|
||||||
|
would be appreciated but is not required.
|
||||||
|
|
||||||
|
2. Altered source versions must be plainly marked as such, and
|
||||||
|
must not be misrepresented as being the original software.
|
||||||
|
|
||||||
|
3. This notice may not be removed or altered from any source
|
||||||
|
distribution.
|
||||||
|
*/
|
||||||
|
#include "Internal.h"
|
||||||
|
#include "SHMProcess.h"
|
||||||
|
#include "dfhack/VersionInfo.h"
|
||||||
|
#include "dfhack/DFError.h"
|
||||||
|
#include "shms.h"
|
||||||
|
#include "mod-core.h"
|
||||||
|
|
||||||
|
using namespace DFHack;
|
||||||
|
|
||||||
|
SHMProcess::SHMProcess(uint32_t PID, vector <VersionInfo *> & known_versions)
|
||||||
|
: d(new Private(this))
|
||||||
|
{
|
||||||
|
d->process_ID = PID;
|
||||||
|
// attach the SHM
|
||||||
|
if(!attach())
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
// Test bridge version, get PID, sync Yield
|
||||||
|
bool bridgeOK;
|
||||||
|
if(!d->Aux_Core_Attach(bridgeOK,d->process_ID))
|
||||||
|
{
|
||||||
|
detach();
|
||||||
|
throw Error::SHMAttachFailure();
|
||||||
|
}
|
||||||
|
else if(!bridgeOK)
|
||||||
|
{
|
||||||
|
detach();
|
||||||
|
throw Error::SHMVersionMismatch();
|
||||||
|
}
|
||||||
|
|
||||||
|
// try to identify the DF version (md5 the binary, compare with known versions)
|
||||||
|
d->validate(known_versions);
|
||||||
|
// at this point, DF is attached and suspended, make it run
|
||||||
|
detach();
|
||||||
|
}
|
||||||
|
|
||||||
|
SHMProcess::~SHMProcess()
|
||||||
|
{
|
||||||
|
if(d->attached)
|
||||||
|
{
|
||||||
|
detach();
|
||||||
|
}
|
||||||
|
// destroy data model. this is assigned by processmanager
|
||||||
|
if(d->memdescriptor)
|
||||||
|
delete d->memdescriptor;
|
||||||
|
delete d;
|
||||||
|
}
|
||||||
|
|
||||||
|
VersionInfo * SHMProcess::getDescriptor()
|
||||||
|
{
|
||||||
|
return d->memdescriptor;
|
||||||
|
}
|
||||||
|
|
||||||
|
int SHMProcess::getPID()
|
||||||
|
{
|
||||||
|
return d->process_ID;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
bool SHMProcess::isSuspended()
|
||||||
|
{
|
||||||
|
return d->locked;
|
||||||
|
}
|
||||||
|
bool SHMProcess::isAttached()
|
||||||
|
{
|
||||||
|
return d->attached;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool SHMProcess::isIdentified()
|
||||||
|
{
|
||||||
|
return d->identified;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool SHMProcess::suspend()
|
||||||
|
{
|
||||||
|
if(!d->attached)
|
||||||
|
{
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
if(d->locked)
|
||||||
|
{
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
//cerr << "suspend" << endl;// FIXME: throw
|
||||||
|
// FIXME: this should be controlled on the server side
|
||||||
|
// FIXME: IF server got CORE_RUN in this frame, interpret CORE_SUSPEND as CORE_STEP
|
||||||
|
// did we just resume a moment ago?
|
||||||
|
if(D_SHMCMD == CORE_RUN)
|
||||||
|
{
|
||||||
|
//fprintf(stderr,"%d invokes step\n",attachmentIdx);
|
||||||
|
// wait for the next window
|
||||||
|
/*
|
||||||
|
if(!d->SetAndWait(CORE_STEP))
|
||||||
|
{
|
||||||
|
throw Error::SHMLockingError("if(!d->SetAndWait(CORE_STEP))");
|
||||||
|
}
|
||||||
|
*/
|
||||||
|
D_SHMCMD = CORE_STEP;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
//fprintf(stderr,"%d invokes suspend\n",attachmentIdx);
|
||||||
|
// lock now
|
||||||
|
/*
|
||||||
|
if(!d->SetAndWait(CORE_SUSPEND))
|
||||||
|
{
|
||||||
|
throw Error::SHMLockingError("if(!d->SetAndWait(CORE_SUSPEND))");
|
||||||
|
}
|
||||||
|
*/
|
||||||
|
D_SHMCMD = CORE_SUSPEND;
|
||||||
|
}
|
||||||
|
//fprintf(stderr,"waiting for lock\n");
|
||||||
|
// we wait for the server to give up our suspend lock (held by default)
|
||||||
|
if(acquireSuspendLock())
|
||||||
|
{
|
||||||
|
d->locked = true;
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
// FIXME: needs a good think-through
|
||||||
|
bool SHMProcess::asyncSuspend()
|
||||||
|
{
|
||||||
|
if(!d->attached)
|
||||||
|
{
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
if(d->locked)
|
||||||
|
{
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
//cerr << "async suspend" << endl;// FIXME: throw
|
||||||
|
uint32_t cmd = D_SHMCMD;
|
||||||
|
if(cmd == CORE_SUSPENDED)
|
||||||
|
{
|
||||||
|
// we have to hold the lock to be really suspended
|
||||||
|
if(acquireSuspendLock())
|
||||||
|
{
|
||||||
|
d->locked = true;
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
// did we just resume a moment ago?
|
||||||
|
if(cmd == CORE_STEP)
|
||||||
|
{
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
else if(cmd == CORE_RUN)
|
||||||
|
{
|
||||||
|
D_SHMCMD = CORE_STEP;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
D_SHMCMD = CORE_SUSPEND;
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
bool SHMProcess::forceresume()
|
||||||
|
{
|
||||||
|
return resume();
|
||||||
|
}
|
||||||
|
|
||||||
|
// FIXME: wait for the server to advance a step!
|
||||||
|
bool SHMProcess::resume()
|
||||||
|
{
|
||||||
|
if(!d->attached)
|
||||||
|
return false;
|
||||||
|
if(!d->locked)
|
||||||
|
return true;
|
||||||
|
//cerr << "resume" << endl;// FIXME: throw
|
||||||
|
// unlock the suspend lock
|
||||||
|
if(releaseSuspendLock())
|
||||||
|
{
|
||||||
|
d->locked = false;
|
||||||
|
if(d->SetAndWait(CORE_RUN)) // we have to make sure the server responds!
|
||||||
|
{
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
throw Error::SHMLockingError("if(d->SetAndWait(CORE_RUN))");
|
||||||
|
}
|
||||||
|
throw Error::SHMLockingError("if(releaseSuspendLock())");
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
// get module index by name and version. bool 0 = error
|
||||||
|
bool SHMProcess::getModuleIndex (const char * name, const uint32_t version, uint32_t & OUTPUT)
|
||||||
|
{
|
||||||
|
if(!d->locked) throw Error::MemoryAccessDenied();
|
||||||
|
|
||||||
|
modulelookup * payload = D_SHMDATA(modulelookup);
|
||||||
|
payload->version = version;
|
||||||
|
|
||||||
|
strncpy(payload->name,name,255);
|
||||||
|
payload->name[255] = 0;
|
||||||
|
|
||||||
|
if(!SetAndWait(CORE_ACQUIRE_MODULE))
|
||||||
|
{
|
||||||
|
return false; // FIXME: throw a fatal exception instead
|
||||||
|
}
|
||||||
|
if(D_SHMHDR->error)
|
||||||
|
{
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
//fprintf(stderr,"%s v%d : %d\n", name, version, D_SHMHDR->value);
|
||||||
|
OUTPUT = D_SHMHDR->value;
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool SHMProcess::Private::Aux_Core_Attach(bool & versionOK, pid_t & PID)
|
||||||
|
{
|
||||||
|
if(!locked) throw Error::MemoryAccessDenied();
|
||||||
|
|
||||||
|
SHMDATA(coreattach)->cl_affinity = OS_getAffinity();
|
||||||
|
if(!SetAndWait(CORE_ATTACH)) return false;
|
||||||
|
/*
|
||||||
|
cerr <<"CORE_VERSION" << CORE_VERSION << endl;
|
||||||
|
cerr <<"server CORE_VERSION" << SHMDATA(coreattach)->sv_version << endl;
|
||||||
|
*/
|
||||||
|
versionOK =( SHMDATA(coreattach)->sv_version == CORE_VERSION );
|
||||||
|
PID = SHMDATA(coreattach)->sv_PID;
|
||||||
|
useYield = SHMDATA(coreattach)->sv_useYield;
|
||||||
|
#ifdef DEBUG
|
||||||
|
if(useYield) cerr << "Using Yield!" << endl;
|
||||||
|
#endif
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
void SHMProcess::read (uint32_t src_address, uint32_t size, uint8_t *target_buffer)
|
||||||
|
{
|
||||||
|
if(!d->locked) throw Error::MemoryAccessDenied();
|
||||||
|
|
||||||
|
// normal read under 1MB
|
||||||
|
if(size <= SHM_BODY)
|
||||||
|
{
|
||||||
|
D_SHMHDR->address = src_address;
|
||||||
|
D_SHMHDR->length = size;
|
||||||
|
full_barrier
|
||||||
|
d->SetAndWait(CORE_READ);
|
||||||
|
memcpy (target_buffer, D_SHMDATA(void),size);
|
||||||
|
}
|
||||||
|
// a big read, we pull data over the shm in iterations
|
||||||
|
else
|
||||||
|
{
|
||||||
|
// first read equals the size of the SHM window
|
||||||
|
uint32_t to_read = SHM_BODY;
|
||||||
|
while (size)
|
||||||
|
{
|
||||||
|
// read to_read bytes from src_cursor
|
||||||
|
D_SHMHDR->address = src_address;
|
||||||
|
D_SHMHDR->length = to_read;
|
||||||
|
full_barrier
|
||||||
|
d->SetAndWait(CORE_READ);
|
||||||
|
memcpy (target_buffer, D_SHMDATA(void) ,to_read);
|
||||||
|
// decrease size by bytes read
|
||||||
|
size -= to_read;
|
||||||
|
// move the cursors
|
||||||
|
src_address += to_read;
|
||||||
|
target_buffer += to_read;
|
||||||
|
// check how much to write in the next iteration
|
||||||
|
to_read = min(size, (uint32_t) SHM_BODY);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void SHMProcess::readByte (const uint32_t offset, uint8_t &val )
|
||||||
|
{
|
||||||
|
if(!d->locked) throw Error::MemoryAccessDenied();
|
||||||
|
|
||||||
|
D_SHMHDR->address = offset;
|
||||||
|
full_barrier
|
||||||
|
d->SetAndWait(CORE_READ_BYTE);
|
||||||
|
val = D_SHMHDR->value;
|
||||||
|
}
|
||||||
|
|
||||||
|
void SHMProcess::readWord (const uint32_t offset, uint16_t &val)
|
||||||
|
{
|
||||||
|
if(!d->locked) throw Error::MemoryAccessDenied();
|
||||||
|
|
||||||
|
D_SHMHDR->address = offset;
|
||||||
|
full_barrier
|
||||||
|
d->SetAndWait(CORE_READ_WORD);
|
||||||
|
val = D_SHMHDR->value;
|
||||||
|
}
|
||||||
|
|
||||||
|
void SHMProcess::readDWord (const uint32_t offset, uint32_t &val)
|
||||||
|
{
|
||||||
|
if(!d->locked) throw Error::MemoryAccessDenied();
|
||||||
|
|
||||||
|
D_SHMHDR->address = offset;
|
||||||
|
full_barrier
|
||||||
|
d->SetAndWait(CORE_READ_DWORD);
|
||||||
|
val = D_SHMHDR->value;
|
||||||
|
}
|
||||||
|
|
||||||
|
void SHMProcess::readQuad (const uint32_t offset, uint64_t &val)
|
||||||
|
{
|
||||||
|
if(!d->locked) throw Error::MemoryAccessDenied();
|
||||||
|
|
||||||
|
D_SHMHDR->address = offset;
|
||||||
|
full_barrier
|
||||||
|
d->SetAndWait(CORE_READ_QUAD);
|
||||||
|
val = D_SHMHDR->Qvalue;
|
||||||
|
}
|
||||||
|
|
||||||
|
void SHMProcess::readFloat (const uint32_t offset, float &val)
|
||||||
|
{
|
||||||
|
if(!d->locked) throw Error::MemoryAccessDenied();
|
||||||
|
|
||||||
|
D_SHMHDR->address = offset;
|
||||||
|
full_barrier
|
||||||
|
d->SetAndWait(CORE_READ_DWORD);
|
||||||
|
val = reinterpret_cast<float&> (D_SHMHDR->value);
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* WRITING
|
||||||
|
*/
|
||||||
|
|
||||||
|
void SHMProcess::writeQuad (uint32_t offset, uint64_t data)
|
||||||
|
{
|
||||||
|
if(!d->locked) throw Error::MemoryAccessDenied();
|
||||||
|
|
||||||
|
D_SHMHDR->address = offset;
|
||||||
|
D_SHMHDR->Qvalue = data;
|
||||||
|
full_barrier
|
||||||
|
d->SetAndWait(CORE_WRITE_QUAD);
|
||||||
|
}
|
||||||
|
|
||||||
|
void SHMProcess::writeDWord (uint32_t offset, uint32_t data)
|
||||||
|
{
|
||||||
|
if(!d->locked) throw Error::MemoryAccessDenied();
|
||||||
|
|
||||||
|
D_SHMHDR->address = offset;
|
||||||
|
D_SHMHDR->value = data;
|
||||||
|
full_barrier
|
||||||
|
d->SetAndWait(CORE_WRITE_DWORD);
|
||||||
|
}
|
||||||
|
|
||||||
|
// using these is expensive.
|
||||||
|
void SHMProcess::writeWord (uint32_t offset, uint16_t data)
|
||||||
|
{
|
||||||
|
if(!d->locked) throw Error::MemoryAccessDenied();
|
||||||
|
|
||||||
|
D_SHMHDR->address = offset;
|
||||||
|
D_SHMHDR->value = data;
|
||||||
|
full_barrier
|
||||||
|
d->SetAndWait(CORE_WRITE_WORD);
|
||||||
|
}
|
||||||
|
|
||||||
|
void SHMProcess::writeByte (uint32_t offset, uint8_t data)
|
||||||
|
{
|
||||||
|
if(!d->locked) throw Error::MemoryAccessDenied();
|
||||||
|
|
||||||
|
D_SHMHDR->address = offset;
|
||||||
|
D_SHMHDR->value = data;
|
||||||
|
full_barrier
|
||||||
|
d->SetAndWait(CORE_WRITE_BYTE);
|
||||||
|
}
|
||||||
|
|
||||||
|
void SHMProcess::write (uint32_t dst_address, uint32_t size, uint8_t *source_buffer)
|
||||||
|
{
|
||||||
|
if(!d->locked) throw Error::MemoryAccessDenied();
|
||||||
|
|
||||||
|
// normal write under 1MB
|
||||||
|
if(size <= SHM_BODY)
|
||||||
|
{
|
||||||
|
D_SHMHDR->address = dst_address;
|
||||||
|
D_SHMHDR->length = size;
|
||||||
|
memcpy(D_SHMDATA(void),source_buffer, size);
|
||||||
|
full_barrier
|
||||||
|
d->SetAndWait(CORE_WRITE);
|
||||||
|
}
|
||||||
|
// a big write, we push this over the shm in iterations
|
||||||
|
else
|
||||||
|
{
|
||||||
|
// first write equals the size of the SHM window
|
||||||
|
uint32_t to_write = SHM_BODY;
|
||||||
|
while (size)
|
||||||
|
{
|
||||||
|
// write to_write bytes to dst_cursor
|
||||||
|
D_SHMHDR->address = dst_address;
|
||||||
|
D_SHMHDR->length = to_write;
|
||||||
|
memcpy(D_SHMDATA(void),source_buffer, to_write);
|
||||||
|
full_barrier
|
||||||
|
d->SetAndWait(CORE_WRITE);
|
||||||
|
// decrease size by bytes written
|
||||||
|
size -= to_write;
|
||||||
|
// move the cursors
|
||||||
|
source_buffer += to_write;
|
||||||
|
dst_address += to_write;
|
||||||
|
// check how much to write in the next iteration
|
||||||
|
to_write = min(size, (uint32_t) SHM_BODY);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// FIXME: butt-fugly
|
||||||
|
const std::string SHMProcess::readCString (uint32_t offset)
|
||||||
|
{
|
||||||
|
if(!d->locked) throw Error::MemoryAccessDenied();
|
||||||
|
|
||||||
|
std::string temp;
|
||||||
|
char temp_c[256];
|
||||||
|
int counter = 0;
|
||||||
|
char r;
|
||||||
|
do
|
||||||
|
{
|
||||||
|
r = Process::readByte(offset+counter);
|
||||||
|
temp_c[counter] = r;
|
||||||
|
counter++;
|
||||||
|
} while (r && counter < 255);
|
||||||
|
temp_c[counter] = 0;
|
||||||
|
temp = temp_c;
|
||||||
|
return temp;
|
||||||
|
}
|
||||||
|
|
||||||
|
const std::string SHMProcess::readSTLString(uint32_t offset)
|
||||||
|
{
|
||||||
|
if(!d->locked) throw Error::MemoryAccessDenied();
|
||||||
|
|
||||||
|
D_SHMHDR->address = offset;
|
||||||
|
full_barrier
|
||||||
|
d->SetAndWait(CORE_READ_STL_STRING);
|
||||||
|
return(string( D_SHMDATA(char) ));
|
||||||
|
}
|
||||||
|
|
||||||
|
size_t SHMProcess::readSTLString (uint32_t offset, char * buffer, size_t bufcapacity)
|
||||||
|
{
|
||||||
|
if(!d->locked) throw Error::MemoryAccessDenied();
|
||||||
|
|
||||||
|
D_SHMHDR->address = offset;
|
||||||
|
full_barrier
|
||||||
|
d->SetAndWait(CORE_READ_STL_STRING);
|
||||||
|
size_t length = D_SHMHDR->value;
|
||||||
|
size_t fit = min(bufcapacity - 1, length);
|
||||||
|
strncpy(buffer,D_SHMDATA(char),fit);
|
||||||
|
buffer[fit] = 0;
|
||||||
|
return fit;
|
||||||
|
}
|
||||||
|
|
||||||
|
void SHMProcess::writeSTLString(const uint32_t address, const std::string writeString)
|
||||||
|
{
|
||||||
|
if(!d->locked) throw Error::MemoryAccessDenied();
|
||||||
|
|
||||||
|
D_SHMHDR->address = address;
|
||||||
|
strncpy(D_SHMDATA(char),writeString.c_str(),writeString.length()+1); // length + 1 for the null terminator
|
||||||
|
full_barrier
|
||||||
|
d->SetAndWait(CORE_WRITE_STL_STRING);
|
||||||
|
}
|
||||||
@ -0,0 +1,144 @@
|
|||||||
|
/*
|
||||||
|
www.sourceforge.net/projects/dfhack
|
||||||
|
Copyright (c) 2009 Petr Mrázek (peterix), Kenneth Ferland (Impaler[WrG]), dorf
|
||||||
|
|
||||||
|
This software is provided 'as-is', without any express or implied
|
||||||
|
warranty. In no event will the authors be held liable for any
|
||||||
|
damages arising from the use of this software.
|
||||||
|
|
||||||
|
Permission is granted to anyone to use this software for any
|
||||||
|
purpose, including commercial applications, and to alter it and
|
||||||
|
redistribute it freely, subject to the following restrictions:
|
||||||
|
|
||||||
|
1. The origin of this software must not be misrepresented; you must
|
||||||
|
not claim that you wrote the original software. If you use this
|
||||||
|
software in a product, an acknowledgment in the product documentation
|
||||||
|
would be appreciated but is not required.
|
||||||
|
|
||||||
|
2. Altered source versions must be plainly marked as such, and
|
||||||
|
must not be misrepresented as being the original software.
|
||||||
|
|
||||||
|
3. This notice may not be removed or altered from any source
|
||||||
|
distribution.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef SHM_PROCESS_H_INCLUDED
|
||||||
|
#define SHM_PROCESS_H_INCLUDED
|
||||||
|
|
||||||
|
#include "dfhack/DFProcess.h"
|
||||||
|
|
||||||
|
namespace DFHack
|
||||||
|
{
|
||||||
|
class DFHACK_EXPORT SHMProcess : public Process
|
||||||
|
{
|
||||||
|
friend class ProcessEnumerator;
|
||||||
|
class Private;
|
||||||
|
private:
|
||||||
|
Private * const d;
|
||||||
|
|
||||||
|
public:
|
||||||
|
SHMProcess(uint32_t PID, std::vector <VersionInfo *> & known_versions);
|
||||||
|
~SHMProcess();
|
||||||
|
// Set up stuff so we can read memory
|
||||||
|
bool attach();
|
||||||
|
bool detach();
|
||||||
|
|
||||||
|
bool suspend();
|
||||||
|
bool asyncSuspend();
|
||||||
|
bool resume();
|
||||||
|
bool forceresume();
|
||||||
|
|
||||||
|
void readQuad(const uint32_t address, uint64_t & value);
|
||||||
|
void writeQuad(const uint32_t address, const uint64_t value);
|
||||||
|
|
||||||
|
void readDWord(const uint32_t address, uint32_t & value);
|
||||||
|
void writeDWord(const uint32_t address, const uint32_t value);
|
||||||
|
|
||||||
|
void readFloat(const uint32_t address, float & value);
|
||||||
|
|
||||||
|
void readWord(const uint32_t address, uint16_t & value);
|
||||||
|
void writeWord(const uint32_t address, const uint16_t value);
|
||||||
|
|
||||||
|
void readByte(const uint32_t address, uint8_t & value);
|
||||||
|
void writeByte(const uint32_t address, const uint8_t value);
|
||||||
|
|
||||||
|
void read( uint32_t address, uint32_t length, uint8_t* buffer);
|
||||||
|
void write(uint32_t address, uint32_t length, uint8_t* buffer);
|
||||||
|
|
||||||
|
const std::string readSTLString (uint32_t offset);
|
||||||
|
size_t readSTLString (uint32_t offset, char * buffer, size_t bufcapacity);
|
||||||
|
void writeSTLString(const uint32_t address, const std::string writeString);
|
||||||
|
// get class name of an object with rtti/type info
|
||||||
|
std::string readClassName(uint32_t vptr);
|
||||||
|
|
||||||
|
const std::string readCString (uint32_t offset);
|
||||||
|
|
||||||
|
bool isSuspended();
|
||||||
|
bool isAttached();
|
||||||
|
bool isIdentified();
|
||||||
|
|
||||||
|
bool getThreadIDs(std::vector<uint32_t> & threads );
|
||||||
|
void getMemRanges(std::vector<t_memrange> & ranges );
|
||||||
|
VersionInfo *getDescriptor();
|
||||||
|
int getPID();
|
||||||
|
std::string getPath();
|
||||||
|
// get module index by name and version. bool 1 = error
|
||||||
|
bool getModuleIndex (const char * name, const uint32_t version, uint32_t & OUTPUT);
|
||||||
|
// get the SHM start if available
|
||||||
|
char * getSHMStart (void);
|
||||||
|
bool SetAndWait (uint32_t state);
|
||||||
|
private:
|
||||||
|
bool acquireSuspendLock();
|
||||||
|
bool releaseSuspendLock();
|
||||||
|
};
|
||||||
|
|
||||||
|
class SHMProcess::Private
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
Private(SHMProcess * self_);
|
||||||
|
~Private(){}
|
||||||
|
VersionInfo * memdescriptor;
|
||||||
|
SHMProcess * self;
|
||||||
|
char *shm_addr;
|
||||||
|
int attachmentIdx;
|
||||||
|
|
||||||
|
bool attached;
|
||||||
|
bool locked;
|
||||||
|
bool identified;
|
||||||
|
bool useYield;
|
||||||
|
|
||||||
|
#ifdef LINUX_BUILD
|
||||||
|
pid_t process_ID;
|
||||||
|
int shm_ID;
|
||||||
|
int server_lock;
|
||||||
|
int client_lock;
|
||||||
|
int suspend_lock;
|
||||||
|
#else
|
||||||
|
typedef unit32_t pid_t;
|
||||||
|
uint32_t process_ID;
|
||||||
|
HANDLE DFSVMutex;
|
||||||
|
HANDLE DFCLMutex;
|
||||||
|
HANDLE DFCLSuspendMutex;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
bool validate(std::vector< VersionInfo* >& known_versions);
|
||||||
|
|
||||||
|
bool Aux_Core_Attach(bool & versionOK, pid_t& PID);
|
||||||
|
bool SetAndWait (uint32_t state);
|
||||||
|
bool GetLocks();
|
||||||
|
bool AreLocksOk();
|
||||||
|
void FreeLocks();
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
// some helpful macros to keep the code bloat in check
|
||||||
|
#define SHMCMD ( (uint32_t *) shm_addr)[attachmentIdx]
|
||||||
|
#define D_SHMCMD ( (uint32_t *) (d->shm_addr))[d->attachmentIdx]
|
||||||
|
|
||||||
|
#define SHMHDR ((shm_core_hdr *)shm_addr)
|
||||||
|
#define D_SHMHDR ((shm_core_hdr *)(d->shm_addr))
|
||||||
|
|
||||||
|
#define SHMDATA(type) ((type *)(shm_addr + SHM_HEADER))
|
||||||
|
#define D_SHMDATA(type) ((type *)(d->shm_addr + SHM_HEADER))
|
||||||
|
|
||||||
|
#endif
|
||||||
Loading…
Reference in New Issue