/**************************************************************************** (c) SYSTEC electronic GmbH, D-07973 Greiz, August-Bebel-Str. 29 www.systec-electronic.com Project: Project independend shared buffer (linear + circular) Description: Implementation of platform specific part for the shared buffer (Implementation for Win32) License: Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of SYSTEC electronic GmbH nor the names of its contributors may be used to endorse or promote products derived from this software without prior written permission. For written permission, please contact info@systec-electronic.com. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. Severability Clause: If a provision of this License is or becomes illegal, invalid or unenforceable in any jurisdiction, that shall not affect: 1. the validity or enforceability in that jurisdiction of any other provision of this License; or 2. the validity or enforceability in other jurisdictions of that or any other provision of this License. ------------------------------------------------------------------------- 2006/06/27 -rs: V 1.00 (initial version) ****************************************************************************/ #define WINVER 0x0400 // #defines necessary for usage of #define _WIN32_WINNT 0x0400 // function #include #include #include "global.h" #include "sharedbuff.h" #include "shbipc.h" /***************************************************************************/ /* */ /* */ /* G L O B A L D E F I N I T I O N S */ /* */ /* */ /***************************************************************************/ #if (!defined(SHBIPC_INLINED)) || defined(SHBIPC_INLINE_ENABLED) //--------------------------------------------------------------------------- // Configuration //--------------------------------------------------------------------------- //--------------------------------------------------------------------------- // Constant definitions //--------------------------------------------------------------------------- #define MAX_LEN_BUFFER_ID MAX_PATH #define IDX_EVENT_NEW_DATA 0 #define IDX_EVENT_TERM_REQU 1 #define IDX_EVENT_TERM_RESP 2 #define NAME_MUTEX_BUFF_ACCESS "BuffAccess" #define NAME_EVENT_NEW_DATA "NewData" #define NAME_EVENT_TERM_REQU "TermRequ" #define NAME_EVENT_TERM_RESP "TermResp" #define NAME_EVENT_JOB_READY "JobReady" #define TIMEOUT_ENTER_ATOMIC 1000 // for debgging: INFINITE #define TIMEOUT_TERM_THREAD 2000 #define SBI_MAGIC_ID 0x5342492B // magic ID ("SBI+") #define SBH_MAGIC_ID 0x5342482A // magic ID ("SBH*") //--------------------------------------------------------------------------- // Local types //--------------------------------------------------------------------------- // This structure is the common header for the shared memory region used // by all processes attached this shared memory. It includes common // information to administrate/manage the shared buffer from a couple of // separated processes (e.g. the refernce counter). This structure is // located at the start of the shared memory region itself and exists // consequently only one times per shared memory instance. typedef struct { unsigned long m_SbhMagicID; // magic ID ("SBH*") unsigned long m_ulShMemSize; unsigned long m_ulRefCount; char m_szBufferID[MAX_LEN_BUFFER_ID]; #ifndef NDEBUG unsigned long m_ulOwnerProcID; #endif } tShbMemHeader; // This structure is the "external entry point" from a separate process // to get access to a shared buffer. This structure includes all platform // resp. target specific information to administrate/manage the shared // buffer from a separate process. Every process attached to the shared // buffer has its own runtime instance of this structure with its individual // runtime data (e.g. the scope of an event handle is limitted to the // owner process only). The structure member points // to the (process specific) start address of the shared memory region // itself. typedef struct { unsigned long m_SbiMagicID; // magic ID ("SBI+") HANDLE m_hSharedMem; HANDLE m_hMutexBuffAccess; HANDLE m_hThreadNewData; // thraed to signal that new data are available HANDLE m_ahEventNewData[3]; // IDX_EVENT_NEW_DATA + IDX_EVENT_TERM_REQU + ID_EVENT_TERM_RESP tSigHndlrNewData m_pfnSigHndlrNewData; HANDLE m_hThreadJobReady; // thread to signal that a job/operation is ready now (e.g. reset buffer) HANDLE m_hEventJobReady; unsigned long m_ulTimeOutJobReady; tSigHndlrJobReady m_pfnSigHndlrJobReady; tShbMemHeader *m_pShbMemHeader; #ifndef NDEBUG unsigned long m_ulThreadIDNewData; unsigned long m_ulThreadIDJobReady; #endif } tShbMemInst; //--------------------------------------------------------------------------- // Global variables //--------------------------------------------------------------------------- //--------------------------------------------------------------------------- // Local variables //--------------------------------------------------------------------------- //--------------------------------------------------------------------------- // Prototypes of internal functions //--------------------------------------------------------------------------- //--------------------------------------------------------------------------- // Get pointer to process local information structure //--------------------------------------------------------------------------- INLINE_FUNCTION tShbMemInst *ShbIpcGetShbMemInst(tShbInstance pShbInstance_p) { tShbMemInst *pShbMemInst; pShbMemInst = (tShbMemInst *) pShbInstance_p; ASSERT(pShbMemInst->m_SbiMagicID == SBI_MAGIC_ID); return (pShbMemInst); } //--------------------------------------------------------------------------- // Get pointer to shared memory header //--------------------------------------------------------------------------- INLINE_FUNCTION tShbMemHeader *ShbIpcGetShbMemHeader(tShbInstance pShbInstance_p) { tShbMemInst *pShbMemInst; tShbMemHeader *pShbMemHeader; pShbMemInst = ShbIpcGetShbMemInst(pShbInstance_p); pShbMemHeader = pShbMemInst->m_pShbMemHeader; ASSERT(pShbMemHeader->m_SbhMagicID == SBH_MAGIC_ID); return (pShbMemHeader); } // not inlined internal functions DWORD WINAPI ShbIpcThreadSignalNewData(LPVOID pvThreadParam_p); DWORD WINAPI ShbIpcThreadSignalJobReady(LPVOID pvThreadParam_p); const char *ShbIpcGetUniformObjectName(const char *pszEventJobName_p, const char *pszBufferID_p, BOOL fGlobalObject_p); #endif #if !defined(SHBIPC_INLINE_ENABLED) // true internal functions (not inlined) static void *ShbIpcAllocPrivateMem(unsigned long ulMemSize_p); static void ShbIpcReleasePrivateMem(void *pMem_p); #endif //=========================================================================// // // // P U B L I C F U N C T I O N S // // // //=========================================================================// #if !defined(SHBIPC_INLINE_ENABLED) // not inlined external functions //--------------------------------------------------------------------------- // Initialize IPC for Shared Buffer Module //--------------------------------------------------------------------------- tShbError ShbIpcInit(void) { return (kShbOk); } //--------------------------------------------------------------------------- // Deinitialize IPC for Shared Buffer Module //--------------------------------------------------------------------------- tShbError ShbIpcExit(void) { return (kShbOk); } //--------------------------------------------------------------------------- // Allocate Shared Buffer //--------------------------------------------------------------------------- tShbError ShbIpcAllocBuffer(unsigned long ulBufferSize_p, const char *pszBufferID_p, tShbInstance * ppShbInstance_p, unsigned int *pfShbNewCreated_p) { HANDLE hSharedMem; LPVOID pSharedMem; unsigned long ulShMemSize; tShbMemInst *pShbMemInst; tShbMemHeader *pShbMemHeader; tShbInstance pShbInstance; unsigned int fShMemNewCreated; const char *pszObjectName; HANDLE hMutexBuffAccess; HANDLE hEventNewData; HANDLE hEventJobReady; tShbError ShbError; ulShMemSize = ulBufferSize_p + sizeof(tShbMemHeader); pSharedMem = NULL; pShbInstance = NULL; fShMemNewCreated = FALSE; ShbError = kShbOk; //--------------------------------------------------------------- // (1) open an existing or create a new shared memory //--------------------------------------------------------------- // try to open an already existing shared memory // (created by an another process) hSharedMem = OpenFileMapping(FILE_MAP_ALL_ACCESS, // DWORD dwDesiredAccess FALSE, // BOOL bInheritHandle pszBufferID_p); // LPCTSTR lpName if (hSharedMem != NULL) { // a shared memory already exists fShMemNewCreated = FALSE; } else { // it seams that this process is the first who wants to use the // shared memory, so it has to create a new shared memory hSharedMem = CreateFileMapping(INVALID_HANDLE_VALUE, // HANDLE hFile NULL, // LPSECURITY_ATTRIBUTES lpAttributes PAGE_READWRITE, // DWORD flProtect 0, // DWORD dwMaximumSizeHigh ulShMemSize, // DWORD dwMaximumSizeLow pszBufferID_p); // LPCTSTR lpName fShMemNewCreated = TRUE; } if (hSharedMem == NULL) { ShbError = kShbOutOfMem; goto Exit; } //--------------------------------------------------------------- // (2) get the pointer to the shared memory //--------------------------------------------------------------- pSharedMem = MapViewOfFile(hSharedMem, // HANDLE hFileMappingObject FILE_MAP_ALL_ACCESS, // DWORD dwDesiredAccess, 0, // DWORD dwFileOffsetHigh, 0, // DWORD dwFileOffsetLow, ulShMemSize); // SIZE_T dwNumberOfBytesToMap if (pSharedMem == NULL) { ShbError = kShbOutOfMem; goto Exit; } //--------------------------------------------------------------- // (3) setup or update header and management information //--------------------------------------------------------------- pShbMemHeader = (tShbMemHeader *) pSharedMem; // allocate a memory block from process specific mempool to save // process local information to administrate/manage the shared buffer pShbMemInst = (tShbMemInst *) ShbIpcAllocPrivateMem(sizeof(tShbMemInst)); if (pShbMemInst == NULL) { ShbError = kShbOutOfMem; goto Exit; } // reset complete header to default values pShbMemInst->m_SbiMagicID = SBI_MAGIC_ID; pShbMemInst->m_hSharedMem = hSharedMem; pShbMemInst->m_hMutexBuffAccess = INVALID_HANDLE_VALUE; pShbMemInst->m_hThreadNewData = INVALID_HANDLE_VALUE; pShbMemInst->m_ahEventNewData[IDX_EVENT_NEW_DATA] = INVALID_HANDLE_VALUE; pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_REQU] = INVALID_HANDLE_VALUE; pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_RESP] = INVALID_HANDLE_VALUE; pShbMemInst->m_pfnSigHndlrNewData = NULL; pShbMemInst->m_hThreadJobReady = INVALID_HANDLE_VALUE; pShbMemInst->m_hEventJobReady = INVALID_HANDLE_VALUE; pShbMemInst->m_ulTimeOutJobReady = 0; pShbMemInst->m_pfnSigHndlrJobReady = NULL; pShbMemInst->m_pShbMemHeader = pShbMemHeader; #ifndef NDEBUG { pShbMemInst->m_ulThreadIDNewData = 0; pShbMemInst->m_ulThreadIDJobReady = 0; } #endif // create mutex for buffer access pszObjectName = ShbIpcGetUniformObjectName(NAME_MUTEX_BUFF_ACCESS, pszBufferID_p, TRUE); hMutexBuffAccess = CreateMutex(NULL, // LPSECURITY_ATTRIBUTES lpMutexAttributes FALSE, // BOOL bInitialOwner pszObjectName); // LPCTSTR lpName pShbMemInst->m_hMutexBuffAccess = hMutexBuffAccess; ASSERT(pShbMemInst->m_hMutexBuffAccess != NULL); // The EventNewData is used for signaling of new data after a write // operation (SetEvent) as well as for waiting for new data on the // reader side (WaitForMultipleObjects). Because it's not known if // this process will be read or write data, the event will be // always created here. pszObjectName = ShbIpcGetUniformObjectName(NAME_EVENT_NEW_DATA, pszBufferID_p, TRUE); hEventNewData = CreateEvent(NULL, // LPSECURITY_ATTRIBUTES lpEventAttributes FALSE, // BOOL bManualReset FALSE, // BOOL bInitialState pszObjectName); // LPCTSTR lpName pShbMemInst->m_ahEventNewData[IDX_EVENT_NEW_DATA] = hEventNewData; ASSERT(pShbMemInst->m_ahEventNewData[IDX_EVENT_NEW_DATA] != NULL); // The EventJobReady is used for signaling that a job is done (SetEvent) // as well as for waiting for finishing of a job (WaitForMultipleObjects). // Because it's not known if this process will signal or wait, the event // will be always created here. pszObjectName = ShbIpcGetUniformObjectName(NAME_EVENT_JOB_READY, pszBufferID_p, TRUE); hEventJobReady = CreateEvent(NULL, // LPSECURITY_ATTRIBUTES lpEventAttributes FALSE, // BOOL bManualReset FALSE, // BOOL bInitialState pszObjectName); // LPCTSTR lpName pShbMemInst->m_hEventJobReady = hEventJobReady; ASSERT(pShbMemInst->m_hEventJobReady != NULL); if (fShMemNewCreated) { // this process was the first who wanted to use the shared memory, // so a new shared memory was created // -> setup new header information inside the shared memory region // itself pShbMemHeader->m_SbhMagicID = SBH_MAGIC_ID; pShbMemHeader->m_ulShMemSize = ulShMemSize; pShbMemHeader->m_ulRefCount = 1; strncpy(pShbMemHeader->m_szBufferID, pszBufferID_p, sizeof(pShbMemHeader->m_szBufferID) - 1); #ifndef NDEBUG { pShbMemHeader->m_ulOwnerProcID = GetCurrentProcessId(); } #endif } else { // any other process has created the shared memory and this // process has only attached to it // -> check and update existing header information inside the // shared memory region itself if (pShbMemHeader->m_ulShMemSize != ulShMemSize) { ShbError = kShbOpenMismatch; goto Exit; } #ifndef NDEBUG { if (strncmp (pShbMemHeader->m_szBufferID, pszBufferID_p, sizeof(pShbMemHeader->m_szBufferID) - 1)) { ShbError = kShbOpenMismatch; goto Exit; } } #endif pShbMemHeader->m_ulRefCount++; } // set abstarct "handle" for returning to application pShbInstance = (tShbInstance *) pShbMemInst; Exit: if (ShbError != kShbOk) { if (pShbMemInst != NULL) { ShbIpcReleasePrivateMem(pShbMemInst); } if (pSharedMem != NULL) { UnmapViewOfFile(pSharedMem); } if (hSharedMem != NULL) { CloseHandle(hSharedMem); } } *pfShbNewCreated_p = fShMemNewCreated; *ppShbInstance_p = pShbInstance; return (ShbError); } //--------------------------------------------------------------------------- // Release Shared Buffer //--------------------------------------------------------------------------- tShbError ShbIpcReleaseBuffer(tShbInstance pShbInstance_p) { tShbMemInst *pShbMemInst; tShbMemHeader *pShbMemHeader; HANDLE hEventNewData; HANDLE hMutexBuffAccess; tShbError ShbError; tShbError ShbError2; if (pShbInstance_p == NULL) { return (kShbOk); } pShbMemInst = ShbIpcGetShbMemInst(pShbInstance_p); pShbMemHeader = ShbIpcGetShbMemHeader(pShbInstance_p); if (!--pShbMemHeader->m_ulRefCount) { ShbError = kShbOk; } else { ShbError = kShbMemUsedByOtherProcs; } ShbError2 = ShbIpcStopSignalingNewData(pShbInstance_p); hEventNewData = pShbMemInst->m_ahEventNewData[IDX_EVENT_NEW_DATA]; if (hEventNewData != INVALID_HANDLE_VALUE) { CloseHandle(hEventNewData); pShbMemInst->m_ahEventNewData[IDX_EVENT_NEW_DATA] = INVALID_HANDLE_VALUE; } hMutexBuffAccess = pShbMemInst->m_hMutexBuffAccess; if (hMutexBuffAccess != INVALID_HANDLE_VALUE) { CloseHandle(hMutexBuffAccess); pShbMemInst->m_hMutexBuffAccess = INVALID_HANDLE_VALUE; } UnmapViewOfFile(pShbMemHeader); if (pShbMemInst->m_hSharedMem != INVALID_HANDLE_VALUE) { CloseHandle(pShbMemInst->m_hSharedMem); pShbMemInst->m_hSharedMem = INVALID_HANDLE_VALUE; } ShbIpcReleasePrivateMem(pShbMemInst); if (ShbError == kShbOk) { ShbError = ShbError2; } return (ShbError); } #endif // !defined(SHBIPC_INLINE_ENABLED) #if (!defined(SHBIPC_INLINED)) || defined(SHBIPC_INLINE_ENABLED) //--------------------------------------------------------------------------- // Enter atomic section for Shared Buffer access //--------------------------------------------------------------------------- INLINE_FUNCTION tShbError ShbIpcEnterAtomicSection(tShbInstance pShbInstance_p) { tShbMemInst *pShbMemInst; HANDLE hMutexBuffAccess; DWORD dwWaitResult; tShbError ShbError; if (pShbInstance_p == NULL) { return (kShbInvalidArg); } pShbMemInst = ShbIpcGetShbMemInst(pShbInstance_p); ShbError = kShbOk; hMutexBuffAccess = pShbMemInst->m_hMutexBuffAccess; if (hMutexBuffAccess != INVALID_HANDLE_VALUE) { dwWaitResult = WaitForSingleObject(hMutexBuffAccess, TIMEOUT_ENTER_ATOMIC); switch (dwWaitResult) { case WAIT_OBJECT_0 + 0: { break; } case WAIT_TIMEOUT: { TRACE0 ("\nShbIpcEnterAtomicSection(): WAIT_TIMEOUT"); ASSERT(0); ShbError = kShbBufferInvalid; break; } case WAIT_ABANDONED: { TRACE0 ("\nShbIpcEnterAtomicSection(): WAIT_ABANDONED"); ASSERT(0); ShbError = kShbBufferInvalid; break; } case WAIT_FAILED: { TRACE1 ("\nShbIpcEnterAtomicSection(): WAIT_FAILED -> LastError=%ld", GetLastError()); ASSERT(0); ShbError = kShbBufferInvalid; break; } default: { TRACE1 ("\nShbIpcEnterAtomicSection(): unknown error -> LastError=%ld", GetLastError()); ASSERT(0); ShbError = kShbBufferInvalid; break; } } } else { ShbError = kShbBufferInvalid; } return (ShbError); } //--------------------------------------------------------------------------- // Leave atomic section for Shared Buffer access //--------------------------------------------------------------------------- INLINE_FUNCTION tShbError ShbIpcLeaveAtomicSection(tShbInstance pShbInstance_p) { tShbMemInst *pShbMemInst; HANDLE hMutexBuffAccess; BOOL fRes; tShbError ShbError; if (pShbInstance_p == NULL) { return (kShbInvalidArg); } pShbMemInst = ShbIpcGetShbMemInst(pShbInstance_p); ShbError = kShbOk; hMutexBuffAccess = pShbMemInst->m_hMutexBuffAccess; if (hMutexBuffAccess != INVALID_HANDLE_VALUE) { fRes = ReleaseMutex(hMutexBuffAccess); ASSERT(fRes); } else { ShbError = kShbBufferInvalid; } return (ShbError); } //--------------------------------------------------------------------------- // Start signaling of new data (called from reading process) //--------------------------------------------------------------------------- INLINE_FUNCTION tShbError ShbIpcStartSignalingNewData(tShbInstance pShbInstance_p, tSigHndlrNewData pfnSignalHandlerNewData_p, tShbPriority ShbPriority_p) { tShbMemInst *pShbMemInst; tShbMemHeader *pShbMemHeader; const char *pszObjectName; HANDLE hEventTermRequ; HANDLE hEventTermResp; HANDLE hThreadNewData; unsigned long ulThreadIDNewData; tShbError ShbError; int iPriority; if ((pShbInstance_p == NULL) || (pfnSignalHandlerNewData_p == NULL)) { return (kShbInvalidArg); } pShbMemInst = ShbIpcGetShbMemInst(pShbInstance_p); pShbMemHeader = ShbIpcGetShbMemHeader(pShbInstance_p); ShbError = kShbOk; if ((pShbMemInst->m_hThreadNewData != INVALID_HANDLE_VALUE) || (pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_REQU] != INVALID_HANDLE_VALUE) || (pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_RESP] != INVALID_HANDLE_VALUE) || (pShbMemInst->m_pfnSigHndlrNewData != NULL)) { ShbError = kShbAlreadySignaling; goto Exit; } pShbMemInst->m_pfnSigHndlrNewData = pfnSignalHandlerNewData_p; // Because the event m_ahEventNewData[IDX_EVENT_NEW_DATA]> // is used for signaling of new data after a write operation too (using // SetEvent), it is always created here (see ). pszObjectName = ShbIpcGetUniformObjectName(NAME_EVENT_TERM_REQU, pShbMemHeader->m_szBufferID, FALSE); hEventTermRequ = CreateEvent(NULL, // LPSECURITY_ATTRIBUTES lpEventAttributes FALSE, // BOOL bManualReset FALSE, // BOOL bInitialState pszObjectName); // LPCTSTR lpName pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_REQU] = hEventTermRequ; ASSERT(pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_REQU] != NULL); pszObjectName = ShbIpcGetUniformObjectName(NAME_EVENT_TERM_RESP, pShbMemHeader->m_szBufferID, FALSE); hEventTermResp = CreateEvent(NULL, // LPSECURITY_ATTRIBUTES lpEventAttributes FALSE, // BOOL bManualReset FALSE, // BOOL bInitialState pszObjectName); // LPCTSTR lpName pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_RESP] = hEventTermResp; ASSERT(pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_RESP] != NULL); hThreadNewData = CreateThread(NULL, // LPSECURITY_ATTRIBUTES lpThreadAttributes 0, // SIZE_T dwStackSize ShbIpcThreadSignalNewData, // LPTHREAD_START_ROUTINE lpStartAddress pShbInstance_p, // LPVOID lpParameter 0, // DWORD dwCreationFlags &ulThreadIDNewData); // LPDWORD lpThreadId switch (ShbPriority_p) { case kShbPriorityLow: iPriority = THREAD_PRIORITY_BELOW_NORMAL; break; case kShbPriorityNormal: iPriority = THREAD_PRIORITY_NORMAL; break; case kshbPriorityHigh: iPriority = THREAD_PRIORITY_ABOVE_NORMAL; break; } ASSERT(pShbMemInst->m_hThreadNewData != NULL); SetThreadPriority(hThreadNewData, iPriority); pShbMemInst->m_hThreadNewData = hThreadNewData; #ifndef NDEBUG { pShbMemInst->m_ulThreadIDNewData = ulThreadIDNewData; } #endif Exit: return (ShbError); } //--------------------------------------------------------------------------- // Stop signaling of new data (called from reading process) //--------------------------------------------------------------------------- INLINE_FUNCTION tShbError ShbIpcStopSignalingNewData(tShbInstance pShbInstance_p) { tShbMemInst *pShbMemInst; HANDLE hEventTermRequ; HANDLE hEventTermResp; DWORD dwWaitResult; if (pShbInstance_p == NULL) { return (kShbInvalidArg); } pShbMemInst = ShbIpcGetShbMemInst(pShbInstance_p); // terminate new data signaling thread // (set event to wakeup the thread and dispose it // to exit, then wait for confirmation using event ) hEventTermRequ = pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_REQU]; hEventTermResp = pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_RESP]; if ((hEventTermRequ != INVALID_HANDLE_VALUE) && (hEventTermResp != INVALID_HANDLE_VALUE)) { TRACE0("\nShbIpcStopSignalingNewData(): enter wait state"); dwWaitResult = SignalObjectAndWait(hEventTermRequ, // HANDLE hObjectToSignal hEventTermResp, // HANDLE hObjectToWaitOn TIMEOUT_TERM_THREAD, // DWORD dwMilliseconds FALSE); // BOOL bAlertable TRACE0 ("\nShbIpcStopSignalingNewData(): wait state leaved: ---> "); switch (dwWaitResult) { case WAIT_OBJECT_0 + 0: // event "new data signaling thread terminated" { TRACE0("Event = WAIT_OBJECT_0+0"); break; } default: { TRACE0("Unhandled Event"); ASSERT(0); break; } } } if (pShbMemInst->m_hThreadNewData != INVALID_HANDLE_VALUE) { CloseHandle(pShbMemInst->m_hThreadNewData); pShbMemInst->m_hThreadNewData = INVALID_HANDLE_VALUE; } if (pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_REQU] != INVALID_HANDLE_VALUE) { CloseHandle(pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_REQU]); pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_REQU] = INVALID_HANDLE_VALUE; } if (pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_RESP] != INVALID_HANDLE_VALUE) { CloseHandle(pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_RESP]); pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_RESP] = INVALID_HANDLE_VALUE; } pShbMemInst->m_pfnSigHndlrNewData = NULL; return (kShbOk); } //--------------------------------------------------------------------------- // Signal new data (called from writing process) //--------------------------------------------------------------------------- INLINE_FUNCTION tShbError ShbIpcSignalNewData(tShbInstance pShbInstance_p) { tShbMemInst *pShbMemInst; HANDLE hEventNewData; BOOL fRes; // TRACE0("\nShbIpcSignalNewData(): enter\n"); if (pShbInstance_p == NULL) { return (kShbInvalidArg); } pShbMemInst = ShbIpcGetShbMemInst(pShbInstance_p); ASSERT(pShbMemInst->m_ahEventNewData[IDX_EVENT_NEW_DATA] != INVALID_HANDLE_VALUE); hEventNewData = pShbMemInst->m_ahEventNewData[IDX_EVENT_NEW_DATA]; if (hEventNewData != INVALID_HANDLE_VALUE) { fRes = SetEvent(hEventNewData); // TRACE1("\nShbIpcSignalNewData(): EventNewData set (Result=%d)\n", (int)fRes); ASSERT(fRes); } // TRACE0("\nShbIpcSignalNewData(): leave\n"); return (kShbOk); } //--------------------------------------------------------------------------- // Start signaling for job ready (called from waiting process) //--------------------------------------------------------------------------- INLINE_FUNCTION tShbError ShbIpcStartSignalingJobReady(tShbInstance pShbInstance_p, unsigned long ulTimeOut_p, tSigHndlrJobReady pfnSignalHandlerJobReady_p) { tShbMemInst *pShbMemInst; tShbMemHeader *pShbMemHeader; HANDLE hThreadJobReady; unsigned long ulThreadIDJobReady; tShbError ShbError; if ((pShbInstance_p == NULL) || (pfnSignalHandlerJobReady_p == NULL)) { return (kShbInvalidArg); } pShbMemInst = ShbIpcGetShbMemInst(pShbInstance_p); pShbMemHeader = ShbIpcGetShbMemHeader(pShbInstance_p); ShbError = kShbOk; if ((pShbMemInst->m_hThreadJobReady != INVALID_HANDLE_VALUE) || (pShbMemInst->m_pfnSigHndlrJobReady != NULL)) { ShbError = kShbAlreadySignaling; goto Exit; } pShbMemInst->m_ulTimeOutJobReady = ulTimeOut_p; pShbMemInst->m_pfnSigHndlrJobReady = pfnSignalHandlerJobReady_p; // Because the event m_ahEventJobReady> is used for // signaling of a finished job too (using SetEvent), it is always // created here (see ). hThreadJobReady = CreateThread(NULL, // LPSECURITY_ATTRIBUTES lpThreadAttributes 0, // SIZE_T dwStackSize ShbIpcThreadSignalJobReady, // LPTHREAD_START_ROUTINE lpStartAddress pShbInstance_p, // LPVOID lpParameter 0, // DWORD dwCreationFlags &ulThreadIDJobReady); // LPDWORD lpThreadId pShbMemInst->m_hThreadJobReady = hThreadJobReady; ASSERT(pShbMemInst->m_hThreadJobReady != NULL); #ifndef NDEBUG { pShbMemInst->m_ulThreadIDJobReady = ulThreadIDJobReady; } #endif Exit: return (ShbError); } //--------------------------------------------------------------------------- // Signal job ready (called from executing process) //--------------------------------------------------------------------------- INLINE_FUNCTION tShbError ShbIpcSignalJobReady(tShbInstance pShbInstance_p) { tShbMemInst *pShbMemInst; HANDLE hEventJobReady; BOOL fRes; // TRACE0("\nShbIpcSignalJobReady(): enter\n"); if (pShbInstance_p == NULL) { return (kShbInvalidArg); } pShbMemInst = ShbIpcGetShbMemInst(pShbInstance_p); ASSERT(pShbMemInst->m_hEventJobReady != INVALID_HANDLE_VALUE); hEventJobReady = pShbMemInst->m_hEventJobReady; if (hEventJobReady != INVALID_HANDLE_VALUE) { fRes = SetEvent(hEventJobReady); // TRACE1("\nShbIpcSignalJobReady(): EventJobReady set (Result=%d)\n", (int)fRes); ASSERT(fRes); } // TRACE0("\nShbIpcSignalJobReady(): leave\n"); return (kShbOk); } //--------------------------------------------------------------------------- // Get pointer to common used share memory area //--------------------------------------------------------------------------- INLINE_FUNCTION void *ShbIpcGetShMemPtr(tShbInstance pShbInstance_p) { tShbMemHeader *pShbMemHeader; void *pShbShMemPtr; pShbMemHeader = ShbIpcGetShbMemHeader(pShbInstance_p); if (pShbMemHeader != NULL) { pShbShMemPtr = (BYTE *) pShbMemHeader + sizeof(tShbMemHeader); } else { pShbShMemPtr = NULL; } return (pShbShMemPtr); } #endif //=========================================================================// // // // P R I V A T E F U N C T I O N S // // // //=========================================================================// #if !defined(SHBIPC_INLINE_ENABLED) //--------------------------------------------------------------------------- // Allocate a memory block from process specific mempool //--------------------------------------------------------------------------- static void *ShbIpcAllocPrivateMem(unsigned long ulMemSize_p) { HGLOBAL hMem; void *pMem; hMem = GlobalAlloc(GMEM_FIXED, ulMemSize_p + sizeof(HGLOBAL)); pMem = GlobalLock(hMem); if (pMem != NULL) { *(HGLOBAL *) pMem = hMem; (BYTE *) pMem += sizeof(HGLOBAL); } #ifndef NDEBUG { memset(pMem, 0xaa, ulMemSize_p); } #endif return (pMem); } //--------------------------------------------------------------------------- // Release a memory block from process specific mempool //--------------------------------------------------------------------------- static void ShbIpcReleasePrivateMem(void *pMem_p) { HGLOBAL hMem; if (pMem_p == NULL) { return; } (BYTE *) pMem_p -= sizeof(HGLOBAL); hMem = *(HGLOBAL *) pMem_p; GlobalUnlock(hMem); GlobalFree(hMem); return; } //--------------------------------------------------------------------------- // Create uniform object name (needed for inter-process communication) //--------------------------------------------------------------------------- const char *ShbIpcGetUniformObjectName(const char *pszObjectJobName_p, const char *pszBufferID_p, BOOL fGlobalObject_p) { static char szObjectName[MAX_PATH]; char szObjectPrefix[MAX_PATH]; if (fGlobalObject_p) { strncpy(szObjectPrefix, "Global\\", sizeof(szObjectPrefix)); } else { _snprintf(szObjectPrefix, sizeof(szObjectPrefix), "PID%08lX_", (unsigned long)GetCurrentProcessId()); } _snprintf(szObjectName, sizeof(szObjectName), "%s%s#%s", szObjectPrefix, pszBufferID_p, pszObjectJobName_p); return (szObjectName); } //--------------------------------------------------------------------------- // Thread for new data signaling //--------------------------------------------------------------------------- DWORD WINAPI ShbIpcThreadSignalNewData(LPVOID pvThreadParam_p) { tShbInstance pShbInstance; tShbMemInst *pShbMemInst; DWORD dwWaitResult; BOOL fTermRequ; int fCallAgain; TRACE1 ("\nShbIpcThreadSignalNewData(): SignalThread started (pShbInstance=0x%08lX)\n", (DWORD) pvThreadParam_p); pShbInstance = (tShbMemInst *) pvThreadParam_p; pShbMemInst = ShbIpcGetShbMemInst(pShbInstance); fTermRequ = FALSE; do { ASSERT((pShbMemInst->m_ahEventNewData[0] != INVALID_HANDLE_VALUE) && (pShbMemInst->m_ahEventNewData[0] != NULL)); ASSERT((pShbMemInst->m_ahEventNewData[1] != INVALID_HANDLE_VALUE) && (pShbMemInst->m_ahEventNewData[1] != NULL)); TRACE0("\nShbIpcThreadSignalNewData(): enter wait state"); dwWaitResult = WaitForMultipleObjects(2, // DWORD nCount pShbMemInst->m_ahEventNewData, // const HANDLE* lpHandles FALSE, // BOOL bWaitAll INFINITE); // DWORD dwMilliseconds TRACE0 ("\nShbIpcThreadSignalNewData(): wait state leaved: ---> "); switch (dwWaitResult) { case WAIT_OBJECT_0 + 0: // event "new data" { TRACE0("Event = WAIT_OBJECT_0+0"); if (pShbMemInst->m_pfnSigHndlrNewData != NULL) { TRACE0 ("\nShbIpcThreadSignalNewData(): calling SignalHandlerNewData"); do { fCallAgain = pShbMemInst-> m_pfnSigHndlrNewData (pShbInstance); // d.k.: try to run any shared buffer which has higher priority. // under Windows this is not really necessary because the Windows scheduler // already preempts tasks with lower priority. } while (fCallAgain != FALSE); } break; } case WAIT_OBJECT_0 + 1: // event "terminate" { TRACE0("Event = WAIT_OBJECT_0+1"); fTermRequ = TRUE; break; } default: { TRACE0("Unhandled Event"); ASSERT(0); fTermRequ = TRUE; break; } } } while (!fTermRequ); if (pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_RESP] != INVALID_HANDLE_VALUE) { SetEvent(pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_RESP]); } TRACE1 ("\nShbIpcThreadSignalNewData(): SignalThread terminated (pShbInstance=0x%08lX)\n", (DWORD) pShbInstance); ExitThread(0); } //--------------------------------------------------------------------------- // Thread for new data signaling //--------------------------------------------------------------------------- DWORD WINAPI ShbIpcThreadSignalJobReady(LPVOID pvThreadParam_p) { tShbInstance *pShbInstance; tShbMemInst *pShbMemInst; DWORD ulTimeOut; DWORD dwWaitResult; unsigned int fTimeOut; TRACE1 ("\nShbIpcThreadSignalJobReady(): SignalThread started (pShbInstance=0x%08lX)\n", (DWORD) pvThreadParam_p); pShbInstance = (tShbInstance *) pvThreadParam_p; pShbMemInst = ShbIpcGetShbMemInst(pShbInstance); fTimeOut = FALSE; if (pShbMemInst->m_ulTimeOutJobReady != 0) { ulTimeOut = pShbMemInst->m_ulTimeOutJobReady; } else { ulTimeOut = INFINITE; } ASSERT((pShbMemInst->m_hEventJobReady != INVALID_HANDLE_VALUE) && (pShbMemInst->m_hEventJobReady != NULL)); TRACE0("\nShbIpcThreadSignalJobReady(): enter wait state"); dwWaitResult = WaitForSingleObject(pShbMemInst->m_hEventJobReady, // HANDLE hHandle ulTimeOut); // DWORD dwMilliseconds TRACE0("\nShbIpcThreadSignalJobReady(): wait state leaved: ---> "); switch (dwWaitResult) { case WAIT_OBJECT_0 + 0: // event "new data" { TRACE0("Event = WAIT_OBJECT_0+0"); fTimeOut = FALSE; break; } case WAIT_TIMEOUT: { TRACE0("\nEvent = WAIT_TIMEOUT"); fTimeOut = TRUE; // ASSERT(0); break; } default: { TRACE0("Unhandled Event"); fTimeOut = TRUE; ASSERT(0); break; } } if (pShbMemInst->m_pfnSigHndlrJobReady != NULL) { TRACE0 ("\nShbIpcThreadSignalJobReady(): calling SignalHandlerJobReady"); pShbMemInst->m_pfnSigHndlrJobReady(pShbInstance, fTimeOut); } pShbMemInst->m_hThreadJobReady = INVALID_HANDLE_VALUE; pShbMemInst->m_pfnSigHndlrJobReady = NULL; TRACE1 ("\nShbIpcThreadSignalJobReady(): SignalThread terminated (pShbInstance=0x%08lX)\n", (DWORD) pShbInstance); ExitThread(0); } #endif // EOF