| /**************************************************************************** |
| |
| (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 independend part for the |
| shared buffer |
| |
| 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) |
| |
| ****************************************************************************/ |
| |
| #if defined(WIN32) || defined(_WIN32) |
| |
| #ifdef UNDER_RTSS |
| // RTX header |
| #include <windows.h> |
| #include <process.h> |
| #include <rtapi.h> |
| |
| #elif __BORLANDC__ |
| // borland C header |
| #include <windows.h> |
| #include <process.h> |
| |
| #elif WINCE |
| #include <windows.h> |
| |
| #else |
| // MSVC needs to include windows.h at first |
| // the following defines ar necessary for function prototypes for waitable timers |
| #define _WIN32_WINDOWS 0x0401 |
| #define _WIN32_WINNT 0x0400 |
| #include <windows.h> |
| #include <process.h> |
| #endif |
| |
| #endif |
| |
| #include "global.h" |
| #include "SharedBuff.h" |
| #include "ShbIpc.h" |
| |
| #include <linux/string.h> |
| #include <linux/kernel.h> |
| |
| /***************************************************************************/ |
| /* */ |
| /* */ |
| /* G L O B A L D E F I N I T I O N S */ |
| /* */ |
| /* */ |
| /***************************************************************************/ |
| |
| //--------------------------------------------------------------------------- |
| // Configuration |
| //--------------------------------------------------------------------------- |
| |
| //--------------------------------------------------------------------------- |
| // Constant definitions |
| //--------------------------------------------------------------------------- |
| |
| #define SBC_MAGIC_ID 0x53424323 // magic ID ("SBC#") |
| #define SBL_MAGIC_ID 0x53424C23 // magic ID ("SBL#") |
| |
| //--------------------------------------------------------------------------- |
| // Local types |
| //--------------------------------------------------------------------------- |
| |
| // structure to administrate circular shared buffer head |
| typedef struct { |
| unsigned long m_ShbCirMagicID; // magic ID ("SBC#") |
| unsigned long m_ulBufferTotalSize; // over-all size of complete buffer |
| unsigned long m_ulBufferDataSize; // size of complete data area |
| unsigned long m_ulWrIndex; // current write index (set bevore write) |
| unsigned long m_ulRdIndex; // current read index (set after read) |
| unsigned long m_ulNumOfWriteJobs; // number of currently (parallel running) write operations |
| unsigned long m_ulDataInUse; // currently used buffer size (incl. uncompleted write operations) |
| unsigned long m_ulDataApended; // buffer size of complete new written but not yet readable data (in case of m_ulNumOfWriteJobs>1) |
| unsigned long m_ulBlocksApended; // number of complete new written but not yet readable data blocks (in case of m_ulNumOfWriteJobs>1) |
| unsigned long m_ulDataReadable; // buffer size with readable (complete written) data |
| unsigned long m_ulBlocksReadable; // number of readable (complete written) data blocks |
| tShbCirSigHndlrNewData m_pfnSigHndlrNewData; // application handler to signal new data |
| unsigned int m_fBufferLocked; // TRUE if buffer is locked (because of pending reset request) |
| tShbCirSigHndlrReset m_pfnSigHndlrReset; // application handler to signal buffer reset is done |
| unsigned char m_Data; // start of data area (the real data size is unknown at this time) |
| |
| } tShbCirBuff; |
| |
| // structure to administrate linear shared buffer head |
| typedef struct { |
| unsigned int m_ShbLinMagicID; // magic ID ("SBL#") |
| unsigned long m_ulBufferTotalSize; // over-all size of complete buffer |
| unsigned long m_ulBufferDataSize; // size of complete data area |
| unsigned char m_Data; // start of data area (the real data size is unknown at this time) |
| |
| } tShbLinBuff; |
| |
| // type to save size of a single data block inside the circular shared buffer |
| typedef struct { |
| unsigned int m_uiFullBlockSize:28; // a single block must not exceed a length of 256MByte :-) |
| unsigned int m_uiAlignFillBytes:4; |
| |
| } tShbCirBlockSize; |
| |
| #define SBC_BLOCK_ALIGNMENT 4 // alignment must *not* be lower than sizeof(tShbCirBlockSize)! |
| #define SBC_MAX_BLOCK_SIZE ((1<<28)-1) // = (2^28 - 1) = (256MByte - 1) -> should be enought for real life :-) |
| |
| #define SBL_BLOCK_ALIGNMENT 4 |
| #define SBL_MAX_BLOCK_SIZE ((1<<28)-1) // = (2^28 - 1) = (256MByte - 1) -> should be enought for real life :-) |
| |
| //--------------------------------------------------------------------------- |
| // Global variables |
| //--------------------------------------------------------------------------- |
| |
| //--------------------------------------------------------------------------- |
| // Local variables |
| //--------------------------------------------------------------------------- |
| |
| //--------------------------------------------------------------------------- |
| // Prototypes of internal functions |
| //--------------------------------------------------------------------------- |
| |
| //--------------------------------------------------------------------------- |
| // Get pointer to Circular Shared Buffer |
| //--------------------------------------------------------------------------- |
| |
| tShbCirBuff *ShbCirGetBuffer(tShbInstance pShbInstance_p) |
| { |
| |
| tShbCirBuff *pShbCirBuff; |
| |
| pShbCirBuff = (tShbCirBuff *) ShbIpcGetShMemPtr(pShbInstance_p); |
| ASSERT(pShbCirBuff->m_ShbCirMagicID == SBC_MAGIC_ID); |
| |
| return (pShbCirBuff); |
| |
| } |
| |
| //--------------------------------------------------------------------------- |
| // Get pointer to Linear Shared Buffer |
| //--------------------------------------------------------------------------- |
| |
| tShbLinBuff *ShbLinGetBuffer(tShbInstance pShbInstance_p) |
| { |
| |
| tShbLinBuff *pShbLinBuff; |
| |
| pShbLinBuff = (tShbLinBuff *) ShbIpcGetShMemPtr(pShbInstance_p); |
| ASSERT(pShbLinBuff->m_ShbLinMagicID == SBL_MAGIC_ID); |
| |
| return (pShbLinBuff); |
| |
| } |
| |
| // not inlined internal functions |
| int ShbCirSignalHandlerNewData(tShbInstance pShbInstance_p); |
| void ShbCirSignalHandlerReset(tShbInstance pShbInstance_p, |
| unsigned int fTimeOut_p); |
| |
| |
| //=========================================================================// |
| // // |
| // P U B L I C F U N C T I O N S // |
| // // |
| //=========================================================================// |
| |
| // not inlined external functions |
| |
| //--------------------------------------------------------------------------- |
| // Initialize Shared Buffer Module |
| //--------------------------------------------------------------------------- |
| |
| tShbError ShbInit(void) |
| { |
| |
| tShbError ShbError; |
| |
| ShbError = ShbIpcInit(); |
| |
| return (ShbError); |
| |
| } |
| |
| //--------------------------------------------------------------------------- |
| // Deinitialize Shared Buffer Module |
| //--------------------------------------------------------------------------- |
| |
| tShbError ShbExit(void) |
| { |
| |
| tShbError ShbError; |
| |
| ShbError = ShbIpcExit(); |
| |
| return (ShbError); |
| |
| } |
| |
| //-------------------------------------------------------------------------// |
| // // |
| // C i r c u l a r S h a r e d B u f f e r // |
| // // |
| //-------------------------------------------------------------------------// |
| |
| //--------------------------------------------------------------------------- |
| // Allocate Circular Shared Buffer |
| //--------------------------------------------------------------------------- |
| |
| tShbError ShbCirAllocBuffer(unsigned long ulBufferSize_p, |
| const char *pszBufferID_p, |
| tShbInstance * ppShbInstance_p, |
| unsigned int *pfShbNewCreated_p) |
| { |
| |
| tShbInstance pShbInstance; |
| tShbCirBuff *pShbCirBuff; |
| unsigned int fShbNewCreated; |
| unsigned long ulBufferDataSize; |
| unsigned long ulBufferTotalSize; |
| tShbError ShbError; |
| |
| // check arguments |
| if ((ulBufferSize_p == 0) || (ppShbInstance_p == NULL)) { |
| return (kShbInvalidArg); |
| } |
| |
| // calculate length of memory to allocate |
| ulBufferDataSize = |
| (ulBufferSize_p + |
| (SBC_BLOCK_ALIGNMENT - 1)) & ~(SBC_BLOCK_ALIGNMENT - 1); |
| ulBufferTotalSize = ulBufferDataSize + sizeof(tShbCirBuff); |
| |
| // allocate a new or open an existing shared buffer |
| ShbError = ShbIpcAllocBuffer(ulBufferTotalSize, pszBufferID_p, |
| &pShbInstance, &fShbNewCreated); |
| if (ShbError != kShbOk) { |
| goto Exit; |
| } |
| |
| if (pShbInstance == NULL) { |
| ShbError = kShbOutOfMem; |
| goto Exit; |
| } |
| |
| // get pointer to shared buffer |
| pShbCirBuff = (tShbCirBuff *) ShbIpcGetShMemPtr(pShbInstance); |
| |
| // if the shared buffer was new created, than this process has |
| // to initialize it, otherwise the buffer is already in use |
| // and *must not* be reseted |
| if (fShbNewCreated) { |
| #ifndef NDEBUG |
| { |
| memset(pShbCirBuff, 0xCC, ulBufferTotalSize); |
| } |
| #endif |
| |
| pShbCirBuff->m_ShbCirMagicID = SBC_MAGIC_ID; |
| pShbCirBuff->m_ulBufferTotalSize = ulBufferTotalSize; |
| pShbCirBuff->m_ulBufferDataSize = ulBufferDataSize; |
| pShbCirBuff->m_ulWrIndex = 0; |
| pShbCirBuff->m_ulRdIndex = 0; |
| pShbCirBuff->m_ulNumOfWriteJobs = 0; |
| pShbCirBuff->m_ulDataInUse = 0; |
| pShbCirBuff->m_ulDataApended = 0; |
| pShbCirBuff->m_ulBlocksApended = 0; |
| pShbCirBuff->m_ulDataReadable = 0; |
| pShbCirBuff->m_ulBlocksReadable = 0; |
| pShbCirBuff->m_pfnSigHndlrNewData = NULL; |
| pShbCirBuff->m_fBufferLocked = FALSE; |
| pShbCirBuff->m_pfnSigHndlrReset = NULL; |
| } else { |
| if (pShbCirBuff->m_ShbCirMagicID != SBC_MAGIC_ID) { |
| ShbError = kShbInvalidBufferType; |
| goto Exit; |
| } |
| } |
| |
| Exit: |
| |
| *ppShbInstance_p = pShbInstance; |
| *pfShbNewCreated_p = fShbNewCreated; |
| |
| return (ShbError); |
| |
| } |
| |
| //--------------------------------------------------------------------------- |
| // Release Circular Shared Buffer |
| //--------------------------------------------------------------------------- |
| |
| tShbError ShbCirReleaseBuffer(tShbInstance pShbInstance_p) |
| { |
| |
| tShbError ShbError; |
| |
| // check arguments |
| if (pShbInstance_p == NULL) { |
| ShbError = kShbOk; |
| goto Exit; |
| } |
| |
| ShbError = ShbIpcReleaseBuffer(pShbInstance_p); |
| |
| Exit: |
| |
| return (ShbError); |
| |
| } |
| |
| //--------------------------------------------------------------------------- |
| // Reset Circular Shared Buffer |
| //--------------------------------------------------------------------------- |
| |
| tShbError ShbCirResetBuffer(tShbInstance pShbInstance_p, |
| unsigned long ulTimeOut_p, |
| tShbCirSigHndlrReset pfnSignalHandlerReset_p) |
| { |
| |
| tShbCirBuff *pShbCirBuff; |
| unsigned long ulNumOfWriteJobs = 0; // d.k. GCC complains about uninitialized variable otherwise |
| tShbError ShbError; |
| |
| // check arguments |
| if (pShbInstance_p == NULL) { |
| ShbError = kShbInvalidArg; |
| goto Exit; |
| } |
| |
| pShbCirBuff = ShbCirGetBuffer(pShbInstance_p); |
| ShbError = kShbOk; |
| |
| if (pShbCirBuff->m_ShbCirMagicID != SBC_MAGIC_ID) { |
| ShbError = kShbInvalidBufferType; |
| goto Exit; |
| } |
| |
| // start reset job by setting request request in buffer header |
| ShbIpcEnterAtomicSection(pShbInstance_p); |
| { |
| if (!pShbCirBuff->m_fBufferLocked) { |
| ulNumOfWriteJobs = pShbCirBuff->m_ulNumOfWriteJobs; |
| |
| pShbCirBuff->m_fBufferLocked = TRUE; |
| pShbCirBuff->m_pfnSigHndlrReset = |
| pfnSignalHandlerReset_p; |
| } else { |
| ShbError = kShbAlreadyReseting; |
| } |
| } |
| ShbIpcLeaveAtomicSection(pShbInstance_p); |
| |
| if (ShbError != kShbOk) { |
| goto Exit; |
| } |
| |
| // if there is currently no running write operation then reset buffer |
| // immediately, otherwise wait until the last write job is ready by |
| // starting a signal process |
| if (ulNumOfWriteJobs == 0) { |
| // there is currently no running write operation |
| // -> reset buffer immediately |
| ShbCirSignalHandlerReset(pShbInstance_p, FALSE); |
| ShbError = kShbOk; |
| } else { |
| // there is currently at least one running write operation |
| // -> starting signal process to wait until the last write job is ready |
| ShbError = |
| ShbIpcStartSignalingJobReady(pShbInstance_p, ulTimeOut_p, |
| ShbCirSignalHandlerReset); |
| } |
| |
| Exit: |
| |
| return (ShbError); |
| |
| } |
| |
| //--------------------------------------------------------------------------- |
| // Write data block to Circular Shared Buffer |
| //--------------------------------------------------------------------------- |
| |
| tShbError ShbCirWriteDataBlock(tShbInstance pShbInstance_p, |
| const void *pSrcDataBlock_p, |
| unsigned long ulDataBlockSize_p) |
| { |
| |
| tShbCirBuff *pShbCirBuff; |
| tShbCirBlockSize ShbCirBlockSize; |
| unsigned int uiFullBlockSize; |
| unsigned int uiAlignFillBytes; |
| unsigned char *pShbCirDataPtr; |
| unsigned char *pScrDataPtr; |
| unsigned long ulDataSize; |
| unsigned long ulChunkSize; |
| unsigned long ulWrIndex = 0; // d.k. GCC complains about uninitialized variable otherwise |
| unsigned int fSignalNewData; |
| unsigned int fSignalReset; |
| tShbError ShbError; |
| tShbError ShbError2; |
| int fRes; |
| |
| // check arguments |
| if (pShbInstance_p == NULL) { |
| ShbError = kShbInvalidArg; |
| goto Exit; |
| } |
| |
| if ((pSrcDataBlock_p == NULL) || (ulDataBlockSize_p == 0)) { |
| // nothing to do here |
| ShbError = kShbOk; |
| goto Exit; |
| } |
| |
| if (ulDataBlockSize_p > SBC_MAX_BLOCK_SIZE) { |
| ShbError = kShbExceedDataSizeLimit; |
| goto Exit; |
| } |
| |
| pShbCirBuff = ShbCirGetBuffer(pShbInstance_p); |
| pScrDataPtr = (unsigned char *)pSrcDataBlock_p; |
| fSignalNewData = FALSE; |
| fSignalReset = FALSE; |
| ShbError = kShbOk; |
| |
| if (pShbCirBuff->m_ShbCirMagicID != SBC_MAGIC_ID) { |
| ShbError = kShbInvalidBufferType; |
| goto Exit; |
| } |
| |
| // calculate data block size in circular buffer |
| ulDataSize = |
| (ulDataBlockSize_p + |
| (SBC_BLOCK_ALIGNMENT - 1)) & ~(SBC_BLOCK_ALIGNMENT - 1); |
| uiFullBlockSize = ulDataSize + sizeof(tShbCirBlockSize); // data size + header |
| uiAlignFillBytes = ulDataSize - ulDataBlockSize_p; |
| |
| ShbCirBlockSize.m_uiFullBlockSize = uiFullBlockSize; |
| ShbCirBlockSize.m_uiAlignFillBytes = uiAlignFillBytes; |
| |
| // reserve the needed memory for the write operation to do now |
| // and make necessary adjustments in the circular buffer header |
| ShbIpcEnterAtomicSection(pShbInstance_p); |
| { |
| // check if there is sufficient memory available to store |
| // the new data |
| fRes = |
| uiFullBlockSize <= |
| (pShbCirBuff->m_ulBufferDataSize - |
| pShbCirBuff->m_ulDataInUse); |
| if (fRes) { |
| // set write pointer for the write operation to do now |
| // to the current write pointer of the circular buffer |
| ulWrIndex = pShbCirBuff->m_ulWrIndex; |
| |
| // reserve the needed memory for the write operation to do now |
| pShbCirBuff->m_ulDataInUse += uiFullBlockSize; |
| |
| // set new write pointer behind the reserved memory |
| // for the write operation to do now |
| pShbCirBuff->m_ulWrIndex += uiFullBlockSize; |
| pShbCirBuff->m_ulWrIndex %= |
| pShbCirBuff->m_ulBufferDataSize; |
| |
| // increment number of currently (parallel running) |
| // write operations |
| pShbCirBuff->m_ulNumOfWriteJobs++; |
| } |
| } |
| ShbIpcLeaveAtomicSection(pShbInstance_p); |
| |
| if (!fRes) { |
| ShbError = kShbBufferFull; |
| goto Exit; |
| } |
| |
| // copy the data to the circular buffer |
| // (the copy process itself will be done outside of any |
| // critical/locked section) |
| pShbCirDataPtr = &pShbCirBuff->m_Data; // ptr to start of data area |
| |
| // write real size of current block (incl. alignment fill bytes) |
| *(tShbCirBlockSize *) (pShbCirDataPtr + ulWrIndex) = ShbCirBlockSize; |
| ulWrIndex += sizeof(tShbCirBlockSize); |
| ulWrIndex %= pShbCirBuff->m_ulBufferDataSize; |
| |
| if (ulWrIndex + ulDataBlockSize_p <= pShbCirBuff->m_ulBufferDataSize) { |
| // linear write operation |
| memcpy(pShbCirDataPtr + ulWrIndex, pScrDataPtr, |
| ulDataBlockSize_p); |
| } else { |
| // wrap-around write operation |
| ulChunkSize = pShbCirBuff->m_ulBufferDataSize - ulWrIndex; |
| memcpy(pShbCirDataPtr + ulWrIndex, pScrDataPtr, ulChunkSize); |
| memcpy(pShbCirDataPtr, pScrDataPtr + ulChunkSize, |
| ulDataBlockSize_p - ulChunkSize); |
| } |
| |
| // adjust header information for circular buffer with properties |
| // of the wiritten data block |
| ShbIpcEnterAtomicSection(pShbInstance_p); |
| { |
| pShbCirBuff->m_ulDataApended += uiFullBlockSize; |
| pShbCirBuff->m_ulBlocksApended++; |
| |
| // decrement number of currently (parallel running) write operations |
| if (!--pShbCirBuff->m_ulNumOfWriteJobs) { |
| // if there is no other write process running then |
| // set new size of readable (complete written) data and |
| // adjust number of readable blocks |
| pShbCirBuff->m_ulDataReadable += |
| pShbCirBuff->m_ulDataApended; |
| pShbCirBuff->m_ulBlocksReadable += |
| pShbCirBuff->m_ulBlocksApended; |
| |
| pShbCirBuff->m_ulDataApended = 0; |
| pShbCirBuff->m_ulBlocksApended = 0; |
| |
| fSignalNewData = TRUE; |
| fSignalReset = pShbCirBuff->m_fBufferLocked; |
| } |
| } |
| ShbIpcLeaveAtomicSection(pShbInstance_p); |
| |
| // signal new data event to a potentially reading application |
| if (fSignalNewData) { |
| ShbError2 = ShbIpcSignalNewData(pShbInstance_p); |
| if (ShbError == kShbOk) { |
| ShbError = ShbError2; |
| } |
| } |
| // signal that the last write job has been finished to allow |
| // a waiting application to reset the buffer now |
| if (fSignalReset) { |
| ShbError2 = ShbIpcSignalJobReady(pShbInstance_p); |
| if (ShbError == kShbOk) { |
| ShbError = ShbError2; |
| } |
| } |
| |
| Exit: |
| |
| return (ShbError); |
| |
| } |
| |
| //--------------------------------------------------------------------------- |
| // Allocate block within the Circular Shared Buffer for chunk writing |
| //--------------------------------------------------------------------------- |
| |
| tShbError ShbCirAllocDataBlock(tShbInstance pShbInstance_p, |
| tShbCirChunk * pShbCirChunk_p, |
| unsigned long ulDataBufferSize_p) |
| { |
| |
| tShbCirBuff *pShbCirBuff; |
| tShbCirBlockSize ShbCirBlockSize; |
| unsigned int uiFullBlockSize; |
| unsigned int uiAlignFillBytes; |
| unsigned char *pShbCirDataPtr; |
| unsigned long ulDataSize; |
| unsigned long ulWrIndex = 0; // d.k. GCC complains about uninitialized variable otherwise |
| tShbError ShbError; |
| int fRes; |
| |
| // check arguments |
| if ((pShbInstance_p == NULL) || (pShbCirChunk_p == NULL)) { |
| ShbError = kShbInvalidArg; |
| goto Exit; |
| } |
| |
| if (ulDataBufferSize_p == 0) { |
| ShbError = kShbInvalidArg; |
| goto Exit; |
| } |
| |
| if (ulDataBufferSize_p > SBC_MAX_BLOCK_SIZE) { |
| ShbError = kShbExceedDataSizeLimit; |
| goto Exit; |
| } |
| |
| pShbCirBuff = ShbCirGetBuffer(pShbInstance_p); |
| ShbError = kShbOk; |
| |
| if (pShbCirBuff->m_ShbCirMagicID != SBC_MAGIC_ID) { |
| ShbError = kShbInvalidBufferType; |
| goto Exit; |
| } |
| |
| // calculate data block size in circular buffer |
| ulDataSize = |
| (ulDataBufferSize_p + |
| (SBC_BLOCK_ALIGNMENT - 1)) & ~(SBC_BLOCK_ALIGNMENT - 1); |
| uiFullBlockSize = ulDataSize + sizeof(tShbCirBlockSize); // data size + header |
| uiAlignFillBytes = ulDataSize - ulDataBufferSize_p; |
| |
| ShbCirBlockSize.m_uiFullBlockSize = uiFullBlockSize; |
| ShbCirBlockSize.m_uiAlignFillBytes = uiAlignFillBytes; |
| |
| // reserve the needed memory for the write operation to do now |
| // and make necessary adjustments in the circular buffer header |
| ShbIpcEnterAtomicSection(pShbInstance_p); |
| { |
| // check if there is sufficient memory available to store |
| // the new data |
| fRes = |
| (uiFullBlockSize <= |
| (pShbCirBuff->m_ulBufferDataSize - |
| pShbCirBuff->m_ulDataInUse)); |
| if (fRes) { |
| // set write pointer for the write operation to do now |
| // to the current write pointer of the circular buffer |
| ulWrIndex = pShbCirBuff->m_ulWrIndex; |
| |
| // reserve the needed memory for the write operation to do now |
| pShbCirBuff->m_ulDataInUse += uiFullBlockSize; |
| |
| // set new write pointer behind the reserved memory |
| // for the write operation to do now |
| pShbCirBuff->m_ulWrIndex += uiFullBlockSize; |
| pShbCirBuff->m_ulWrIndex %= |
| pShbCirBuff->m_ulBufferDataSize; |
| |
| // increment number of currently (parallel running) |
| // write operations |
| pShbCirBuff->m_ulNumOfWriteJobs++; |
| } |
| } |
| ShbIpcLeaveAtomicSection(pShbInstance_p); |
| |
| if (!fRes) { |
| ShbError = kShbBufferFull; |
| goto Exit; |
| } |
| |
| // setup header information for allocated buffer |
| pShbCirDataPtr = &pShbCirBuff->m_Data; // ptr to start of data area |
| |
| // write real size of current block (incl. alignment fill bytes) |
| *(tShbCirBlockSize *) (pShbCirDataPtr + ulWrIndex) = ShbCirBlockSize; |
| ulWrIndex += sizeof(tShbCirBlockSize); |
| ulWrIndex %= pShbCirBuff->m_ulBufferDataSize; |
| |
| // setup chunk descriptor |
| pShbCirChunk_p->m_uiFullBlockSize = uiFullBlockSize; |
| pShbCirChunk_p->m_ulAvailableSize = ulDataBufferSize_p; |
| pShbCirChunk_p->m_ulWrIndex = ulWrIndex; |
| pShbCirChunk_p->m_fBufferCompleted = FALSE; |
| |
| Exit: |
| |
| return (ShbError); |
| |
| } |
| |
| //--------------------------------------------------------------------------- |
| // Write data chunk into an allocated buffer of the Circular Shared Buffer |
| //--------------------------------------------------------------------------- |
| |
| tShbError ShbCirWriteDataChunk(tShbInstance pShbInstance_p, |
| tShbCirChunk *pShbCirChunk_p, |
| const void *pSrcDataChunk_p, |
| unsigned long ulDataChunkSize_p, |
| unsigned int *pfBufferCompleted_p) |
| { |
| |
| tShbCirBuff *pShbCirBuff; |
| unsigned char *pShbCirDataPtr; |
| unsigned char *pScrDataPtr; |
| unsigned long ulSubChunkSize; |
| unsigned long ulWrIndex; |
| unsigned int fBufferCompleted; |
| unsigned int fSignalNewData; |
| unsigned int fSignalReset; |
| tShbError ShbError; |
| tShbError ShbError2; |
| |
| // check arguments |
| if ((pShbInstance_p == NULL) || (pShbCirChunk_p == NULL) |
| || (pfBufferCompleted_p == NULL)) { |
| ShbError = kShbInvalidArg; |
| goto Exit; |
| } |
| |
| if ((pSrcDataChunk_p == NULL) || (ulDataChunkSize_p == 0)) { |
| // nothing to do here |
| ShbError = kShbOk; |
| goto Exit; |
| } |
| |
| if (pShbCirChunk_p->m_fBufferCompleted) { |
| ShbError = kShbBufferAlreadyCompleted; |
| goto Exit; |
| } |
| |
| if (ulDataChunkSize_p > pShbCirChunk_p->m_ulAvailableSize) { |
| ShbError = kShbExceedDataSizeLimit; |
| goto Exit; |
| } |
| |
| pShbCirBuff = ShbCirGetBuffer(pShbInstance_p); |
| pScrDataPtr = (unsigned char *)pSrcDataChunk_p; |
| fSignalNewData = FALSE; |
| fSignalReset = FALSE; |
| ShbError = kShbOk; |
| |
| if (pShbCirBuff->m_ShbCirMagicID != SBC_MAGIC_ID) { |
| ShbError = kShbInvalidBufferType; |
| goto Exit; |
| } |
| |
| ulWrIndex = pShbCirChunk_p->m_ulWrIndex; |
| |
| // copy the data to the circular buffer |
| // (the copy process itself will be done outside of any |
| // critical/locked section) |
| pShbCirDataPtr = &pShbCirBuff->m_Data; // ptr to start of data area |
| |
| if (ulWrIndex + ulDataChunkSize_p <= pShbCirBuff->m_ulBufferDataSize) { |
| // linear write operation |
| memcpy(pShbCirDataPtr + ulWrIndex, pScrDataPtr, |
| ulDataChunkSize_p); |
| } else { |
| // wrap-around write operation |
| ulSubChunkSize = pShbCirBuff->m_ulBufferDataSize - ulWrIndex; |
| memcpy(pShbCirDataPtr + ulWrIndex, pScrDataPtr, ulSubChunkSize); |
| memcpy(pShbCirDataPtr, pScrDataPtr + ulSubChunkSize, |
| ulDataChunkSize_p - ulSubChunkSize); |
| } |
| |
| // adjust chunk descriptor |
| ulWrIndex += ulDataChunkSize_p; |
| ulWrIndex %= pShbCirBuff->m_ulBufferDataSize; |
| |
| pShbCirChunk_p->m_ulAvailableSize -= ulDataChunkSize_p; |
| pShbCirChunk_p->m_ulWrIndex = ulWrIndex; |
| |
| fBufferCompleted = (pShbCirChunk_p->m_ulAvailableSize == 0); |
| pShbCirChunk_p->m_fBufferCompleted = fBufferCompleted; |
| |
| // if the complete allocated buffer is filled with data then |
| // adjust header information for circular buffer with properties |
| // of the wiritten data block |
| if (fBufferCompleted) { |
| ShbIpcEnterAtomicSection(pShbInstance_p); |
| { |
| pShbCirBuff->m_ulDataApended += |
| pShbCirChunk_p->m_uiFullBlockSize; |
| pShbCirBuff->m_ulBlocksApended++; |
| |
| // decrement number of currently (parallel running) write operations |
| if (!--pShbCirBuff->m_ulNumOfWriteJobs) { |
| // if there is no other write process running then |
| // set new size of readable (complete written) data and |
| // adjust number of readable blocks |
| pShbCirBuff->m_ulDataReadable += |
| pShbCirBuff->m_ulDataApended; |
| pShbCirBuff->m_ulBlocksReadable += |
| pShbCirBuff->m_ulBlocksApended; |
| |
| pShbCirBuff->m_ulDataApended = 0; |
| pShbCirBuff->m_ulBlocksApended = 0; |
| |
| fSignalNewData = TRUE; |
| fSignalReset = pShbCirBuff->m_fBufferLocked; |
| } |
| } |
| ShbIpcLeaveAtomicSection(pShbInstance_p); |
| } |
| |
| // signal new data event to a potentially reading application |
| if (fSignalNewData) { |
| ShbError2 = ShbIpcSignalNewData(pShbInstance_p); |
| if (ShbError == kShbOk) { |
| ShbError = ShbError2; |
| } |
| } |
| // signal that the last write job has been finished to allow |
| // a waiting application to reset the buffer now |
| if (fSignalReset) { |
| ShbError2 = ShbIpcSignalJobReady(pShbInstance_p); |
| if (ShbError == kShbOk) { |
| ShbError = ShbError2; |
| } |
| } |
| |
| *pfBufferCompleted_p = fBufferCompleted; |
| |
| Exit: |
| |
| return (ShbError); |
| |
| } |
| |
| //--------------------------------------------------------------------------- |
| // Read data block from Circular Shared Buffer |
| //--------------------------------------------------------------------------- |
| |
| tShbError ShbCirReadDataBlock(tShbInstance pShbInstance_p, |
| void *pDstDataBlock_p, |
| unsigned long ulRdBuffSize_p, |
| unsigned long *pulDataBlockSize_p) |
| { |
| |
| tShbCirBuff *pShbCirBuff; |
| tShbCirBlockSize ShbCirBlockSize; |
| unsigned long ulDataReadable; |
| unsigned char *pShbCirDataPtr; |
| unsigned char *pDstDataPtr; |
| unsigned long ulDataSize = 0; // d.k. GCC complains about uninitialized variable otherwise |
| unsigned long ulChunkSize; |
| unsigned long ulRdIndex; |
| tShbError ShbError; |
| |
| // check arguments |
| if ((pShbInstance_p == NULL) || (pulDataBlockSize_p == NULL)) { |
| return (kShbInvalidArg); |
| } |
| |
| if ((pDstDataBlock_p == NULL) || (ulRdBuffSize_p == 0)) { |
| // nothing to do here |
| ShbError = kShbOk; |
| goto Exit; |
| } |
| |
| ShbError = kShbOk; |
| pShbCirBuff = ShbCirGetBuffer(pShbInstance_p); |
| pDstDataPtr = (unsigned char *)pDstDataBlock_p; |
| ulDataSize = 0; |
| |
| if (pShbCirBuff->m_ShbCirMagicID != SBC_MAGIC_ID) { |
| ShbError = kShbInvalidBufferType; |
| goto Exit; |
| } |
| |
| // get total number of readable bytes for the whole circular buffer |
| ShbIpcEnterAtomicSection(pShbInstance_p); |
| { |
| ulDataReadable = pShbCirBuff->m_ulDataReadable; |
| } |
| ShbIpcLeaveAtomicSection(pShbInstance_p); |
| |
| // if there are readable data available, then there must be at least |
| // one complete readable data block |
| if (ulDataReadable > 0) { |
| // get pointer to start of data area and current read index |
| pShbCirDataPtr = &pShbCirBuff->m_Data; // ptr to start of data area |
| ulRdIndex = pShbCirBuff->m_ulRdIndex; |
| |
| // get real size of current block (incl. alignment fill bytes) |
| ShbCirBlockSize = |
| *(tShbCirBlockSize *) (pShbCirDataPtr + ulRdIndex); |
| ulRdIndex += sizeof(tShbCirBlockSize); |
| ulRdIndex %= pShbCirBuff->m_ulBufferDataSize; |
| |
| // get size of user data inside the current block |
| ulDataSize = |
| ShbCirBlockSize.m_uiFullBlockSize - |
| ShbCirBlockSize.m_uiAlignFillBytes; |
| ulDataSize -= sizeof(tShbCirBlockSize); |
| } |
| |
| // ulDataSize = MIN(ulDataSize, ulRdBuffSize_p); |
| if (ulDataSize > ulRdBuffSize_p) { |
| ulDataSize = ulRdBuffSize_p; |
| ShbError = kShbDataTruncated; |
| } |
| |
| if (ulDataSize == 0) { |
| // nothing to do here |
| ShbError = kShbNoReadableData; |
| goto Exit; |
| } |
| |
| // copy the data from the circular buffer |
| // (the copy process itself will be done outside of any |
| // critical/locked section) |
| if (ulRdIndex + ulDataSize <= pShbCirBuff->m_ulBufferDataSize) { |
| // linear read operation |
| memcpy(pDstDataPtr, pShbCirDataPtr + ulRdIndex, ulDataSize); |
| } else { |
| // wrap-around read operation |
| ulChunkSize = pShbCirBuff->m_ulBufferDataSize - ulRdIndex; |
| memcpy(pDstDataPtr, pShbCirDataPtr + ulRdIndex, ulChunkSize); |
| memcpy(pDstDataPtr + ulChunkSize, pShbCirDataPtr, |
| ulDataSize - ulChunkSize); |
| } |
| |
| #ifndef NDEBUG |
| { |
| tShbCirBlockSize ClrShbCirBlockSize; |
| |
| if (ulRdIndex + ulDataSize <= pShbCirBuff->m_ulBufferDataSize) { |
| // linear buffer |
| memset(pShbCirDataPtr + ulRdIndex, 0xDD, ulDataSize); |
| } else { |
| // wrap-around read operation |
| ulChunkSize = |
| pShbCirBuff->m_ulBufferDataSize - ulRdIndex; |
| memset(pShbCirDataPtr + ulRdIndex, 0xDD, ulChunkSize); |
| memset(pShbCirDataPtr, 0xDD, ulDataSize - ulChunkSize); |
| } |
| |
| ClrShbCirBlockSize.m_uiFullBlockSize = /*(unsigned int) */ -1; // -1 = xFFFFFFF |
| ClrShbCirBlockSize.m_uiAlignFillBytes = /*(unsigned int) */ -1; // -1 = Fxxxxxxx |
| *(tShbCirBlockSize *) (pShbCirDataPtr + |
| pShbCirBuff->m_ulRdIndex) = |
| ClrShbCirBlockSize; |
| } |
| #endif // #ifndef NDEBUG |
| |
| // set new size of readable data, data in use, new read index |
| // and adjust number of readable blocks |
| ShbIpcEnterAtomicSection(pShbInstance_p); |
| { |
| pShbCirBuff->m_ulDataInUse -= ShbCirBlockSize.m_uiFullBlockSize; |
| pShbCirBuff->m_ulDataReadable -= |
| ShbCirBlockSize.m_uiFullBlockSize; |
| pShbCirBuff->m_ulBlocksReadable--; |
| |
| //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ |
| if ((pShbCirBuff->m_ulDataInUse == 0) |
| && (pShbCirBuff->m_ulDataReadable == 0)) { |
| ASSERT(pShbCirBuff->m_ulBlocksReadable == 0); |
| |
| pShbCirBuff->m_ulWrIndex = 0; |
| pShbCirBuff->m_ulRdIndex = 0; |
| } else |
| //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ |
| { |
| pShbCirBuff->m_ulRdIndex += |
| ShbCirBlockSize.m_uiFullBlockSize; |
| pShbCirBuff->m_ulRdIndex %= |
| pShbCirBuff->m_ulBufferDataSize; |
| } |
| } |
| ShbIpcLeaveAtomicSection(pShbInstance_p); |
| |
| Exit: |
| |
| *pulDataBlockSize_p = ulDataSize; |
| |
| return (ShbError); |
| |
| } |
| |
| //--------------------------------------------------------------------------- |
| // Get data size of next readable block from Circular Shared Buffer |
| //--------------------------------------------------------------------------- |
| |
| tShbError ShbCirGetReadDataSize(tShbInstance pShbInstance_p, |
| unsigned long *pulDataBlockSize_p) |
| { |
| |
| tShbCirBuff *pShbCirBuff; |
| unsigned long ulDataReadable; |
| unsigned char *pShbCirDataPtr; |
| tShbCirBlockSize ShbCirBlockSize; |
| unsigned long ulDataSize; |
| tShbError ShbError; |
| |
| // check arguments |
| if ((pShbInstance_p == NULL) || (pulDataBlockSize_p == NULL)) { |
| return (kShbInvalidArg); |
| } |
| |
| pShbCirBuff = ShbCirGetBuffer(pShbInstance_p); |
| ulDataSize = 0; |
| ShbError = kShbOk; |
| |
| if (pShbCirBuff->m_ShbCirMagicID != SBC_MAGIC_ID) { |
| ShbError = kShbInvalidBufferType; |
| goto Exit; |
| } |
| |
| // get total number of readable bytes for the whole circular buffer |
| ShbIpcEnterAtomicSection(pShbInstance_p); |
| { |
| ulDataReadable = pShbCirBuff->m_ulDataReadable; |
| } |
| ShbIpcLeaveAtomicSection(pShbInstance_p); |
| |
| // if there are readable data available, then there must be at least |
| // one complete readable data block |
| if (ulDataReadable > 0) { |
| pShbCirDataPtr = |
| &pShbCirBuff->m_Data + pShbCirBuff->m_ulRdIndex; |
| |
| // get real size of current block (incl. alignment fill bytes) |
| ShbCirBlockSize = *(tShbCirBlockSize *) pShbCirDataPtr; |
| |
| // get size of user data inside the current block |
| ulDataSize = |
| ShbCirBlockSize.m_uiFullBlockSize - |
| ShbCirBlockSize.m_uiAlignFillBytes; |
| ulDataSize -= sizeof(tShbCirBlockSize); |
| } |
| |
| Exit: |
| |
| *pulDataBlockSize_p = ulDataSize; |
| |
| return (ShbError); |
| |
| } |
| |
| //--------------------------------------------------------------------------- |
| // Get number of readable blocks from Circular Shared Buffer |
| //--------------------------------------------------------------------------- |
| |
| tShbError ShbCirGetReadBlockCount(tShbInstance pShbInstance_p, |
| unsigned long *pulDataBlockCount_p) |
| { |
| |
| tShbCirBuff *pShbCirBuff; |
| unsigned long ulBlockCount; |
| tShbError ShbError; |
| |
| // check arguments |
| if ((pShbInstance_p == NULL) || (pulDataBlockCount_p == NULL)) { |
| ShbError = kShbInvalidArg; |
| goto Exit; |
| } |
| |
| pShbCirBuff = ShbCirGetBuffer(pShbInstance_p); |
| ulBlockCount = 0; |
| ShbError = kShbOk; |
| |
| if (pShbCirBuff->m_ShbCirMagicID != SBC_MAGIC_ID) { |
| ShbError = kShbInvalidBufferType; |
| goto Exit; |
| } |
| |
| ShbIpcEnterAtomicSection(pShbInstance_p); |
| { |
| ulBlockCount = pShbCirBuff->m_ulBlocksReadable; |
| } |
| ShbIpcLeaveAtomicSection(pShbInstance_p); |
| |
| *pulDataBlockCount_p = ulBlockCount; |
| |
| Exit: |
| |
| return (ShbError); |
| |
| } |
| |
| //--------------------------------------------------------------------------- |
| // Set application handler to signal new data for Circular Shared Buffer |
| // d.k.: new parameter priority as enum |
| //--------------------------------------------------------------------------- |
| |
| tShbError ShbCirSetSignalHandlerNewData(tShbInstance pShbInstance_p, |
| tShbCirSigHndlrNewData pfnSignalHandlerNewData_p, |
| tShbPriority ShbPriority_p) |
| { |
| |
| tShbCirBuff *pShbCirBuff; |
| tShbError ShbError; |
| |
| // check arguments |
| if (pShbInstance_p == NULL) { |
| ShbError = kShbInvalidArg; |
| goto Exit; |
| } |
| |
| pShbCirBuff = ShbCirGetBuffer(pShbInstance_p); |
| ShbError = kShbOk; |
| |
| if (pShbCirBuff->m_ShbCirMagicID != SBC_MAGIC_ID) { |
| ShbError = kShbInvalidBufferType; |
| goto Exit; |
| } |
| |
| if (pfnSignalHandlerNewData_p != NULL) { |
| // set a new signal handler |
| if (pShbCirBuff->m_pfnSigHndlrNewData != NULL) { |
| ShbError = kShbAlreadySignaling; |
| goto Exit; |
| } |
| |
| pShbCirBuff->m_pfnSigHndlrNewData = pfnSignalHandlerNewData_p; |
| ShbError = |
| ShbIpcStartSignalingNewData(pShbInstance_p, |
| ShbCirSignalHandlerNewData, |
| ShbPriority_p); |
| } else { |
| // remove existing signal handler |
| ShbError = ShbIpcStopSignalingNewData(pShbInstance_p); |
| if (pShbCirBuff->m_pfnSigHndlrNewData != NULL) { |
| pShbCirBuff->m_pfnSigHndlrNewData(pShbInstance_p, 0); |
| } |
| pShbCirBuff->m_pfnSigHndlrNewData = NULL; |
| } |
| |
| Exit: |
| |
| return (ShbError); |
| |
| } |
| |
| //--------------------------------------------------------------------------- |
| // DEBUG: Trace Circular Shared Buffer |
| //--------------------------------------------------------------------------- |
| |
| #ifndef NDEBUG |
| tShbError ShbCirTraceBuffer(tShbInstance pShbInstance_p) |
| { |
| |
| tShbCirBuff *pShbCirBuff; |
| char szMagigID[sizeof(SBC_MAGIC_ID) + 1]; |
| tShbCirBlockSize ShbCirBlockSize; |
| unsigned long ulDataReadable; |
| unsigned char *pShbCirDataPtr; |
| unsigned long ulBlockIndex; |
| unsigned int nBlockCount; |
| unsigned long ulDataSize; |
| unsigned long ulChunkSize; |
| unsigned long ulRdIndex; |
| tShbError ShbError; |
| |
| TRACE0("\n\n##### Circular Shared Buffer #####\n"); |
| |
| // check arguments |
| if (pShbInstance_p == NULL) { |
| TRACE1("\nERROR: invalid buffer address (0x%08lX)\n", |
| (unsigned long)pShbInstance_p); |
| ShbError = kShbInvalidArg; |
| goto Exit; |
| } |
| |
| pShbCirBuff = ShbCirGetBuffer(pShbInstance_p); |
| ShbError = kShbOk; |
| |
| if (pShbCirBuff->m_ShbCirMagicID != SBC_MAGIC_ID) { |
| ShbError = kShbInvalidBufferType; |
| goto Exit; |
| } |
| |
| *(unsigned long *)&szMagigID[0] = pShbCirBuff->m_ShbCirMagicID; |
| szMagigID[sizeof(SBC_MAGIC_ID)] = '\0'; |
| |
| ShbIpcEnterAtomicSection(pShbInstance_p); |
| { |
| TRACE1("\nBuffer Address: 0x%08lX\n", |
| (unsigned long)pShbCirBuff); |
| |
| TRACE0("\nHeader Info:"); |
| TRACE2("\nMagigID: '%s' (%08lX)", szMagigID, |
| pShbCirBuff->m_ShbCirMagicID); |
| TRACE1("\nBufferTotalSize: %4lu [Bytes]", |
| pShbCirBuff->m_ulBufferTotalSize); |
| TRACE1("\nBufferDataSize: %4lu [Bytes]", |
| pShbCirBuff->m_ulBufferDataSize); |
| TRACE1("\nWrIndex: %4lu", pShbCirBuff->m_ulWrIndex); |
| TRACE1("\nRdIndex: %4lu", pShbCirBuff->m_ulRdIndex); |
| TRACE1("\nNumOfWriteJobs: %4lu", |
| pShbCirBuff->m_ulNumOfWriteJobs); |
| TRACE1("\nDataInUse: %4lu [Bytes]", |
| pShbCirBuff->m_ulDataInUse); |
| TRACE1("\nDataApended: %4lu [Bytes]", |
| pShbCirBuff->m_ulDataApended); |
| TRACE1("\nBlocksApended: %4lu", |
| pShbCirBuff->m_ulBlocksApended); |
| TRACE1("\nDataReadable: %4lu [Bytes]", |
| pShbCirBuff->m_ulDataReadable); |
| TRACE1("\nBlocksReadable: %4lu", |
| pShbCirBuff->m_ulBlocksReadable); |
| TRACE1("\nSigHndlrNewData: %08lX", |
| (unsigned long)pShbCirBuff->m_pfnSigHndlrNewData); |
| TRACE1("\nBufferLocked: %d", pShbCirBuff->m_fBufferLocked); |
| TRACE1("\nSigHndlrReset: %08lX", |
| (unsigned long)pShbCirBuff->m_pfnSigHndlrReset); |
| |
| ShbTraceDump(&pShbCirBuff->m_Data, |
| pShbCirBuff->m_ulBufferDataSize, 0x00000000L, |
| "\nData Area:"); |
| |
| ulDataReadable = pShbCirBuff->m_ulDataReadable; |
| nBlockCount = 1; |
| ulBlockIndex = pShbCirBuff->m_ulRdIndex; |
| |
| while (ulDataReadable > 0) { |
| TRACE1("\n\n--- Block #%u ---", nBlockCount); |
| |
| // get pointer to start of data area and current read index |
| pShbCirDataPtr = &pShbCirBuff->m_Data; // ptr to start of data area |
| ulRdIndex = ulBlockIndex; |
| |
| // get real size of current block (incl. alignment fill bytes) |
| ShbCirBlockSize = |
| *(tShbCirBlockSize *) (pShbCirDataPtr + ulRdIndex); |
| ulRdIndex += sizeof(tShbCirBlockSize); |
| ulRdIndex %= pShbCirBuff->m_ulBufferDataSize; |
| |
| // get size of user data inside the current block |
| ulDataSize = |
| ShbCirBlockSize.m_uiFullBlockSize - |
| ShbCirBlockSize.m_uiAlignFillBytes; |
| ulDataSize -= sizeof(tShbCirBlockSize); |
| |
| TRACE1 |
| ("\nFull Data Size: %4u [Bytes] (incl. header and alignment fill bytes)", |
| ShbCirBlockSize.m_uiFullBlockSize); |
| TRACE1("\nUser Data Size: %4lu [Bytes]", |
| ulDataSize); |
| TRACE1("\nAlignment Fill Bytes: %4u [Bytes]", |
| ShbCirBlockSize.m_uiAlignFillBytes); |
| |
| if (ulRdIndex + ulDataSize <= |
| pShbCirBuff->m_ulBufferDataSize) { |
| // linear data buffer |
| ShbTraceDump(pShbCirDataPtr + ulRdIndex, |
| ulDataSize, 0x00000000L, NULL); |
| } else { |
| // wrap-around data buffer |
| ulChunkSize = |
| pShbCirBuff->m_ulBufferDataSize - ulRdIndex; |
| ShbTraceDump(pShbCirDataPtr + ulRdIndex, |
| ulChunkSize, 0x00000000L, NULL); |
| ShbTraceDump(pShbCirDataPtr, |
| ulDataSize - ulChunkSize, |
| ulChunkSize, NULL); |
| } |
| |
| nBlockCount++; |
| |
| ulBlockIndex += ShbCirBlockSize.m_uiFullBlockSize; |
| ulBlockIndex %= pShbCirBuff->m_ulBufferDataSize; |
| |
| ulDataReadable -= ShbCirBlockSize.m_uiFullBlockSize; |
| } |
| |
| ASSERT(pShbCirBuff->m_ulBlocksReadable == nBlockCount - 1); |
| } |
| ShbIpcLeaveAtomicSection(pShbInstance_p); |
| |
| Exit: |
| |
| return (ShbError); |
| |
| } |
| #endif |
| |
| //-------------------------------------------------------------------------// |
| // // |
| // L i n e a r S h a r e d B u f f e r // |
| // // |
| //-------------------------------------------------------------------------// |
| |
| //--------------------------------------------------------------------------- |
| // Allocate Linear Shared Buffer |
| //--------------------------------------------------------------------------- |
| |
| tShbError ShbLinAllocBuffer(unsigned long ulBufferSize_p, |
| const char *pszBufferID_p, |
| tShbInstance * ppShbInstance_p, |
| unsigned int *pfShbNewCreated_p) |
| { |
| |
| tShbInstance pShbInstance; |
| tShbLinBuff *pShbLinBuff; |
| unsigned int fShbNewCreated; |
| unsigned long ulBufferDataSize; |
| unsigned long ulBufferTotalSize; |
| tShbError ShbError; |
| |
| // check arguments |
| if ((ulBufferSize_p == 0) || (ppShbInstance_p == NULL)) { |
| return (kShbInvalidArg); |
| } |
| |
| // calculate length of memory to allocate |
| ulBufferDataSize = |
| (ulBufferSize_p + |
| (SBL_BLOCK_ALIGNMENT - 1)) & ~(SBL_BLOCK_ALIGNMENT - 1); |
| ulBufferTotalSize = ulBufferDataSize + sizeof(tShbLinBuff); |
| |
| // allocate a new or open an existing shared buffer |
| ShbError = ShbIpcAllocBuffer(ulBufferTotalSize, pszBufferID_p, |
| &pShbInstance, &fShbNewCreated); |
| if (ShbError != kShbOk) { |
| goto Exit; |
| } |
| |
| if (pShbInstance == NULL) { |
| ShbError = kShbOutOfMem; |
| goto Exit; |
| } |
| |
| // get pointer to shared buffer |
| pShbLinBuff = (tShbLinBuff *) ShbIpcGetShMemPtr(pShbInstance); |
| |
| // if the shared buffer was new created, than this process has |
| // to initialize it, otherwise the buffer is already in use |
| // and *must not* be reseted |
| if (fShbNewCreated) { |
| #ifndef NDEBUG |
| { |
| memset(pShbLinBuff, 0xCC, ulBufferTotalSize); |
| } |
| #endif |
| |
| pShbLinBuff->m_ShbLinMagicID = SBL_MAGIC_ID; |
| pShbLinBuff->m_ulBufferTotalSize = ulBufferTotalSize; |
| pShbLinBuff->m_ulBufferDataSize = ulBufferDataSize; |
| } else { |
| if (pShbLinBuff->m_ShbLinMagicID != SBL_MAGIC_ID) { |
| ShbError = kShbInvalidBufferType; |
| goto Exit; |
| } |
| } |
| |
| Exit: |
| |
| *ppShbInstance_p = pShbInstance; |
| *pfShbNewCreated_p = fShbNewCreated; |
| |
| return (ShbError); |
| |
| } |
| |
| //--------------------------------------------------------------------------- |
| // Release Linear Shared Buffer |
| //--------------------------------------------------------------------------- |
| |
| tShbError ShbLinReleaseBuffer(tShbInstance pShbInstance_p) |
| { |
| |
| tShbError ShbError; |
| |
| // check arguments |
| if (pShbInstance_p == NULL) { |
| ShbError = kShbOk; |
| goto Exit; |
| } |
| |
| ShbError = ShbIpcReleaseBuffer(pShbInstance_p); |
| |
| Exit: |
| |
| return (ShbError); |
| |
| } |
| |
| //--------------------------------------------------------------------------- |
| // Write data block to Linear Shared Buffer |
| //--------------------------------------------------------------------------- |
| tShbError ShbLinWriteDataBlock(tShbInstance pShbInstance_p, |
| unsigned long ulDstBufferOffs_p, |
| const void *pSrcDataBlock_p, |
| unsigned long ulDataBlockSize_p) |
| { |
| |
| tShbLinBuff *pShbLinBuff; |
| unsigned char *pShbLinDataPtr; |
| unsigned char *pScrDataPtr; |
| unsigned long ulBufferDataSize; |
| tShbError ShbError; |
| |
| // check arguments |
| if (pShbInstance_p == NULL) { |
| ShbError = kShbInvalidArg; |
| goto Exit; |
| } |
| |
| if ((pSrcDataBlock_p == NULL) || (ulDataBlockSize_p == 0)) { |
| // nothing to do here |
| ShbError = kShbOk; |
| goto Exit; |
| } |
| |
| if (ulDataBlockSize_p > SBL_MAX_BLOCK_SIZE) { |
| ShbError = kShbExceedDataSizeLimit; |
| goto Exit; |
| } |
| |
| pShbLinBuff = ShbLinGetBuffer(pShbInstance_p); |
| pScrDataPtr = (unsigned char *)pSrcDataBlock_p; |
| ShbError = kShbOk; |
| |
| if (pShbLinBuff->m_ShbLinMagicID != SBL_MAGIC_ID) { |
| ShbError = kShbInvalidBufferType; |
| goto Exit; |
| } |
| |
| // check if offeset and size for the write operation matches with |
| // the size of the shared buffer |
| ulBufferDataSize = pShbLinBuff->m_ulBufferDataSize; |
| if ((ulDstBufferOffs_p > ulBufferDataSize) || |
| (ulDataBlockSize_p > ulBufferDataSize) || |
| ((ulDstBufferOffs_p + ulDataBlockSize_p) > ulBufferDataSize)) { |
| ShbError = kShbDataOutsideBufferArea; |
| goto Exit; |
| } |
| |
| // copy the data to the linear buffer |
| // (the copy process will be done inside of any critical/locked section) |
| pShbLinDataPtr = &pShbLinBuff->m_Data; // ptr to start of data area |
| pShbLinDataPtr += ulDstBufferOffs_p; |
| |
| ShbIpcEnterAtomicSection(pShbInstance_p); |
| { |
| memcpy(pShbLinDataPtr, pScrDataPtr, ulDataBlockSize_p); |
| } |
| ShbIpcLeaveAtomicSection(pShbInstance_p); |
| |
| Exit: |
| |
| return (ShbError); |
| |
| } |
| |
| //--------------------------------------------------------------------------- |
| // Read data block from Linear Shared Buffer |
| //--------------------------------------------------------------------------- |
| tShbError ShbLinReadDataBlock(tShbInstance pShbInstance_p, |
| void *pDstDataBlock_p, |
| unsigned long ulSrcBufferOffs_p, |
| unsigned long ulDataBlockSize_p) |
| { |
| |
| tShbLinBuff *pShbLinBuff; |
| unsigned char *pShbLinDataPtr; |
| unsigned char *pDstDataPtr; |
| unsigned long ulBufferDataSize; |
| tShbError ShbError; |
| |
| // check arguments |
| if (pShbInstance_p == NULL) { |
| ShbError = kShbInvalidArg; |
| goto Exit; |
| } |
| |
| if ((pDstDataBlock_p == NULL) || (ulDataBlockSize_p == 0)) { |
| // nothing to do here |
| ShbError = kShbOk; |
| goto Exit; |
| } |
| |
| if (ulDataBlockSize_p > SBL_MAX_BLOCK_SIZE) { |
| ShbError = kShbExceedDataSizeLimit; |
| goto Exit; |
| } |
| |
| pShbLinBuff = ShbLinGetBuffer(pShbInstance_p); |
| pDstDataPtr = (unsigned char *)pDstDataBlock_p; |
| ShbError = kShbOk; |
| |
| if (pShbLinBuff->m_ShbLinMagicID != SBL_MAGIC_ID) { |
| ShbError = kShbInvalidBufferType; |
| goto Exit; |
| } |
| |
| // check if offeset and size for the read operation matches with |
| // the size of the shared buffer |
| ulBufferDataSize = pShbLinBuff->m_ulBufferDataSize; |
| if ((ulSrcBufferOffs_p > ulBufferDataSize) || |
| (ulDataBlockSize_p > ulBufferDataSize) || |
| ((ulSrcBufferOffs_p + ulDataBlockSize_p) > ulBufferDataSize)) { |
| ShbError = kShbDataOutsideBufferArea; |
| goto Exit; |
| } |
| |
| // copy the data to the linear buffer |
| // (the copy process will be done inside of any critical/locked section) |
| pShbLinDataPtr = &pShbLinBuff->m_Data; // ptr to start of data area |
| pShbLinDataPtr += ulSrcBufferOffs_p; |
| |
| ShbIpcEnterAtomicSection(pShbInstance_p); |
| { |
| memcpy(pDstDataPtr, pShbLinDataPtr, ulDataBlockSize_p); |
| } |
| ShbIpcLeaveAtomicSection(pShbInstance_p); |
| |
| Exit: |
| |
| return (ShbError); |
| |
| } |
| |
| //--------------------------------------------------------------------------- |
| // DEBUG: Trace Linear Shared Buffer |
| //--------------------------------------------------------------------------- |
| |
| #ifndef NDEBUG |
| tShbError ShbLinTraceBuffer(tShbInstance pShbInstance_p) |
| { |
| |
| tShbLinBuff *pShbLinBuff; |
| char szMagigID[sizeof(SBL_MAGIC_ID) + 1]; |
| tShbError ShbError; |
| |
| TRACE0("\n\n##### Linear Shared Buffer #####\n"); |
| |
| // check arguments |
| if (pShbInstance_p == NULL) { |
| TRACE1("\nERROR: invalid buffer address (0x%08lX)\n", |
| (unsigned long)pShbInstance_p); |
| ShbError = kShbInvalidArg; |
| goto Exit; |
| } |
| |
| pShbLinBuff = ShbLinGetBuffer(pShbInstance_p); |
| ShbError = kShbOk; |
| |
| if (pShbLinBuff->m_ShbLinMagicID != SBL_MAGIC_ID) { |
| ShbError = kShbInvalidBufferType; |
| goto Exit; |
| } |
| |
| *(unsigned int *)&szMagigID[0] = pShbLinBuff->m_ShbLinMagicID; |
| szMagigID[sizeof(SBL_MAGIC_ID)] = '\0'; |
| |
| ShbIpcEnterAtomicSection(pShbInstance_p); |
| { |
| TRACE1("\nBuffer Address: 0x%08lX\n", |
| (unsigned long)pShbLinBuff); |
| |
| TRACE0("\nHeader Info:"); |
| TRACE2("\nMagigID: '%s' (%08X)", szMagigID, |
| pShbLinBuff->m_ShbLinMagicID); |
| TRACE1("\nBufferTotalSize: %4lu [Bytes]", |
| pShbLinBuff->m_ulBufferTotalSize); |
| TRACE1("\nBufferDataSize: %4lu [Bytes]", |
| pShbLinBuff->m_ulBufferDataSize); |
| |
| ShbTraceDump(&pShbLinBuff->m_Data, |
| pShbLinBuff->m_ulBufferDataSize, 0x00000000L, |
| "\nData Area:"); |
| } |
| ShbIpcLeaveAtomicSection(pShbInstance_p); |
| |
| Exit: |
| |
| return (ShbError); |
| |
| } |
| #endif |
| |
| //--------------------------------------------------------------------------- |
| // Dump buffer contents |
| //--------------------------------------------------------------------------- |
| |
| #ifndef NDEBUG |
| tShbError ShbTraceDump(const unsigned char *pabStartAddr_p, |
| unsigned long ulDataSize_p, |
| unsigned long ulAddrOffset_p, const char *pszInfoText_p) |
| { |
| |
| const unsigned char *pabBuffData; |
| unsigned long ulBuffSize; |
| unsigned char bData; |
| int nRow; |
| int nCol; |
| |
| // get pointer to buffer and length of buffer |
| pabBuffData = pabStartAddr_p; |
| ulBuffSize = ulDataSize_p; |
| |
| if (pszInfoText_p != NULL) { |
| TRACE1("%s", pszInfoText_p); |
| } |
| // dump buffer contents |
| for (nRow = 0;; nRow++) { |
| TRACE1("\n%08lX: ", |
| (unsigned long)(nRow * 0x10) + ulAddrOffset_p); |
| |
| for (nCol = 0; nCol < 16; nCol++) { |
| if ((unsigned long)nCol < ulBuffSize) { |
| TRACE1("%02X ", |
| (unsigned int)*(pabBuffData + nCol)); |
| } else { |
| TRACE0(" "); |
| } |
| } |
| |
| TRACE0(" "); |
| |
| for (nCol = 0; nCol < 16; nCol++) { |
| bData = *pabBuffData++; |
| if ((unsigned long)nCol < ulBuffSize) { |
| if ((bData >= 0x20) && (bData < 0x7F)) { |
| TRACE1("%c", bData); |
| } else { |
| TRACE0("."); |
| } |
| } else { |
| TRACE0(" "); |
| } |
| } |
| |
| if (ulBuffSize > 16) { |
| ulBuffSize -= 16; |
| } else { |
| break; |
| } |
| } |
| |
| return (kShbOk); |
| |
| } |
| #endif // #ifndef NDEBUG |
| |
| //=========================================================================// |
| // // |
| // P R I V A T E F U N C T I O N S // |
| // // |
| //=========================================================================// |
| |
| //--------------------------------------------------------------------------- |
| // Handler to signal new data event for Circular Shared Buffer |
| //--------------------------------------------------------------------------- |
| |
| int ShbCirSignalHandlerNewData(tShbInstance pShbInstance_p) |
| { |
| |
| tShbCirBuff *pShbCirBuff; |
| unsigned long ulDataSize; |
| unsigned long ulBlockCount; |
| tShbError ShbError; |
| |
| // check arguments |
| if (pShbInstance_p == NULL) { |
| return FALSE; |
| } |
| |
| pShbCirBuff = ShbCirGetBuffer(pShbInstance_p); |
| ShbError = kShbOk; |
| |
| if (pShbCirBuff->m_ShbCirMagicID != SBC_MAGIC_ID) { |
| return FALSE; |
| } |
| |
| // call application handler |
| if (pShbCirBuff->m_pfnSigHndlrNewData != NULL) { |
| /* do |
| {*/ |
| ShbError = ShbCirGetReadDataSize(pShbInstance_p, &ulDataSize); |
| if ((ulDataSize > 0) && (ShbError == kShbOk)) { |
| pShbCirBuff->m_pfnSigHndlrNewData(pShbInstance_p, |
| ulDataSize); |
| } |
| |
| ShbError = |
| ShbCirGetReadBlockCount(pShbInstance_p, &ulBlockCount); |
| /* } |
| while ((ulBlockCount > 0) && (ShbError == kShbOk));*/ |
| } |
| // Return TRUE if there are pending blocks. |
| // In that case ShbIpc tries to call this function again immediately if there |
| // is no other filled shared buffer with higher priority. |
| return ((ulBlockCount > 0) && (ShbError == kShbOk)); |
| |
| } |
| |
| //--------------------------------------------------------------------------- |
| // Handler to reset Circular Shared Buffer |
| //--------------------------------------------------------------------------- |
| |
| void ShbCirSignalHandlerReset(tShbInstance pShbInstance_p, |
| unsigned int fTimeOut_p) |
| { |
| |
| tShbCirBuff *pShbCirBuff; |
| |
| // check arguments |
| if (pShbInstance_p == NULL) { |
| return; |
| } |
| |
| pShbCirBuff = ShbCirGetBuffer(pShbInstance_p); |
| if (pShbCirBuff->m_ShbCirMagicID != SBC_MAGIC_ID) { |
| return; |
| } |
| |
| // reset buffer header |
| if (!fTimeOut_p) { |
| ShbIpcEnterAtomicSection(pShbInstance_p); |
| { |
| pShbCirBuff->m_ulWrIndex = 0; |
| pShbCirBuff->m_ulRdIndex = 0; |
| pShbCirBuff->m_ulNumOfWriteJobs = 0; |
| pShbCirBuff->m_ulDataInUse = 0; |
| pShbCirBuff->m_ulDataApended = 0; |
| pShbCirBuff->m_ulBlocksApended = 0; |
| pShbCirBuff->m_ulDataReadable = 0; |
| pShbCirBuff->m_ulBlocksReadable = 0; |
| } |
| ShbIpcLeaveAtomicSection(pShbInstance_p); |
| |
| #ifndef NDEBUG |
| { |
| memset(&pShbCirBuff->m_Data, 0xCC, |
| pShbCirBuff->m_ulBufferDataSize); |
| } |
| #endif |
| } |
| |
| // call application handler |
| if (pShbCirBuff->m_pfnSigHndlrReset != NULL) { |
| pShbCirBuff->m_pfnSigHndlrReset(pShbInstance_p, fTimeOut_p); |
| } |
| |
| // unlock buffer |
| ShbIpcEnterAtomicSection(pShbInstance_p); |
| { |
| pShbCirBuff->m_fBufferLocked = FALSE; |
| pShbCirBuff->m_pfnSigHndlrReset = NULL; |
| } |
| ShbIpcLeaveAtomicSection(pShbInstance_p); |
| |
| return; |
| |
| } |
| |
| // EOF |