| /**************************************************************************** |
| |
| (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" |
| |
| // d.k. Linux kernel modules needs other header files for memcpy() |
| #if (TARGET_SYSTEM == _LINUX_) && defined(__KERNEL__) |
| #include <linux/string.h> |
| #else |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #endif |
| |
| |
| |
| |
| /***************************************************************************/ |
| /* */ |
| /* */ |
| /* G L O B A L D E F I N I T I O N S */ |
| /* */ |
| /* */ |
| /***************************************************************************/ |
| |
| #if (!defined(SHAREDBUFF_INLINED)) || defined(INLINE_ENABLED) |
| |
| //--------------------------------------------------------------------------- |
| // 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 |
| //--------------------------------------------------------------------------- |
| |
| INLINE_FUNCTION 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 |
| //--------------------------------------------------------------------------- |
| |
| INLINE_FUNCTION 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); |
| |
| #endif |
| |
| |
| |
| //=========================================================================// |
| // // |
| // P U B L I C F U N C T I O N S // |
| // // |
| //=========================================================================// |
| |
| #if !defined(INLINE_ENABLED) |
| // 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); |
| |
| } |
| |
| |
| #endif // !defined(INLINE_ENABLED) |
| |
| #if (!defined(SHAREDBUFF_INLINED)) || defined(INLINE_ENABLED) |
| |
| //--------------------------------------------------------------------------- |
| // Reset Circular Shared Buffer |
| //--------------------------------------------------------------------------- |
| |
| INLINE_FUNCTION 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 |
| //--------------------------------------------------------------------------- |
| |
| INLINE_FUNCTION 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 |
| //--------------------------------------------------------------------------- |
| |
| INLINE_FUNCTION 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 |
| //--------------------------------------------------------------------------- |
| |
| INLINE_FUNCTION 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 |
| //--------------------------------------------------------------------------- |
| |
| INLINE_FUNCTION 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 |
| //--------------------------------------------------------------------------- |
| |
| INLINE_FUNCTION 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 |
| //--------------------------------------------------------------------------- |
| |
| INLINE_FUNCTION 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 |
| //--------------------------------------------------------------------------- |
| |
| INLINE_FUNCTION 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); |
| |
| } |
| |
| #endif |
| |
| #if !defined(INLINE_ENABLED) |
| |
| //--------------------------------------------------------------------------- |
| // 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); |
| |
| } |
| |
| |
| #endif // !defined(INLINE_ENABLED) |
| |
| #if (!defined(SHAREDBUFF_INLINED)) || defined(INLINE_ENABLED) |
| |
| //--------------------------------------------------------------------------- |
| // Write data block to Linear Shared Buffer |
| //--------------------------------------------------------------------------- |
| |
| INLINE_FUNCTION 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 |
| //--------------------------------------------------------------------------- |
| |
| INLINE_FUNCTION 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); |
| |
| } |
| |
| #endif |
| |
| |
| #if !defined(INLINE_ENABLED) |
| |
| |
| //--------------------------------------------------------------------------- |
| // 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) |
| { |
| TRACE0(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; |
| |
| } |
| |
| #endif |
| |
| |
| // EOF |
| |
