diff options
Diffstat (limited to 'video_in_hal/nsframework/framework_unified/client/NS_RingBuffer/src/ns_ringbuffer.cpp')
| -rwxr-xr-x | video_in_hal/nsframework/framework_unified/client/NS_RingBuffer/src/ns_ringbuffer.cpp | 1029 |
1 files changed, 0 insertions, 1029 deletions
diff --git a/video_in_hal/nsframework/framework_unified/client/NS_RingBuffer/src/ns_ringbuffer.cpp b/video_in_hal/nsframework/framework_unified/client/NS_RingBuffer/src/ns_ringbuffer.cpp deleted file mode 100755 index 1fbc5b5..0000000 --- a/video_in_hal/nsframework/framework_unified/client/NS_RingBuffer/src/ns_ringbuffer.cpp +++ /dev/null @@ -1,1029 +0,0 @@ -/* - * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -//////////////////////////////////////////////////////////////////////////////////////////////////// -/// \ingroup tag_NSRingBuffer -/// \brief This file contains implementation of class CNSRingBuffer. -/// This class provides API to open, read, write and close ring buffer -/// -//////////////////////////////////////////////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////////////////////////////////////////////// -// Include Files -//////////////////////////////////////////////////////////////////////////////////////////////////// -#include <unistd.h> -#include <sys/mman.h> -#include <sys/stat.h> -#include <fcntl.h> -#include <errno.h> -#include <string.h> -#include <stdlib.h> -#include <stdio.h> -#include <limits.h> - -#include <native_service/ns_ringbuffer.h> -#include <native_service/cl_lock.h> - -#include <string> - -#define RBUF_HEADER_EXT "Hdr" -#define RBUF_RETRY_SLEEP (1000) -#define RBUF_RETRY_COUNT (8) -#define RBUF_PAGE_SIZE (4096) -#define RBUF_PAGE_ALIGN(p) ((p / RBUF_PAGE_SIZE) * RBUF_PAGE_SIZE) - -//////////////////////////////////////////////////////////////////////////////////////////////// -/// CNSRingBuffer -/// Parameterized Constructor of CNSRingBuffer class -//////////////////////////////////////////////////////////////////////////////////////////////// -CNSRingBuffer::CNSRingBuffer(const std::string &f_cMappedFilePath, const UI_32 f_uiSize, int f_lid): - m_cMappedFilePath(f_cMappedFilePath), m_uiRingBuffSize(f_uiSize), m_pRbufMtx(NULL), m_pRbufHdr(NULL), m_pRbuf(NULL), - m_lid(f_lid), m_pLockAddr(NULL), m_siProcessLastWrtPage(-1) { // LCOV_EXCL_BR_LINE 11: except branch - m_cMappedFileHdrPath = f_cMappedFilePath; - m_cMappedFileHdrPath.append(RBUF_HEADER_EXT); // LCOV_EXCL_BR_LINE 11: except branch - - m_cRbufMtxName = f_cMappedFilePath; - std::size_t found = m_cRbufMtxName.find_first_of('/'); - while (found != std::string::npos) { - m_cRbufMtxName[found] = '_'; - found = m_cRbufMtxName.find_first_of('/', found + 1); - } - m_cRbufMtxName[0] = '/'; - pthread_mutex_init(&m_tOpenMutex, NULL); -} - -//////////////////////////////////////////////////////////////////////////////////////////////// -/// CNSRingBuffer -/// Constructor of CNSRingBuffer class -//////////////////////////////////////////////////////////////////////////////////////////////// -CNSRingBuffer::CNSRingBuffer(): - m_cMappedFilePath(""), m_uiRingBuffSize(0), m_pRbufMtx(NULL), m_pRbufHdr(NULL), m_pRbuf(NULL), m_lid(-1), - m_pLockAddr(NULL), m_siProcessLastWrtPage(-1) { - pthread_mutex_init(&m_tOpenMutex, NULL); -} - -//////////////////////////////////////////////////////////////////////////////////////////////// -/// ~CNSRingBuffer -/// Destructor of CNSRingBuffer class -//////////////////////////////////////////////////////////////////////////////////////////////// -CNSRingBuffer::~CNSRingBuffer() { - if (NULL != m_pRbufHdr) { - // un-map the ring buffer object - Close(); - - m_pRbufHdr = NULL; - m_pRbufMtx = NULL; - } - pthread_mutex_destroy(&m_tOpenMutex); -} - -//////////////////////////////////////////////////////////////////////////////////////////////// -/// Open -/// This function opens and maps the ring buffer object. -/// It creates the ring buffer if it does not exists. -//////////////////////////////////////////////////////////////////////////////////////////////// -EFrameworkunifiedStatus CNSRingBuffer::Open() { - EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusErrOther; - - pthread_mutex_lock(&m_tOpenMutex); - - if (NULL == m_pRbufMtx) { - // Open ring buffer mutex - if (eFrameworkunifiedStatusOK != (l_eStatus = MapSM(reinterpret_cast<PVOID *>(&m_pRbufMtx), - m_cRbufMtxName, sizeof(NSRingBufferMtx)))) { - if (ENOENT == errno) { - errno = EOK; - - -// if (eFrameworkunifiedStatusOK == CreateRBMutex()) { - EFrameworkunifiedStatus l_eStatus1 = CreateRBMutex(); - if ((l_eStatus1 == eFrameworkunifiedStatusOK) || (l_eStatus1 == eFrameworkunifiedStatusDuplicate)) { - - l_eStatus = MapSM(reinterpret_cast<PVOID *>(&m_pRbufMtx), m_cRbufMtxName, sizeof(NSRingBufferMtx)); - } - } - } else { - if (m_pRbufMtx->m_lid != m_lid) { - // Different Lock ID in constructor parameter and mutex object - l_eStatus = eFrameworkunifiedStatusInvldParam; - } - } - } - - if (eFrameworkunifiedStatusOK == l_eStatus) { - if (m_lid >= 0 && NULL == m_pLockAddr) { - CL_LockProcessInit(); - if ((m_pLockAddr = CL_LockMap(m_lid)) == MAP_FAILED) { - l_eStatus = eFrameworkunifiedStatusFail; - } - } - } - - if (eFrameworkunifiedStatusOK == l_eStatus) { - if (NULL == m_pRbufHdr) { - // Open header ring buffer - if (eFrameworkunifiedStatusOK != (l_eStatus = Map(reinterpret_cast<PVOID *>(&m_pRbufHdr), - m_cMappedFileHdrPath, sizeof(NSRingBufferHdr)))) { - if (ENOENT == errno) { // ring buffer is not created yet - errno = EOK; - - // Create ring buffer - -// if (eFrameworkunifiedStatusOK == CreateRBHeader()) { - EFrameworkunifiedStatus l_eStatus1 = CreateRBHeader(); - if ((l_eStatus1 == eFrameworkunifiedStatusOK) || (l_eStatus1 == eFrameworkunifiedStatusDuplicate)) { - - // Retry to open - l_eStatus = Map(reinterpret_cast<PVOID *>(&m_pRbufHdr), - m_cMappedFileHdrPath, sizeof(NSRingBufferHdr)); - -// } - } else { - l_eStatus = l_eStatus1; - } - - } - } else { - -#if 0 - LockMtx(); - - struct stat st; - int ret = stat(m_cMappedFilePath.c_str(), &st); - - if (m_uiRingBuffSize == 0) { - if (ret == 0) { // LCOV_EXCL_BR_LINE 5:stat's error case. - // LCOV_EXCL_START 5: stat's error case. - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - if ((UI_32)st.st_size != m_pRbufHdr->m_uiRingBufferSize || (UI_32)st.st_size < m_pRbufHdr->m_uiReadPtr - || (UI_32)st.st_size < m_pRbufHdr->m_uiWritePtr) { - memset(m_pRbufHdr, 0, sizeof(NSRingBufferHdr)); - m_pRbufHdr->m_uiRingBufferSize = static_cast<UI_32>(st.st_size); - unlink(m_cMappedFilePath.c_str()); - } - m_uiRingBuffSize = static_cast<UI_32>(st.st_size); - // LCOV_EXCL_STOP - } - } else { - if (m_uiRingBuffSize != m_pRbufHdr->m_uiRingBufferSize || m_uiRingBuffSize < m_pRbufHdr->m_uiReadPtr - || m_uiRingBuffSize < m_pRbufHdr->m_uiWritePtr || (ret == 0 && m_uiRingBuffSize != (UI_32)st.st_size)) { - memset(m_pRbufHdr, 0, sizeof(NSRingBufferHdr)); - m_pRbufHdr->m_uiRingBufferSize = m_uiRingBuffSize; - unlink(m_cMappedFilePath.c_str()); - } - } - - UnlockMtx(); -#endif - int ret; - if ( (ret = LockMtx()) == 0) { - struct stat st; - int ret = stat(m_cMappedFilePath.c_str(), &st); - - if (m_uiRingBuffSize == 0) { - if (ret == 0) { - if ((UI_32)st.st_size != m_pRbufHdr->m_uiRingBufferSize || (UI_32)st.st_size < m_pRbufHdr->m_uiReadPtr || - (UI_32)st.st_size < m_pRbufHdr->m_uiWritePtr) { - memset(m_pRbufHdr, 0, sizeof(NSRingBufferHdr)); - m_pRbufHdr->m_uiRingBufferSize = static_cast<UI_32>(st.st_size); - unlink(m_cMappedFilePath.c_str()); - } - m_uiRingBuffSize = static_cast<UI_32>(st.st_size); - } - } else { - if (m_uiRingBuffSize != m_pRbufHdr->m_uiRingBufferSize || m_uiRingBuffSize < m_pRbufHdr->m_uiReadPtr || - m_uiRingBuffSize < m_pRbufHdr->m_uiWritePtr || (ret == 0 && m_uiRingBuffSize != (UI_32)st.st_size)) { - memset(m_pRbufHdr, 0, sizeof(NSRingBufferHdr)); - m_pRbufHdr->m_uiRingBufferSize = m_uiRingBuffSize; - unlink(m_cMappedFilePath.c_str()); - } - } - - UnlockMtx(); - } else { - fprintf(stderr, "[%s] LockMtx error: %s\n", __PRETTY_FUNCTION__, strerror(ret)); - munmap(m_pRbufHdr, sizeof(NSRingBufferHdr)); - m_pRbufHdr = NULL; - l_eStatus = eFrameworkunifiedStatusFail; - } - - } - } - } - - if (eFrameworkunifiedStatusOK == l_eStatus && 0 != m_uiRingBuffSize) { - if (NULL == m_pRbuf) { - // Open ring buffer data buffer, create if not exists - if (eFrameworkunifiedStatusOK != (l_eStatus = Map(reinterpret_cast<PVOID *>(&m_pRbuf), - m_cMappedFilePath, m_uiRingBuffSize))) { - if (ENOENT == errno) { // ring buffer is not created yet - // Create ring buffer - -// if (eFrameworkunifiedStatusOK == CreateRBDataBuffer()) { - EFrameworkunifiedStatus l_eStatus1 = CreateRBDataBuffer(); - if ((l_eStatus1 == eFrameworkunifiedStatusOK) || (l_eStatus1 == eFrameworkunifiedStatusDuplicate)) { - - // Retry to open - l_eStatus = Map(reinterpret_cast<PVOID *>(&m_pRbuf), - m_cMappedFilePath, m_uiRingBuffSize); - } - } - } - } - } - - pthread_mutex_unlock(&m_tOpenMutex); - - return l_eStatus; -} - -//////////////////////////////////////////////////////////////////////////////////////////////// -/// IsOpen -/// This function is used to check whether the ring buffer is opened or not. -//////////////////////////////////////////////////////////////////////////////////////////////// -BOOL CNSRingBuffer::IsOpen() { - return NULL == m_pRbufHdr ? FALSE : TRUE; -} - -//////////////////////////////////////////////////////////////////////////////////////////////// -/// Close -/// This function closes the ring buffer object. -//////////////////////////////////////////////////////////////////////////////////////////////// -EFrameworkunifiedStatus CNSRingBuffer::Close() { - if (NULL != m_pLockAddr) { - CL_LockUnmap(m_pLockAddr); - } - - EFrameworkunifiedStatus l_eStatus1 = UnMap(m_pRbufHdr, sizeof(NSRingBufferHdr)); - m_pRbufHdr = NULL; - - EFrameworkunifiedStatus l_eStatus2 = eFrameworkunifiedStatusOK; - if (0 != m_uiRingBuffSize) { - l_eStatus2 = UnMap(m_pRbuf, m_uiRingBuffSize); - m_pRbuf = NULL; - } - - EFrameworkunifiedStatus l_eStatus3 = UnMap(m_pRbufMtx, sizeof(NSRingBufferMtx)); - m_pRbufMtx = NULL; - - return (eFrameworkunifiedStatusOK != l_eStatus1 || eFrameworkunifiedStatusOK != l_eStatus2 || - eFrameworkunifiedStatusOK != l_eStatus3) ? eFrameworkunifiedStatusFail : eFrameworkunifiedStatusOK; -} - -//////////////////////////////////////////////////////////////////////////////////////////////// -/// Read -/// This function reads data from the ring buffer. -//////////////////////////////////////////////////////////////////////////////////////////////// -SI_32 CNSRingBuffer::Read(PSTR f_pBuffer, const UI_32 f_uilength) { - SI_32 l_iReadSize = -1; - - if ((NULL != f_pBuffer) && (NULL != m_pRbufHdr) && (0 != f_uilength)) { - UI_32 l_uiDataSizeToRead = 0; - - // Remaining buffer size from read pointer to end of the buffer - UI_32 l_uiRemainSize = 0; - - -#if 0 - LockMtx(); - - // if ring buffer size is changed by some other process, remap the updated buffer size in this process - // ring buffer size can only be changed if the initial size is 0. - if (m_uiRingBuffSize != m_pRbufHdr->m_uiRingBufferSize) { - if (eFrameworkunifiedStatusOK == Map(reinterpret_cast<PVOID *>(&m_pRbuf), - m_cMappedFilePath, m_pRbufHdr->m_uiRingBufferSize)) { - m_uiRingBuffSize = m_pRbufHdr->m_uiRingBufferSize; - } - } - - if (NULL != m_pRbuf) { - l_uiRemainSize = m_uiRingBuffSize - m_pRbufHdr->m_uiReadPtr; - - // Round read data size depending on un-read data size in the buffer - l_uiDataSizeToRead = m_pRbufHdr->m_uiUnReadSize < f_uilength ? m_pRbufHdr->m_uiUnReadSize : f_uilength; - - if (l_uiRemainSize < l_uiDataSizeToRead) { - // Wrapping read - memcpy(f_pBuffer, m_pRbuf + m_pRbufHdr->m_uiReadPtr, l_uiRemainSize); - memcpy(f_pBuffer + l_uiRemainSize, m_pRbuf, l_uiDataSizeToRead - l_uiRemainSize); - m_pRbufHdr->m_uiReadPtr = l_uiDataSizeToRead - l_uiRemainSize; - } else { - memcpy(f_pBuffer, m_pRbuf + m_pRbufHdr->m_uiReadPtr, l_uiDataSizeToRead); - - m_pRbufHdr->m_uiReadPtr += l_uiDataSizeToRead; - - // Read pointer is the end of the buffer - if (m_pRbufHdr->m_uiReadPtr == m_uiRingBuffSize) { - m_pRbufHdr->m_uiReadPtr = 0; - } - } - - m_pRbufHdr->m_uiUnReadSize -= l_uiDataSizeToRead; // Update un-read data size - - l_iReadSize = l_uiDataSizeToRead; - } - - UnlockMtx(); -#endif - int ret; - if ( (ret = LockMtx()) == 0) { - // if ring buffer size is changed by some other process, remap the updated buffer size in this process - // ring buffer size can only be changed if the initial size is 0. - if (m_uiRingBuffSize != m_pRbufHdr->m_uiRingBufferSize) { - if (eFrameworkunifiedStatusOK == Map(reinterpret_cast<PVOID *>(&m_pRbuf), - m_cMappedFilePath, m_pRbufHdr->m_uiRingBufferSize)) { - m_uiRingBuffSize = m_pRbufHdr->m_uiRingBufferSize; - } - } - - if (NULL != m_pRbuf) { - l_uiRemainSize = m_uiRingBuffSize - m_pRbufHdr->m_uiReadPtr; - - // Round read data size depending on un-read data size in the buffer - l_uiDataSizeToRead = m_pRbufHdr->m_uiUnReadSize < f_uilength ? m_pRbufHdr->m_uiUnReadSize : f_uilength; - - if (l_uiRemainSize < l_uiDataSizeToRead) { - // Wrapping read - memcpy(f_pBuffer, m_pRbuf + m_pRbufHdr->m_uiReadPtr, l_uiRemainSize); - memcpy(f_pBuffer + l_uiRemainSize, m_pRbuf, l_uiDataSizeToRead - l_uiRemainSize); - m_pRbufHdr->m_uiReadPtr = l_uiDataSizeToRead - l_uiRemainSize; - } else { - memcpy(f_pBuffer, m_pRbuf + m_pRbufHdr->m_uiReadPtr, l_uiDataSizeToRead); - - m_pRbufHdr->m_uiReadPtr += l_uiDataSizeToRead; - - // Read pointer is the end of the buffer - if (m_pRbufHdr->m_uiReadPtr == m_uiRingBuffSize) { - m_pRbufHdr->m_uiReadPtr = 0; - } - } - - m_pRbufHdr->m_uiUnReadSize -= l_uiDataSizeToRead; // Update un-read data size - - l_iReadSize = l_uiDataSizeToRead; - } - - UnlockMtx(); - } else { - fprintf(stderr, "[%s] LockMtx error: %s\n", __PRETTY_FUNCTION__, strerror(ret)); - l_iReadSize = 0; - } - - } - - return l_iReadSize; -} - -//////////////////////////////////////////////////////////////////////////////////////////////// -/// Write -/// This function writes the data into the ring buffer. -//////////////////////////////////////////////////////////////////////////////////////////////// -SI_32 CNSRingBuffer::Write(PCSTR f_pBuffer, const UI_32 f_uilength) { - SI_32 l_iWriteSize = -1; - - // size available in buffer - UI_32 l_uiRemainSize = 0; - - if (NULL != m_pRbufHdr && NULL != m_pRbuf && NULL != f_pBuffer && f_uilength <= m_uiRingBuffSize) { // LCOV_EXCL_BR_LINE 11:except branch -#if 0 - LockMtx(); - - UI_32 l_uiLastPage = RBUF_PAGE_ALIGN(m_pRbufHdr->m_uiWritePtr); - l_uiRemainSize = m_uiRingBuffSize - m_pRbufHdr->m_uiWritePtr; - - if (m_siProcessLastWrtPage >= 0) { - if ((UI_32)m_siProcessLastWrtPage != l_uiLastPage) { - if (madvise(m_pRbuf + m_siProcessLastWrtPage, RBUF_PAGE_SIZE, MADV_DONTNEED) < 0) { - fprintf(stderr, "[CNSRingBuffer::Write] madvise(%p) error: %s\n", - m_pRbuf + m_siProcessLastWrtPage, strerror(errno)); - } - } - } - - // Write data to the buffer - if (l_uiRemainSize < f_uilength) { - // Wrapping write - memcpy(m_pRbuf + m_pRbufHdr->m_uiWritePtr, f_pBuffer, l_uiRemainSize); - memcpy(m_pRbuf, f_pBuffer + l_uiRemainSize, f_uilength - l_uiRemainSize); - - // Update the write pointer - m_pRbufHdr->m_uiWritePtr = f_uilength - l_uiRemainSize; - - // The buffer is full of valid data - m_pRbufHdr->m_bIsFull = TRUE; - } else { - memcpy(m_pRbuf + m_pRbufHdr->m_uiWritePtr, f_pBuffer, f_uilength); - - // Update the write pointer - m_pRbufHdr->m_uiWritePtr += f_uilength; - - // Write pointer is the end of the buffer - if (m_pRbufHdr->m_uiWritePtr == m_uiRingBuffSize) { - m_pRbufHdr->m_uiWritePtr = 0; - - // The buffer is full of valid data - m_pRbufHdr->m_bIsFull = TRUE; - } - } - - // Update un-read data size - m_pRbufHdr->m_uiUnReadSize += f_uilength; - - // Set read pointer to be same as write pointer if write pointer exceeds the read pointer - if (m_uiRingBuffSize < m_pRbufHdr->m_uiUnReadSize) { - m_pRbufHdr->m_uiReadPtr = m_pRbufHdr->m_uiWritePtr; - m_pRbufHdr->m_uiUnReadSize = m_uiRingBuffSize; - } - - while (l_uiLastPage != RBUF_PAGE_ALIGN(m_pRbufHdr->m_uiWritePtr)) { - if (madvise(m_pRbuf + l_uiLastPage, RBUF_PAGE_SIZE, MADV_DONTNEED) < 0) { - fprintf(stderr, "[CNSRingBuffer::Write] madvise(%p) error: %s\n", m_pRbuf + l_uiLastPage, strerror(errno)); - } - l_uiLastPage += RBUF_PAGE_SIZE; - if (l_uiLastPage >= m_uiRingBuffSize) { - l_uiLastPage = 0; - } - } - m_siProcessLastWrtPage = (SI_32)l_uiLastPage; - - UnlockMtx(); - - l_iWriteSize = f_uilength; -#endif - int ret; - if ( (ret = LockMtx()) == 0) { - UI_32 l_uiLastPage = RBUF_PAGE_ALIGN(m_pRbufHdr->m_uiWritePtr); - l_uiRemainSize = m_uiRingBuffSize - m_pRbufHdr->m_uiWritePtr; - - if (m_siProcessLastWrtPage >= 0) { - if ((UI_32)m_siProcessLastWrtPage != l_uiLastPage) { - if (madvise(m_pRbuf + m_siProcessLastWrtPage, RBUF_PAGE_SIZE, MADV_DONTNEED) < 0) { - fprintf(stderr, "[CNSRingBuffer::Write] madvise(%p) error: %s\n", - m_pRbuf + m_siProcessLastWrtPage, strerror(errno)); - } - } - } - - // Write data to the buffer - if (l_uiRemainSize < f_uilength) { - // Wrapping write - memcpy(m_pRbuf + m_pRbufHdr->m_uiWritePtr, f_pBuffer, l_uiRemainSize); - memcpy(m_pRbuf, f_pBuffer + l_uiRemainSize, f_uilength - l_uiRemainSize); - - // Update the write pointer - m_pRbufHdr->m_uiWritePtr = f_uilength - l_uiRemainSize; - - // The buffer is full of valid data - m_pRbufHdr->m_bIsFull = TRUE; - } else { - memcpy(m_pRbuf + m_pRbufHdr->m_uiWritePtr, f_pBuffer, f_uilength); - - // Update the write pointer - m_pRbufHdr->m_uiWritePtr += f_uilength; - - // Write pointer is the end of the buffer - if (m_pRbufHdr->m_uiWritePtr == m_uiRingBuffSize) { - m_pRbufHdr->m_uiWritePtr = 0; - - // The buffer is full of valid data - m_pRbufHdr->m_bIsFull = TRUE; - } - } - - // Update un-read data size - m_pRbufHdr->m_uiUnReadSize += f_uilength; - - // Set read pointer to be same as write pointer if write pointer exceeds the read pointer - if (m_uiRingBuffSize < m_pRbufHdr->m_uiUnReadSize) { - m_pRbufHdr->m_uiReadPtr = m_pRbufHdr->m_uiWritePtr; - m_pRbufHdr->m_uiUnReadSize = m_uiRingBuffSize; - } - - while (l_uiLastPage != RBUF_PAGE_ALIGN(m_pRbufHdr->m_uiWritePtr)) { - if (madvise(m_pRbuf + l_uiLastPage, RBUF_PAGE_SIZE, MADV_DONTNEED) < 0) { - fprintf(stderr, "[CNSRingBuffer::Write] madvise(%p) error: %s\n", - m_pRbuf + l_uiLastPage, strerror(errno)); - } - l_uiLastPage += RBUF_PAGE_SIZE; - if (l_uiLastPage >= m_uiRingBuffSize) { - l_uiLastPage = 0; - } - } - m_siProcessLastWrtPage = (SI_32)l_uiLastPage; - - UnlockMtx(); - - l_iWriteSize = f_uilength; - } else { - fprintf(stderr, "[%s] LockMtx error: %s\n", __PRETTY_FUNCTION__, strerror(ret)); - l_iWriteSize = 0; - } - - } - - return l_iWriteSize; -} - -//////////////////////////////////////////////////////////////////////////////////////////////// -/// DumpToFile -/// This function writes all the data in the buffer into provided file f_pPath. -//////////////////////////////////////////////////////////////////////////////////////////////// -EFrameworkunifiedStatus CNSRingBuffer::DumpToFile(PCSTR f_pPath, PUI_32 f_uiDumpSize) { - EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; - - ssize_t l_iSize = 0; - - SI_32 fd = -1; - - if (NULL == f_uiDumpSize) { - return eFrameworkunifiedStatusNullPointer; - } - *f_uiDumpSize = 0; - - if (NULL != f_pPath) { - if (NULL != m_pRbufHdr) { - // Open file - if (-1 != (fd = open(f_pPath, O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0640))) { - if (NULL != m_pRbuf && 0 != m_uiRingBuffSize) { - -#if 0 - LockMtx(); - // Write buffer data to file - if (m_pRbufHdr->m_bIsFull) { - // Buffer has full of data (read data from write pointer) - if (-1 != (l_iSize = write(fd, m_pRbuf + m_pRbufHdr->m_uiWritePtr, - m_uiRingBuffSize - m_pRbufHdr->m_uiWritePtr))) { - *f_uiDumpSize += static_cast<UI_32>(l_iSize); - } else { - l_eStatus = eFrameworkunifiedStatusErrOther; - } - } - - if (-1 != (l_iSize = write(fd, m_pRbuf, m_pRbufHdr->m_uiWritePtr))) { - *f_uiDumpSize += static_cast<UI_32>(l_iSize); - } - - UnlockMtx(); -#endif - int ret; - if ( (ret = LockMtx()) == 0) { - // Write buffer data to file - if (m_pRbufHdr->m_bIsFull) { - // Buffer has full of data (read data from write pointer) - if (-1 != (l_iSize = write(fd, m_pRbuf + m_pRbufHdr->m_uiWritePtr, - m_uiRingBuffSize - m_pRbufHdr->m_uiWritePtr))) { - -// *f_uiDumpSize += l_iSize; - *f_uiDumpSize += static_cast<UI_32>(l_iSize); - } else { - l_eStatus = eFrameworkunifiedStatusErrOther; - } - } - - if (-1 != (l_iSize = write(fd, m_pRbuf, m_pRbufHdr->m_uiWritePtr))) { - -// *f_uiDumpSize += l_iSize; - *f_uiDumpSize += static_cast<UI_32>(l_iSize); - } - - UnlockMtx(); - } else { - fprintf(stderr, "[%s] LockMtx error: %s\n", __PRETTY_FUNCTION__, strerror(ret)); - } - - } else if (NULL == m_pRbuf && 0 != m_uiRingBuffSize) { - l_eStatus = eFrameworkunifiedStatusFail; - } else { - // do nothing - } - - // Sync the file to force I/O operation completed - fsync(fd); - - close(fd); - } else { - l_eStatus = eFrameworkunifiedStatusFileLoadError; - } - } else { - l_eStatus = eFrameworkunifiedStatusFail; - } - } else { - l_eStatus = eFrameworkunifiedStatusInvldParam; - } - - return l_eStatus; -} - -//////////////////////////////////////////////////////////////////////////////////////////////// -/// GetSize -/// This function returns the number of unread bytes which can be read by Read(). -//////////////////////////////////////////////////////////////////////////////////////////////// -SI_32 CNSRingBuffer::GetSize() { - SI_32 l_uiReadSize = -1; - - if (NULL != m_pRbufHdr) { - l_uiReadSize = m_pRbufHdr->m_uiUnReadSize; - } - - return l_uiReadSize; -} - -//////////////////////////////////////////////////////////////////////////////////////////////// -/// ClearBuf -/// This function clears the buffer. -//////////////////////////////////////////////////////////////////////////////////////////////// -EFrameworkunifiedStatus CNSRingBuffer::ClearBuf() { - EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; - - if (NULL != m_pRbufHdr) { - -#if 0 - LockMtx(); - - // Initialize the r/w pointers - m_pRbufHdr->m_uiReadPtr = 0; - m_pRbufHdr->m_uiWritePtr = 0; - m_pRbufHdr->m_uiUnReadSize = 0; - m_pRbufHdr->m_bIsFull = FALSE; - - UnlockMtx(); -#endif - int ret; - if ((ret = LockMtx()) == 0) { - // Initialize the r/w pointers - m_pRbufHdr->m_uiReadPtr = 0; - m_pRbufHdr->m_uiWritePtr = 0; - m_pRbufHdr->m_uiUnReadSize = 0; - m_pRbufHdr->m_bIsFull = FALSE; - - UnlockMtx(); - } else { - fprintf(stderr, "[%s] LockMtx error: %s\n", __PRETTY_FUNCTION__, strerror(ret)); - } - - } else { - l_eStatus = eFrameworkunifiedStatusFail; - } - - return l_eStatus; -} - -//////////////////////////////////////////////////////////////////////////////////////////////// -/// SetReadPtrToWritePtr -/// This function sets the position of read ptr to write ptr in buffer. -//////////////////////////////////////////////////////////////////////////////////////////////// -EFrameworkunifiedStatus CNSRingBuffer::SetReadPtrToWritePtr() { - EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; - - if (NULL != m_pRbufHdr) { - -#if 0 - LockMtx(); - - // Initialize the r/w pointers - m_pRbufHdr->m_uiReadPtr = m_pRbufHdr->m_uiWritePtr; - m_pRbufHdr->m_uiUnReadSize = 0; - - UnlockMtx(); -#endif - int ret; - if ( (ret = LockMtx()) == 0) { - // Initialize the r/w pointers - m_pRbufHdr->m_uiReadPtr = m_pRbufHdr->m_uiWritePtr; - m_pRbufHdr->m_uiUnReadSize = 0; - - UnlockMtx(); - } else { - fprintf(stderr, "[%s] LockMtx error: %s\n", __PRETTY_FUNCTION__, strerror(ret)); - } - - } else { - l_eStatus = eFrameworkunifiedStatusFail; - } - - return l_eStatus; -} -// -//////////////////////////////////////////////////////////////////////////////////////////////// -/// CreateRBMutex -/// This function creates the shared memory object for mutex. -//////////////////////////////////////////////////////////////////////////////////////////////// -EFrameworkunifiedStatus CNSRingBuffer::CreateRBMutex() { - EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail; - - // file descriptor of shared memory - SI_32 l_siId = -1; - - // ring buffer mutex - NSRingBufferMtx *l_pRbufMtx = NULL; - - if ((!m_cRbufMtxName.empty()) || (m_cRbufMtxName.size() <= NAME_MAX)) { - // Try to create shared memory - l_siId = shm_open(m_cRbufMtxName.c_str(), O_CREAT | O_EXCL | O_RDWR, 0640); - - if (-1 != l_siId) { - // Set the size of shared memory - if (-1 != ftruncate(l_siId, sizeof(NSRingBufferMtx))) { - // Map the shared memory - l_pRbufMtx = reinterpret_cast<NSRingBufferMtx *>(mmap(NULL, - sizeof(NSRingBufferMtx), (PROT_READ | PROT_WRITE), MAP_SHARED, l_siId, 0)); - - if (MAP_FAILED != l_pRbufMtx) { - if (m_lid == -1) { - // mutex attribute - pthread_mutexattr_t l_tMtxAttr = {}; - - // Initialize mutex - pthread_mutexattr_init(&l_tMtxAttr); - pthread_mutexattr_setpshared(&l_tMtxAttr, PTHREAD_PROCESS_SHARED); - pthread_mutex_init(&l_pRbufMtx->m_tBufMutex, &l_tMtxAttr); - pthread_mutexattr_destroy(&l_tMtxAttr); - - l_eStatus = eFrameworkunifiedStatusOK; - } else { - // CL_Lock - l_eStatus = eFrameworkunifiedStatusOK; - } - l_pRbufMtx->m_lid = m_lid; - - // Once initialized un-map the shared memory - munmap(l_pRbufMtx, sizeof(NSRingBufferMtx)); - } - } - - close(l_siId); - } else if (EEXIST == errno) { - // Shared memory is already created - l_eStatus = eFrameworkunifiedStatusDuplicate; - } else { - // do nothing - } - } else { - l_eStatus = eFrameworkunifiedStatusInvldParam; - } - - return l_eStatus; -} - -//////////////////////////////////////////////////////////////////////////////////////////////// -/// CreateRBHeader -/// This function creates the ring buffer object for header. -//////////////////////////////////////////////////////////////////////////////////////////////// -EFrameworkunifiedStatus CNSRingBuffer::CreateRBHeader() { - EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail; - - // file descriptor of ring buffer - SI_32 l_siFd = -1; - - // ring buffer headers - NSRingBufferHdr *l_pRbufHdr = NULL; - - if (!m_cMappedFileHdrPath.empty()) { // LCOV_EXCL_BR_LINE 11: except branch - // Try to create ring buffer - l_siFd = open(m_cMappedFileHdrPath.c_str(), O_CREAT | O_EXCL | O_RDWR | O_CLOEXEC, 0640); - - if (-1 != l_siFd) { - // Set the size of ring buffer - if (-1 != ftruncate(l_siFd, sizeof(NSRingBufferHdr))) { - // Map the ring buffer - l_pRbufHdr = reinterpret_cast<NSRingBufferHdr *>(mmap(NULL, - sizeof(NSRingBufferHdr), (PROT_READ | PROT_WRITE), MAP_SHARED, l_siFd, 0)); - - if (MAP_FAILED != l_pRbufHdr) { - -#if 0 - LockMtx(); - - // Initialize the r/w pointers - l_pRbufHdr->m_uiReadPtr = 0; - l_pRbufHdr->m_uiWritePtr = 0; - l_pRbufHdr->m_uiUnReadSize = 0; - l_pRbufHdr->m_bIsFull = FALSE; - l_pRbufHdr->m_uiRingBufferSize = m_uiRingBuffSize; - - UnlockMtx(); -#endif - int ret; - if ( (ret = LockMtx()) == 0) { - // Initialize the r/w pointers - l_pRbufHdr->m_uiReadPtr = 0; - l_pRbufHdr->m_uiWritePtr = 0; - l_pRbufHdr->m_uiUnReadSize = 0; - l_pRbufHdr->m_bIsFull = FALSE; - l_pRbufHdr->m_uiRingBufferSize = m_uiRingBuffSize; - - UnlockMtx(); - l_eStatus = eFrameworkunifiedStatusOK; - } else { - fprintf(stderr, "[%s] LockMtx error: %s\n", __PRETTY_FUNCTION__, strerror(ret)); - l_eStatus = eFrameworkunifiedStatusFail; - } - - - // Once initialized un-map the ring buffer - munmap(l_pRbufHdr, sizeof(NSRingBufferHdr)); - } - } - - close(l_siFd); - } else if (EEXIST == errno) { - // ring buffer is already created - l_eStatus = eFrameworkunifiedStatusDuplicate; - } else { - // do nothing - } - } else { - l_eStatus = eFrameworkunifiedStatusInvldParam; - } - - return l_eStatus; -} - -//////////////////////////////////////////////////////////////////////////////////////////////// -/// CreateRBDataBuffer -/// This function creates the ring buffer object for data buffer. -//////////////////////////////////////////////////////////////////////////////////////////////// -EFrameworkunifiedStatus CNSRingBuffer::CreateRBDataBuffer() { - EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail; - - // file descriptor of ring buffer - SI_32 l_siFd = -1; - - if (!m_cMappedFilePath.empty()) { - // Try to create ring buffer - l_siFd = open(m_cMappedFilePath.c_str(), O_CREAT | O_EXCL | O_RDWR | O_CLOEXEC, 0640); - - if (-1 != l_siFd) { - // Set the size of ring buffer - if (-1 != ftruncate(l_siFd, m_uiRingBuffSize)) { - l_eStatus = eFrameworkunifiedStatusOK; - } - - close(l_siFd); - } else if (EEXIST == errno) { - // ring buffer is already created - l_eStatus = eFrameworkunifiedStatusDuplicate; - } else { - // do nothing - } - } else { - l_eStatus = eFrameworkunifiedStatusInvldParam; - } - - return l_eStatus; -} - -//////////////////////////////////////////////////////////////////////////////////////////////// -/// MapRBHeader -/// This function open and maps in process space. -//////////////////////////////////////////////////////////////////////////////////////////////// -EFrameworkunifiedStatus CNSRingBuffer::Map(PVOID *f_pRbuf, const std::string &f_cMappedFile, const UI_32 f_uiRbufSize) { - EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail; - - // file descriptor of ring buffer - SI_32 l_siFd = -1; - - // ring buffer headers - PVOID l_pRbuf = NULL; - - // Open ring buffer - l_siFd = open(f_cMappedFile.c_str(), O_RDWR | O_CLOEXEC, NULL); - - if (-1 != l_siFd) { - if (CheckSize(l_siFd, f_uiRbufSize) == eFrameworkunifiedStatusOK) { - // Map the ring buffer into its memory space - l_pRbuf = mmap(NULL, f_uiRbufSize, (PROT_READ | PROT_WRITE), MAP_SHARED, l_siFd, 0); - - if (MAP_FAILED != l_pRbuf) { - *f_pRbuf = l_pRbuf; - l_eStatus = eFrameworkunifiedStatusOK; - } - } - - close(l_siFd); - } - - return l_eStatus; -} - -//////////////////////////////////////////////////////////////////////////////////////////////// -/// CheckSize -/// This function check mmap size -//////////////////////////////////////////////////////////////////////////////////////////////// -EFrameworkunifiedStatus CNSRingBuffer::CheckSize(int fd, off_t size) { - EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail; - struct stat st; - int i; - - for (i = 0; i < RBUF_RETRY_COUNT; i++) { - if (fstat(fd, &st) < 0) { - fprintf(stderr, "[CNSRingBuffer::CheckSize] fstat error: %s\n", strerror(errno)); - goto out; - } - if (st.st_size == size) { - l_eStatus = eFrameworkunifiedStatusOK; - break; - } - usleep(RBUF_RETRY_SLEEP); - } - if (i >= RBUF_RETRY_COUNT) { - errno = ENOMEM; - } - -out: - return l_eStatus; -} - -//////////////////////////////////////////////////////////////////////////////////////////////// -/// MapSM -/// This function shm_open and maps the shared memory in process space. -//////////////////////////////////////////////////////////////////////////////////////////////// -EFrameworkunifiedStatus CNSRingBuffer::MapSM(PVOID *f_pShMem, const std::string &f_cShmName, const UI_32 f_uiShmSize) { - EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail; - - // file descriptor of shared memory - SI_32 l_siId = -1; - - // shared memory buffer headers - PVOID l_pShmBuf = NULL; - - // Open shared memory - l_siId = shm_open(f_cShmName.c_str(), O_RDWR, 0640); - - if (-1 != l_siId) { - if (CheckSize(l_siId, f_uiShmSize) == eFrameworkunifiedStatusOK) { - // Map the shared memory into its memory space - l_pShmBuf = mmap(NULL, f_uiShmSize, (PROT_READ | PROT_WRITE), MAP_SHARED, l_siId, 0); - - if (MAP_FAILED != l_pShmBuf) { - *f_pShMem = l_pShmBuf; - l_eStatus = eFrameworkunifiedStatusOK; - } - } - - close(l_siId); - } - - return l_eStatus; -} - -//////////////////////////////////////////////////////////////////////////////////////////////// -/// UnMap -/// This function unmaps object. -//////////////////////////////////////////////////////////////////////////////////////////////// -EFrameworkunifiedStatus CNSRingBuffer::UnMap(PVOID f_pRbuf, const UI_32 f_uiRbufSize) { - EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; - - // Un-map the ring buffer - if (NULL != f_pRbuf) { - if (0 != munmap(f_pRbuf, f_uiRbufSize)) { - l_eStatus = eFrameworkunifiedStatusFail; - } - } else { - l_eStatus = eFrameworkunifiedStatusNullPointer; - } - - return l_eStatus; -} - - -//void CNSRingBuffer::LockMtx() { -// if (m_lid == -1) { -// pthread_mutex_lock(&m_pRbufMtx->m_tBufMutex); -// } else { -// CL_LockGet(m_pLockAddr); -// } -//} -int CNSRingBuffer::LockMtx() { - int ret = 0; - - if (m_lid == -1) { - ret = pthread_mutex_lock(&m_pRbufMtx->m_tBufMutex); - } else { - ret = CL_LockGet(m_pLockAddr); - } - - return ret; -} - - -void CNSRingBuffer::UnlockMtx() { - if (m_lid == -1) { - pthread_mutex_unlock(&m_pRbufMtx->m_tBufMutex); - } else { - CL_LockRelease(m_pLockAddr); - } -} |