Merge much of DFProcess-*-SHM.cpp into DFProcess-SHM.cpp.

library/CMakeLists.txt

@@ -29,6 +29,8 @@ include_directories (${CMAKE_SOURCE_DIR}/library/private/)
 SET(PROJECT_HDRS_INTERNAL
     private/ContextShared.h
     private/Internal.h
+    private/ProcessInternal.h
+    private/SHMProcess.h
 )
 
 SET(PROJECT_HDRS
@@ -89,6 +91,7 @@ DFContext.cpp
 DFTileTypes.cpp
 DFProcessEnumerator.cpp
 ContextShared.cpp
+DFProcess-SHM.cpp
 
 depends/md5/md5.cpp
 depends/md5/md5wrapper.cpp

library/DFProcess-SHM.cpp

@@ -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);
+}

library/DFProcess-linux-SHM.cpp

@@ -22,7 +22,7 @@ must not be misrepresented as being the original software.
 distribution.
 */
 #include "Internal.h"
-#include "ProcessInternal.h"
+#include "SHMProcess.h"
 #include "dfhack/VersionInfo.h"
 #include "dfhack/DFError.h"
 
@@ -39,15 +39,10 @@ distribution.
 
 using namespace DFHack;
 
-class SHMProcess::Private
+SHMProcess::Private::Private(SHMProcess * self_)
-{
-    public:
-    Private(Process * self_)
 {
     memdescriptor = NULL;
     process_ID = 0;
-        shm_addr = 0;
-        //shm_addr_with_cl_idx = 0;
     shm_ID = -1;
     attached = false;
     identified = false;
@@ -55,45 +50,9 @@ class SHMProcess::Private
     server_lock = -1;
     client_lock = -1;
     suspend_lock = -1;
-        attachmentIdx = 0;
     locked = false;
     self = self_;
-    };
+}
-    ~Private(){};
-    VersionInfo * memdescriptor;
-    Process * self;
-    pid_t process_ID;
-    char *shm_addr;
-    int shm_ID;
-    Process* q;
-    int server_lock;
-    int client_lock;
-    int suspend_lock;
-    int attachmentIdx;
-
-    bool attached;
-    bool locked;
-    bool identified;
-    bool useYield;
-
-    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))
 
 bool SHMProcess::Private::SetAndWait (uint32_t state)
 {
@@ -256,50 +215,6 @@ bool SHMProcess::Private::AreLocksOk()
     return false;
 }
 
-SHMProcess::SHMProcess(uint32_t PID, vector< VersionInfo* >& known_versions)
-: d(new Private(this))
-{
-    d->process_ID = PID;
-    d->memdescriptor = 0;
-    if(!attach())
-    {
-        // couldn't attach to process
-        return;
-    }
-    /*
-     * Test bridge version, get PID, sync Yield
-     */
-    bool bridgeOK;
-    if(!d->Aux_Core_Attach(bridgeOK,d->process_ID))
-    {
-        detach();
-        throw Error::SHMAttachFailure();
-    }
-    if(!bridgeOK)
-    {
-        detach();
-        throw Error::SHMVersionMismatch();
-    }
-
-    // try to identify the DF version (md5 the binary, compare with known versions)
-    d->validate(known_versions);
-    // detach
-    detach();
-}
-
-bool SHMProcess::isSuspended()
-{
-    return d->locked;
-}
-bool SHMProcess::isAttached()
-{
-    return d->attached;
-}
-
-bool SHMProcess::isIdentified()
-{
-    return d->identified;
-}
 
 bool SHMProcess::Private::validate(vector <VersionInfo *> & known_versions)
 {
@@ -331,7 +246,7 @@ bool SHMProcess::Private::validate(vector <VersionInfo *> & known_versions)
             {
                 VersionInfo *m = new VersionInfo(**it);
                 memdescriptor = m;
-                m->setParentProcess(dynamic_cast<Process *>( self ));
+                m->setParentProcess(self);
                 identified = true;
                 // cerr << "identified " << m->getVersion() << endl;
                 return true;
@@ -345,27 +260,6 @@ bool SHMProcess::Private::validate(vector <VersionInfo *> & known_versions)
     return false;
 }
 
-SHMProcess::~SHMProcess()
-{
-    if(d->attached)
-    {
-        detach();
-    }
-    if(d->memdescriptor)
-        delete d->memdescriptor;
-    delete d;
-}
-
-VersionInfo * SHMProcess::getDescriptor()
-{
-    return d->memdescriptor;
-}
-
-int SHMProcess::getPID()
-{
-    return d->process_ID;
-}
-
 // there is only one we care about.
 bool SHMProcess::getThreadIDs(vector<uint32_t> & threads )
 {
@@ -406,119 +300,14 @@ void SHMProcess::getMemRanges( vector<t_memrange> & ranges )
     }
 }
 
-bool SHMProcess::suspend()
+bool SHMProcess::acquireSuspendLock()
-{
-    if(!d->attached)
-    {
-        return false;
-    }
-    if(d->locked)
-    {
-        return true;
-    }
-
-    // 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",d->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",d->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(lockf(d->suspend_lock,F_LOCK,0) == 0)
-    {
-        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;
-    }
-    uint32_t cmd = D_SHMCMD;
-    if(cmd == CORE_SUSPENDED)
-    {
-        // we have to hold the lock to be really suspended
-        if(lockf(d->suspend_lock,F_LOCK,0) == 0)
-        {
-            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;
+    return (lockf(d->suspend_lock,F_LOCK,0) == 0);
-        }
-        else
-        {
-            D_SHMCMD = CORE_SUSPEND;
-        }
-        return false;
-    }
 }
 
-bool SHMProcess::forceresume()
+bool SHMProcess::releaseSuspendLock()
-{
-    return resume();
-}
-
-// FIXME: wait for the server to advance a step!
-bool SHMProcess::resume()
-{
-    if(!d->attached)
-        return false;
-    if(!d->locked)
-        return true;
-    // unlock the suspend lock
-    if(lockf(d->suspend_lock,F_ULOCK,0) == 0)
 {
-        d->locked = false;
+    return (lockf(d->suspend_lock,F_ULOCK,0) == 0);
-        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(lockf(d->suspend_lock,F_ULOCK,0) == 0)");
-    return false;
 }
 
 
@@ -530,6 +319,7 @@ bool SHMProcess::attach()
             return suspend();
         return true;
     }
+    //cerr << "attach" << endl;// FIXME: throw
     if(!d->GetLocks())
     {
         //cerr << "server is full or not really there!" << endl;
@@ -588,229 +378,6 @@ bool SHMProcess::detach()
     return false;
 }
 
-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);
-}
-
 string SHMProcess::readClassName (uint32_t vptr)
 {
     if(!d->locked) throw Error::MemoryAccessDenied();
@@ -836,52 +403,9 @@ string SHMProcess::getPath()
     return(string(target_name));
 }
 
-// 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;
-}
-
 char * SHMProcess::getSHMStart (void)
 {
     if(!d->locked) return 0; //THROW HERE!
 
-    return /*d->shm_addr_with_cl_idx*/ d->shm_addr;
+    return d->shm_addr;
-}
-
-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;
 }

library/DFProcess-windows-SHM.cpp

@@ -22,21 +22,17 @@ must not be misrepresented as being the original software.
 distribution.
 */
 #include "Internal.h"
-#include "ProcessInternal.h"
+#include "SHMProcess.h"
 #include "dfhack/VersionInfo.h"
 #include "dfhack/DFError.h"
 #include "shms.h"
 #include "mod-core.h"
 using namespace DFHack;
 
-class SHMProcess::Private
+SHMProcess::Private::Private(SHMProcess * self_)
-{
-    public:
-    Private()
 {
     memdescriptor = NULL;
     process_ID = 0;
-        shm_addr = 0;
     attached = false;
     locked = false;
     identified = false;
@@ -44,41 +40,8 @@ class SHMProcess::Private
     DFSVMutex = 0;
     DFCLMutex = 0;
     DFCLSuspendMutex = 0;
-        attachmentIdx = -1;
+    self = self_;
-    };
+}
-    ~Private(){};
-    VersionInfo * memdescriptor;
-    SHMProcess * self;
-    uint32_t process_ID;
-    char *shm_addr;
-    HANDLE DFSVMutex;
-    HANDLE DFCLMutex;
-    HANDLE DFCLSuspendMutex;
-    int attachmentIdx;
-
-    bool attached;
-    bool locked;
-    bool identified;
-    bool useYield;
-
-    bool validate(std::vector< VersionInfo* >& known_versions);
-
-    bool Aux_Core_Attach(bool & versionOK, uint32_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))
 
 bool SHMProcess::Private::SetAndWait (uint32_t state)
 {
@@ -253,46 +216,6 @@ bool SHMProcess::Private::AreLocksOk()
     return false;
 }
 
-SHMProcess::SHMProcess(uint32_t PID, vector <VersionInfo *> & known_versions)
-: d(new Private())
-{
-    d->process_ID = PID;
-    d->self = this;
-    // 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();
-    }
-    d->validate(known_versions);
-    // at this point, DF is attached and suspended, make it run
-    detach();
-}
-
-bool SHMProcess::isSuspended()
-{
-    return d->locked;
-}
-bool SHMProcess::isAttached()
-{
-    return d->attached;
-}
-
-bool SHMProcess::isIdentified()
-{
-    return d->identified;
-}
 bool SHMProcess::Private::validate(vector <VersionInfo *> & known_versions)
 {
     // try to identify the DF version
@@ -350,29 +273,6 @@ bool SHMProcess::Private::validate(vector <VersionInfo *> & known_versions)
     }
     return false;
 }
-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::getThreadIDs(vector<uint32_t> & threads )
 {
@@ -424,121 +324,14 @@ void SHMProcess::getMemRanges( vector<t_memrange> & ranges )
     ranges.push_back(temp);
 }
 
-bool SHMProcess::suspend()
+bool SHMProcess::acquireSuspendLock()
-{
-    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",d->attachmentIdx);
+    return ( WaitForSingleObject(d->DFCLSuspendMutex,INFINITE) == 0 );
-        // 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",d->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( WaitForSingleObject(d->DFCLSuspendMutex,INFINITE) == 0 )
-    {
-        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( WaitForSingleObject(d->DFCLSuspendMutex,INFINITE) == 0 )
-        {
-            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()
+bool SHMProcess::releaseSuspendLock()
-{
-    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( ReleaseMutex(d->DFCLSuspendMutex) != 0)
-    {
-        d->locked = false;
-        if(d->SetAndWait(CORE_RUN)) // we have to make sure the server responds!
 {
-            return true;
+    return ( ReleaseMutex(d->DFCLSuspendMutex) != 0);
-        }
-        throw Error::SHMLockingError("if(d->SetAndWait(CORE_RUN))");
-    }
-    throw Error::SHMLockingError("if( ReleaseMutex(d->DFCLSuspendMutex) != 0)");
-    return false;
 }
 
 
@@ -613,229 +406,6 @@ bool SHMProcess::detach()
     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);
-}
-
 string SHMProcess::readClassName (uint32_t vptr)
 {
     int rtti = Process::readDWord(vptr - 0x4);
@@ -857,51 +427,9 @@ string SHMProcess::getPath()
     return(out.substr(0,out.find_last_of("\\")));
 }
 
-// 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;
-}
-
 char * SHMProcess::getSHMStart (void)
 {
     if(!d->locked) throw Error::MemoryAccessDenied();
-    return /*d->shm_addr_with_cl_idx*/ d->shm_addr;
-}
-
-bool SHMProcess::Private::Aux_Core_Attach(bool & versionOK,  uint32_t & PID)
-{
-    if(!locked) throw Error::MemoryAccessDenied();
 
-    SHMDATA(coreattach)->cl_affinity = OS_getAffinity();
+    return d->shm_addr;
-    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;
 }

library/DFProcessEnumerator.cpp

@@ -24,6 +24,7 @@ distribution.
 
 #include "Internal.h"
 #include "ProcessInternal.h"
+#include "SHMProcess.h"
 
 #include "dfhack/VersionInfoFactory.h"
 #include "dfhack/DFProcessEnumerator.h"

library/private/ProcessInternal.h

@@ -29,10 +29,6 @@ distribution.
 
 namespace DFHack
 {
-    ////////////////////////////////////////////////////////////////////////////
-    //         Compiler appeasement area. Not worth a look really...          //
-    ////////////////////////////////////////////////////////////////////////////
-
     class DFHACK_EXPORT NormalProcess : public Process
     {
         friend class ProcessEnumerator;
@@ -92,66 +88,6 @@ namespace DFHack
             bool SetAndWait (uint32_t state){return false;};
     };
 
-    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);
-    };
-
 #ifdef LINUX_BUILD
     class DFHACK_EXPORT WineProcess : public Process
     {

library/private/SHMProcess.h

@@ -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