| /**************************************************************************** |
| |
| (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 <SignalObjectAndWait> |
| |
| #include <windows.h> |
| #include <stdio.h> |
| #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 <m_pShbMemHeader> 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 <pShbMemInst->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 <ShbIpcAllocBuffer>). |
| |
| 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 <hEventTermRequ> to wakeup the thread and dispose it |
| // to exit, then wait for confirmation using event <hEventTermResp>) |
| 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 <pShbMemInst->m_ahEventJobReady> is used for |
| // signaling of a finished job too (using SetEvent), it is always |
| // created here (see <ShbIpcAllocBuffer>). |
| |
| 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 |
| |
