/* * @copyright Copyright (c) 2016-2019 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. */ /** * @file * _pbMutex.cpp */ /*---------------------------------------------------------------------------------* * Include Files * *---------------------------------------------------------------------------------*/ #ifndef PT_PB_MUTEX_STUB__CWORD71_ #include #include "_pbInternalProc.h" #include #include #include "WPF_STD_private.h" #include "tchar.h" /*---------------------------------------------------------------------------------* * Define * *---------------------------------------------------------------------------------*/ /* Mutex control table name (Shared Memory) */ #define MUTEX_CTRL_TBL_NAME __TEXT("POS_BASE_MUTEX_TABLE") /* Max. available Lock ID Note : Lock ID application is 1 (for BaseAPI initialization) + 1 (for Mutex function control) + 30 (for provision) = 32 */ #define MAX_CTRL_MUTEX_NUM (30) #define FULL_CTRL_MUTEX_NUM (MAX_CTRL_MUTEX_NUM - 4) /** Mutex control data threshold (no free) */ #define WARN_CTRL_MUTEX_NUM (MAX_CTRL_MUTEX_NUM - 10) /** Mutex control data threshold (warning) */ /* ID needs to be aplicated If you increase or decrease the IDs, define maximum number of managed LOCK IDs and the default setting of "Lock ID Resource List" must also be changed. */ #define MUTEX_LOCK_ID_0 LOCK_POS_MTX_2 /* Mutex management-information-exclusive control */ #define MUTEX_LOCK_ID_1 LOCK_POS_MTX_3 #define MUTEX_LOCK_ID_2 LOCK_POS_MTX_4 #define MUTEX_LOCK_ID_3 LOCK_POS_MTX_5 #define MUTEX_LOCK_ID_4 LOCK_POS_MTX_6 #define MUTEX_LOCK_ID_5 LOCK_POS_MTX_7 #define MUTEX_LOCK_ID_6 LOCK_POS_MTX_8 #define MUTEX_LOCK_ID_7 LOCK_POS_MTX_9 #define MUTEX_LOCK_ID_8 LOCK_POS_MTX_10 #define MUTEX_LOCK_ID_9 LOCK_POS_MTX_11 #define MUTEX_LOCK_ID_10 LOCK_POS_MTX_12 #define MUTEX_LOCK_ID_11 LOCK_POS_MTX_13 #define MUTEX_LOCK_ID_12 LOCK_POS_MTX_14 #define MUTEX_LOCK_ID_13 LOCK_POS_MTX_15 #define MUTEX_LOCK_ID_14 LOCK_POS_MTX_16 #define MUTEX_LOCK_ID_15 LOCK_POS_MTX_17 #define MUTEX_LOCK_ID_16 LOCK_POS_MTX_18 #define MUTEX_LOCK_ID_17 LOCK_POS_MTX_19 #define MUTEX_LOCK_ID_18 LOCK_POS_MTX_20 #define MUTEX_LOCK_ID_19 LOCK_POS_MTX_21 #define MUTEX_LOCK_ID_20 LOCK_POS_MTX_22 #define MUTEX_LOCK_ID_21 LOCK_POS_MTX_23 #define MUTEX_LOCK_ID_22 LOCK_POS_MTX_24 #define MUTEX_LOCK_ID_23 LOCK_POS_MTX_25 #define MUTEX_LOCK_ID_24 LOCK_POS_MTX_26 #define MUTEX_LOCK_ID_25 LOCK_POS_MTX_27 #define MUTEX_LOCK_ID_26 LOCK_POS_MTX_28 #define MUTEX_LOCK_ID_27 LOCK_POS_MTX_29 #define MUTEX_LOCK_ID_28 LOCK_POS_MTX_30 #define MUTEX_LOCK_ID_29 LOCK_POS_MTX_31 #define MUTEX_LOCK_ID_30 LOCK_POS_MTX_32 typedef int32 LOCK_ID; /*---------------------------------------------------------------------------------* * Structure * *---------------------------------------------------------------------------------*/ /*! @brief Mutex control information(Interprocess common-details) */ typedef struct { LOCK_ID lock_id; /**< Lock ID */ TCHAR name[NAME_MAX]; /**< Mutex Name */ int32 ref_cnt; /**< Reference Counter */ uint32_t thread_id; /**< Thread IDs while Lock is being acquired (Initial value:0) Note: For debugging */ BOOL is_rel_fail; /**< Release failure information (Failed:TRUE) Note: For debugging */ BOOL is_forbid_access; /**< Deletion occurred during Lock acquisition (Deletion occurred:TRUE) Note: For debugging */ } MUTEX_CTRL_SHARED_DETAIL; /*! @brief Mutex control information (Interprocess common) */ typedef struct { MUTEX_CTRL_SHARED_DETAIL detail[MAX_CTRL_MUTEX_NUM]; /**< Common Infomation */ uint32_t use_cnt; /**< Use Counter */ uint32_t rsv_cnt; /**< Reserve Counter */ } MUTEX_CTRL_SHARED_INFO; /*! @brief Mutex control information */ typedef struct { HANDLE handle[MAX_CTRL_MUTEX_NUM]; /**< Mutex Handle */ int32 ref_cnt[MAX_CTRL_MUTEX_NUM]; /**< Reference Counter */ MUTEX_CTRL_SHARED_INFO* info; /**< Common Infomation */ } MUTEX_CTRL_INFO; /*---------------------------------------------------------------------------------* * Grobal Value * *---------------------------------------------------------------------------------*/ /** Mutex control table pointer (Partial shared memory) Note: Access to this instance shall be made through the operation module. */ static MUTEX_CTRL_INFO g_mutex_ctrl_tbl; // NOLINT(readability/nolint) global class instance static HANDLE g_h_mtx; /** Mutex control-information-locking Mutex handle */ static HANDLE g_h_shm; /** Shared memory handle */ // Coverity CID: 18788 compliant /** Lock ID Resource List */ static const LOCK_ID kLockIdList[MAX_CTRL_MUTEX_NUM] = { MUTEX_LOCK_ID_1, MUTEX_LOCK_ID_2, MUTEX_LOCK_ID_3, MUTEX_LOCK_ID_4, MUTEX_LOCK_ID_5, MUTEX_LOCK_ID_6, MUTEX_LOCK_ID_7, MUTEX_LOCK_ID_8, MUTEX_LOCK_ID_9, MUTEX_LOCK_ID_10, MUTEX_LOCK_ID_11, MUTEX_LOCK_ID_12, MUTEX_LOCK_ID_13, MUTEX_LOCK_ID_14, MUTEX_LOCK_ID_15, MUTEX_LOCK_ID_16, MUTEX_LOCK_ID_17, MUTEX_LOCK_ID_18, MUTEX_LOCK_ID_19, MUTEX_LOCK_ID_20, MUTEX_LOCK_ID_21, MUTEX_LOCK_ID_22, MUTEX_LOCK_ID_23, MUTEX_LOCK_ID_24, MUTEX_LOCK_ID_25, MUTEX_LOCK_ID_26, MUTEX_LOCK_ID_27, MUTEX_LOCK_ID_28, MUTEX_LOCK_ID_29, MUTEX_LOCK_ID_30, }; /* Mutex property information (Information for each process) _pb_CreateMutex calls -> 1 DeleteMutex calls -> 0 Only "1" can be used in the process. */ BOOL g_is_mutex_owner_tbl[MAX_CTRL_MUTEX_NUM]; /*---------------------------------------------------------------------------------* * Local Function Prototype * *---------------------------------------------------------------------------------*/ /* Mutex Control Table Manipulation Functions */ static void MutexSetLockIdOfCtrlTbl(u_int32 idx, LOCK_ID l_id); /* Set Lock ID */ static LOCK_ID MutexGetLockIdOfCtrlTbl(u_int32 idx); /* Get Lock ID */ static void MutexSetMutexNameOfCtrlTbl(u_int32 idx, LPCTSTR name); /* Set Mutex name */ static void MutexSetMutexHandleOfCtrlTbl(u_int32 idx, HANDLE handle); /* Set Mutex handle */ static HANDLE MutexGetMutexHandleOfCtrlTbl(u_int32 idx); /* Get Mutex Handle */ static void MutexSetTidOfCtrlTbl(uint32_t idx, uint32_t tid); /* Set thread ID while Lock is being acquired */ static uint32_t MutexGetTidOfCtrlTbl(uint32_t idx); /* Get thread ID while Lock is being acquired */ static void MutexSetIsRelFailOfCtrlTbl(uint32_t idx, BOOL flag); /* Set release failure information */ static void MutexSetIsForbidAccessOfCtrlTbl(uint32_t idx, BOOL flag); /* Set deletion occurrence while Lock is being acquired */ static u_int32 MutexGetIdxOfCtrlTbl(HANDLE h_mutex); /* Get index for access */ static void MutexIncRefCntOfCtrlTbl(u_int32 idx); /* Increment Mutex reference counter */ static void MutexDecRefCntOfCtrlTbl(u_int32 idx); /* Decrement Mutex reference counter */ static int32 MutexGetRefCntOfCtrlTbl(u_int32 idx); /* Get Mutex reference counter */ static int32 MutexGetRefCntLocalOfCtrlTbl(u_int32 idx); /* Get mutex reference counter (in-process) */ static u_int32 MutexSearchNameOfCtrlTbl(LPCTSTR name); /* Search mutex name */ static u_int32 MutexSearchEmptyOfCtrlTbl(void); /* Search unused area */ static void MutexIncUseCntOfCtrlInfo(void); /* Increment Mutex using counter */ static void MutexDecUseCntOfCtrlInfo(void); /* Decrement Mutex using counter */ static void MutexIncRsvCntOfCtrlInfo(void); /* Increment Mutex reserved counter */ static void MutexDecRsvCntOfCtrlInfo(void); /* Decrement Mutex reserved counter */ /* Mutex ownership-information manipulation functions */ static void MutexSetFlagOfOwnerTbl(u_int32 idx, BOOL flag); /* Set ownership-information */ static BOOL MutexGetFlagOfOwnerTbl(u_int32 idx); /* Get ownership-information */ /* Mutex manipulation functions for accessing Mutex control tables */ static void MutexCreateMutex(void); /* Create Mutex */ static void MutexLockMutex(void); /* Get Mutex */ static void MutexUnlockMutex(void); /* Release Mutex */ static void MutexDeleteMutex(void); /* Delete Mutex */ /*---------------------------------------------------------------------------------* * Function * *---------------------------------------------------------------------------------*/ /** * @brief * Initialize the mutex function * * Call the in-process initialization API for locking between processes that provide CLS.
* Create shared memory for a Mutex control table.
* Create a mutex for accessing Mutex control info.
* If an error occurs during internal processing of this API, subsequent normal operations cannot be performed, so call _pb_Exit(). * * @return RET_NORMAL */ RET_API MutexInit(void) { RET_API ret_api = RET_NORMAL; MUTEX_CTRL_SHARED_INFO **pp_tbl; u_int32 idx; memset(g_mutex_ctrl_tbl.handle, 0, sizeof(g_mutex_ctrl_tbl.handle)); memset(g_mutex_ctrl_tbl.ref_cnt, 0, sizeof(g_mutex_ctrl_tbl.ref_cnt)); /* Set pointer to Mutex control table */ pp_tbl = &(g_mutex_ctrl_tbl.info); MutexCreateMutex(); /* Create Mutex for accessing Mutex control info */ MutexLockMutex(); /* Get Mutex for accessing Mutex control info */ /* Open the Mutex control table shared memory */ g_h_shm = OpenSharedMemory((TCHAR*)(MUTEX_CTRL_TBL_NAME), // NOLINT(readability/casting) sizeof(MUTEX_CTRL_SHARED_INFO)); /* If called for the first time within all processes, an error occurs and the following processing is performed. */ if (g_h_shm == NULL) { // LCOV_EXCL_BR_LINE 200: can not be other val /* Create shared memory for Mutex control table */ // LCOV_EXCL_BR_LINE 200: can not return NULL g_h_shm = CreateSharedMemory((TCHAR*)MUTEX_CTRL_TBL_NAME, // NOLINT(readability/casting) sizeof(MUTEX_CTRL_SHARED_INFO)); if (g_h_shm == NULL) /* In case of an error */ { // LCOV_EXCL_BR_LINE 200: can not return NULL FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "_pb_CreateShareData ERROR [hShm:%p]", g_h_shm); AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert _pb_Exit(); // LCOV_EXCL_LINE 200: cannot return NULL /* don't arrive here. */ } } MutexUnlockMutex(); /* Release of Mutex for accessing Mutex control info */ /* Set addresses of the acquired shared memory as a pointer of the Mutex control table. */ *pp_tbl = reinterpret_cast(GetSharedMemoryPtr(g_h_shm)); /* Initialize various information of control table */ for (idx = 0; idx < MAX_CTRL_MUTEX_NUM; idx++) { /* Set Lock ID in Mutex control table(Overwrite from the second process onwards) */ MutexSetLockIdOfCtrlTbl(idx, kLockIdList[idx]); MutexSetFlagOfOwnerTbl(idx, FALSE); } return ret_api; } /** * @brief * Terminate */ RET_API MutexTerm(void) { // LCOV_EXCL_START 8:dead code AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert RET_API ret_api = RET_NORMAL; CloseSharedMemory(g_h_shm); MutexDeleteMutex(); return ret_api; } // LCOV_EXCL_STOP /** * @brief * Create Mutex * * Create a named mutex that can be locked between processes. * * @param[in] lp_mutex_attributes Security descriptor(Unused) * @param[in] b_initial_owner Initial owner flag(Unused) * @param[in] lp_name Mutex name * * @return Except NULL Handle of the created mutex (Management information pointer)
* NULL ABEND */ HANDLE _pb_CreateMutex(LPSECURITY_ATTRIBUTES lp_mutex_attributes, // NOLINT(readability/nolint) WPF_SYSAPI.h API BOOL b_initial_owner, LPCTSTR lp_name) { int32 idx; /* For accessing Mutex control table */ HANDLE h_mutex = NULL; /* Mutex handle */ void *p_addr; int32 errno; LOCK_ID lock_id; size_t len; /* Null check */ if (lp_name == NULL) { FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Argument ERROR!!"); } else { len = _tcslen(lp_name); if (len >= NAME_MAX) { FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Argument ERROR!! " \ "Length of mutex name is too long(>=%d). [len:%zu]", NAME_MAX, len); } else { MutexLockMutex(); /* Get Mutex for accessing Mutex control info */ /* Retrieve whether the specified mutex name exists in the Mutex control table */ idx = MutexSearchNameOfCtrlTbl(lp_name); /* Already assigned */ if (idx != MAX_CTRL_MUTEX_NUM) { /* Get mutex handle from Mutex control table */ h_mutex = MutexGetMutexHandleOfCtrlTbl(idx); /* First-time creation within a process */ if (h_mutex == NULL) { /* Get Lock ID */ lock_id = MutexGetLockIdOfCtrlTbl(idx); /* Lock information mapping (CLS) */ p_addr = CL_LockMap(lock_id); // LCOV_EXCL_BR_LINE 4: nsfw error /* In case of an error */ if (p_addr == MAP_FAILED) { // LCOV_EXCL_BR_LINE 4: nsfw error /* Output an error log and return an error value */ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, \ "CL_LockMap ERROR!! [p_addr:%p, errno:%d]", p_addr, errno); } else { /* Successful allocation */ /* Set Mutex handle in the mutex management table */ MutexSetMutexHandleOfCtrlTbl(idx, (HANDLE)p_addr); h_mutex = (HANDLE)p_addr; } } if (h_mutex != NULL) { // LCOV_EXCL_BR_LINE 200: h_mutex can not be NULL /* Increment Mutex reference counter */ MutexIncRefCntOfCtrlTbl(idx); FRAMEWORKUNIFIEDLOG(ZONE_20, __FUNCTION__, "### MUTEX TABLE INFORMATION # (+) idx:%d HANDLE:%p, " \ "ref_cnt:%d, LOCK_ID:%d, NAME:%s, ref_cnt:%d, tid:%d, fail:%d, forbid:%d", idx, g_mutex_ctrl_tbl.handle[idx], g_mutex_ctrl_tbl.ref_cnt[idx], g_mutex_ctrl_tbl.info->detail[idx].lock_id, g_mutex_ctrl_tbl.info->detail[idx].name, g_mutex_ctrl_tbl.info->detail[idx].ref_cnt, g_mutex_ctrl_tbl.info->detail[idx].thread_id, g_mutex_ctrl_tbl.info->detail[idx].is_rel_fail, g_mutex_ctrl_tbl.info->detail[idx].is_forbid_access); } } else { /* For a new assignment */ /* Get the free space in the mutex management table. */ idx = MutexSearchEmptyOfCtrlTbl(); /* Get Lock ID */ lock_id = MutexGetLockIdOfCtrlTbl(idx); /* Lock information mapping (CLS) */ p_addr = CL_LockMap(lock_id); /* In case of an error */ if (p_addr == MAP_FAILED) { // LCOV_EXCL_BR_LINE 4: nsfw error /* Output an error log and return an error value. */ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "CL_LockMap ERROR!! " \ "[p_addr:%p, errno:%d] In _pb_CreateMutex", p_addr, errno); } else { /* Successful allocation */ /* Set Mutex Hanlde in the mutex management table */ MutexSetMutexHandleOfCtrlTbl(idx, (HANDLE)p_addr); /* Set the mutex name in the mutex management table */ MutexSetMutexNameOfCtrlTbl(idx, lp_name); /* Increment Mutex reference counter */ MutexIncRefCntOfCtrlTbl(idx); /* Increment mutex using counter */ MutexIncUseCntOfCtrlInfo(); h_mutex = (HANDLE)p_addr; FRAMEWORKUNIFIEDLOG(ZONE_20, __FUNCTION__, "### MUTEX TABLE INFORMATION # (++) idx:%d HANDLE:%p, ref_cnt:%d, " \ "LOCK_ID:%d, NAME:%s, ref_cnt:%d, tid:%d, fail:%d, forbid:%d", idx, g_mutex_ctrl_tbl.handle[idx], g_mutex_ctrl_tbl.ref_cnt[idx], g_mutex_ctrl_tbl.info->detail[idx].lock_id, g_mutex_ctrl_tbl.info->detail[idx].name, g_mutex_ctrl_tbl.info->detail[idx].ref_cnt, g_mutex_ctrl_tbl.info->detail[idx].thread_id, g_mutex_ctrl_tbl.info->detail[idx].is_rel_fail, g_mutex_ctrl_tbl.info->detail[idx].is_forbid_access); } } if (h_mutex != NULL) { // LCOV_EXCL_BR_LINE 200: can not be NULL /* Update Mutex ownership */ MutexSetFlagOfOwnerTbl(idx, TRUE); } /* Release the Mutex for accessing Mutex control info */ MutexUnlockMutex(); } } return h_mutex; } /** * @brief * Delete the mutex * * Decrement the Mutex reference counter and delete it when it reaches zero. * * @param[in] h_mutex Mutex handle (CreateMutex return value) * * @return WAIT_OBJECT_0 Normal completion
* WAIT_FAILED ABEND */ DWORD PbDeleteMutex(HANDLE h_mutex) { DWORD lret = WAIT_OBJECT_0; u_int32 idx; int32 ref_cnt; int32 ret; BOOL is_owner; uint32_t tid; /* Null check */ if (h_mutex == NULL) { // LCOV_EXCL_BR_LINE 6: h_mutex cannot be NULL FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Argment ERROR"); AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert lret = WAIT_FAILED; /* ABEND */ // LCOV_EXCL_LINE 6: h_mutex cannot be NULL } else { MutexLockMutex(); /* Get Mutex for accessing Mutex control info */ /* Retrieve the index of the management table containing the Mutex handles */ idx = MutexGetIdxOfCtrlTbl(h_mutex); /* When the specified Mutex handle is not registered */ if (idx == MAX_CTRL_MUTEX_NUM) { // LCOV_EXCL_BR_LINE 200: idx can no be MAX_CTRL_MUTEX_NUM FRAMEWORKUNIFIEDLOG(ZONE_20, __FUNCTION__, "Argment ERROR [h_mutex:%p]", h_mutex); AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert lret = WAIT_FAILED; /* ABEND */ // LCOV_EXCL_LINE 200: idx can no be MAX_CTRL_MUTEX_NUM } else { /* If it is registered */ /* Determinate its ownership */ is_owner = MutexGetFlagOfOwnerTbl(idx); if (is_owner == TRUE) { /* Get Mutex reference counter */ ref_cnt = MutexGetRefCntOfCtrlTbl(idx); /* No clients are using the specified Mutex. */ if ((ref_cnt - 1) <= 0) { /* Lock information unmapping (CLS) */ ret = CL_LockUnmap(reinterpret_cast(h_mutex)); // LCOV_EXCL_BR_LINE 4: nsfw error /* When an error occurs */ if (ret == -1) { // LCOV_EXCL_BR_LINE 4: nsfw error FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "CL_LockUnmap ERROR"); AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert lret = WAIT_FAILED; /* ABEND */ // LCOV_EXCL_LINE 4: nsfw error } else { /* If successful */ /* Remove Mutex hanlde from Mutex control table */ MutexSetMutexHandleOfCtrlTbl(idx, NULL); /* Delete the mutex name from the Mutex control table */ MutexSetMutexNameOfCtrlTbl(idx, ""); /* Update Mutex ownership */ MutexSetFlagOfOwnerTbl(idx, FALSE); /* Decrement Mutex reference counter */ MutexDecRefCntOfCtrlTbl(idx); /* Decrement mutex using counter */ MutexDecUseCntOfCtrlInfo(); tid = MutexGetTidOfCtrlTbl(idx); if (tid != 0) { // LCOV_EXCL_BR_LINE 200: tid can not be 0 AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert MutexSetIsForbidAccessOfCtrlTbl(idx, TRUE); // LCOV_EXCL_LINE 200: tid can not be 0 } /* Initialize debug information */ MutexSetTidOfCtrlTbl(idx, 0); MutexSetIsRelFailOfCtrlTbl(idx, FALSE); FRAMEWORKUNIFIEDLOG(ZONE_20, __FUNCTION__, "### MUTEX TABLE INFORMATION # (--) idx:%d HANDLE:%p, ref_cnt(local):%d, " \ "LOCK_ID:%d, NAME:%s, ref_cnt:%d, tid:%d, fail:%d, forbid:%d", idx, g_mutex_ctrl_tbl.handle[idx], g_mutex_ctrl_tbl.ref_cnt[idx], g_mutex_ctrl_tbl.info->detail[idx].lock_id, g_mutex_ctrl_tbl.info->detail[idx].name, g_mutex_ctrl_tbl.info->detail[idx].ref_cnt, g_mutex_ctrl_tbl.info->detail[idx].thread_id, g_mutex_ctrl_tbl.info->detail[idx].is_rel_fail, g_mutex_ctrl_tbl.info->detail[idx].is_forbid_access); } } else { /* If exists */ /* Determine if any clients are referencing in the process */ ref_cnt = MutexGetRefCntLocalOfCtrlTbl(idx); if ((ref_cnt - 1) <= 0) { // LCOV_EXCL_BR_LINE 200: ref_cnt can not bigger than 1 // LCOV_EXCL_START 200: ref_cnt can not bigger than 1 AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert /* Lock information unmapping (CLS) */ ret = CL_LockUnmap(reinterpret_cast(h_mutex)); /* When an error occurs */ if (ret == -1) { FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "CL_LockUnmap ERROR"); lret = WAIT_FAILED; /* ABEND */ } else { /* If successful */ /* Remove Mutex Hanlde from the Mutex control table */ MutexSetMutexHandleOfCtrlTbl(idx, NULL); /* Update Mutex ownership */ MutexSetFlagOfOwnerTbl(idx, FALSE); } // LCOV_EXCL_STOP } if (lret == WAIT_OBJECT_0) { /* Decrement Mutex refernce counter */ MutexDecRefCntOfCtrlTbl(idx); FRAMEWORKUNIFIEDLOG(ZONE_20, __FUNCTION__, "### MUTEX TABLE INFORMATION # (-) idx:%d HANDLE:%p, ref_cnt(local):%d, " \ "LOCK_ID:%d, NAME:%s, ref_cnt:%d, tid:%d, fail:%d, forbid:%d", idx, g_mutex_ctrl_tbl.handle[idx], g_mutex_ctrl_tbl.ref_cnt[idx], g_mutex_ctrl_tbl.info->detail[idx].lock_id, g_mutex_ctrl_tbl.info->detail[idx].name, g_mutex_ctrl_tbl.info->detail[idx].ref_cnt, g_mutex_ctrl_tbl.info->detail[idx].thread_id, g_mutex_ctrl_tbl.info->detail[idx].is_rel_fail, g_mutex_ctrl_tbl.info->detail[idx].is_forbid_access); } } } else { // LCOV_EXCL_BR_LINE 200: is_owner can not be FALSE /* If it is not the owner */ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert lret = WAIT_FAILED; // LCOV_EXCL_LINE 200: is_owner can not be FALSE } } MutexUnlockMutex(); /* Release of Mutex for accessing Mutex control info */ } return lret; } /** * @brief * Mutex Lock * * Take ownership of the mutex and start locking. * * @param[in] h_mutex Mutex handle(CreateMutex return value) * @param[in] timeout Timeout (Millisecond) * * @return WAIT_OBJECT_0 Succeeded to get ownership
* WAIT_TIMEOUT Failed to get ownership (Timeout)
* WAIT_FAILED Failed to get ownership (Error) */ DWORD PbMutexLock(HANDLE h_mutex, DWORD timeout) { DWORD lret = WAIT_OBJECT_0; int32 ret; DWORD time_out_cnt = 0; u_int32 idx; BOOL is_owner; uint32_t tid; /* Null check */ if (h_mutex == NULL) { // LCOV_EXCL_BR_LINE 6: h_mutex cannot be NULL FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Argment ERROR"); AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert lret = WAIT_FAILED; /* ABEND */ // LCOV_EXCL_LINE 6: h_mutex cannot be NULL } else { /* Retrieve the index of the management table containing the Mutex handles */ idx = MutexGetIdxOfCtrlTbl(h_mutex); /* When the specified Mutex handle is not registered */ if (idx == MAX_CTRL_MUTEX_NUM) { // LCOV_EXCL_BR_LINE 6: idx cannot be MAX_CTRL_MUTEX_NUM FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Argment ERROR [h_mutex:%p, idx:%d]", \ h_mutex, idx); AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert lret = WAIT_FAILED; /* ABEND */ // LCOV_EXCL_LINE 6: idx cannot be MAX_CTRL_MUTEX_NUM } else { /* If it is registered */ /* Determinate ownership */ is_owner = MutexGetFlagOfOwnerTbl(idx); if (is_owner == TRUE) { tid = PbGetTid(); /* No timeout specified */ if (timeout == INFINITE) { // LCOV_EXCL_BR_LINE 6: timeout will not be other case /* Get Lock (CLS) */ ret = CL_LockGet(reinterpret_cast(h_mutex)); // LCOV_EXCL_BR_LINE 4: nsfw error if (ret != 0) /* In case of ABEND */ { // LCOV_EXCL_BR_LINE 4: nsfw error FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, \ "CL_LockGet ERROR [h_mutex:%p, ret:%d]", h_mutex, ret); AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert lret = WAIT_FAILED; /* ABEND */ // LCOV_EXCL_LINE 4: nsfw error } else { /* Set thread ID during lock */ MutexSetTidOfCtrlTbl(idx, tid); } } else { // LCOV_EXCL_START 6: timeout will not be other case AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert /* Timeout specified */ while (1) { /* Get Lock (CLS) */ ret = CL_LockNowait(reinterpret_cast(h_mutex)); if (ret != 0) /* In case of ABEND */ { /* Invalid parameter */ if (ret != EBUSY) { FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, \ "CL_LockGet ERROR [h_mutex:%p, ret:%d]", h_mutex, ret); lret = WAIT_FAILED; /* ABEND */ break; } time_out_cnt++; if (time_out_cnt <= timeout) { usleep(1000); } else { /* Timeout error */ lret = WAIT_TIMEOUT; break; } } else { /* Successful acquisition */ /* Set thread ID during lock */ MutexSetTidOfCtrlTbl(idx, tid); break; } } // LCOV_EXCL_STOP } } else { // LCOV_EXCL_BR_LINE 200: is_owner can not be FALSE /* If it is not the owner */ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert lret = WAIT_FAILED; // LCOV_EXCL_LINE 200: is_owner can not be FALSE } } } return lret; } /** * @brief * Mutex Unlock * * Release the mutex ownership and terminate the lock. * * @param[in] h_mutex Mutex handle(CreateMutex return value) * * @return TURE Normal
* FALSE Error */ BOOL PbMutexUnlock(HANDLE h_mutex) { BOOL bret = FALSE; int32 ret; u_int32 idx; BOOL is_owner; uint32_t tid; /* Null check */ if (h_mutex == NULL) { // LCOV_EXCL_BR_LINE 6: h_mutex can not be NULL FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Argment ERROR"); } else { /* Retrieve the index of the management table containing the Mutex handle */ idx = MutexGetIdxOfCtrlTbl(h_mutex); /* When the specified Mutex handle is not registered */ if (idx == MAX_CTRL_MUTEX_NUM) { // LCOV_EXCL_BR_LINE 200: idx can not be MAX_CTRL_MUTEX_NUM FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, \ "MutexGetIdxOfCtrlTbl ERROR [h_mutex:%p, idx:%d]", h_mutex, idx); } else { /* If it is registered */ /* Determinate ownership */ is_owner = MutexGetFlagOfOwnerTbl(idx); if (is_owner == TRUE) { // LCOV_EXCL_BR_LINE 4: nsfw error /* Release thread ID setting during lock */ MutexSetTidOfCtrlTbl(idx, 0); /* Release the Lock */ ret = CL_LockRelease(reinterpret_cast(h_mutex)); if (ret == 0) /* If successful */ { // LCOV_EXCL_BR_LINE 4: nsfw error bret = TRUE; } else { // LCOV_EXCL_BR_LINE 4: nsfw error // LCOV_EXCL_START 4: nsfw error AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert /* Failed */ tid = PbGetTid(); /* Retry to set the thread ID during lock */ MutexSetTidOfCtrlTbl(idx, tid); /* Add the release failure information */ MutexSetIsRelFailOfCtrlTbl(idx, TRUE); FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, \ "CL_LockRelease ERROR [h_mutex:%p, ret:%d]", h_mutex, ret); // LCOV_EXCL_STOP } } } } return bret; } /*---------------------------------------------------------------------------------* * Local Function * *---------------------------------------------------------------------------------*/ /** * @brief * Set the Lock ID (Mutex control table) * * If an invalid value is specified for an argument, the system assumes that it is a design problem and calls _pb_Exit(). * * @param[in] idx Control table accessor * @param[in] l_id Lock ID */ static void MutexSetLockIdOfCtrlTbl(u_int32 idx, LOCK_ID l_id) { /* check index */ if (idx >= MAX_CTRL_MUTEX_NUM) { // LCOV_EXCL_BR_LINE 6: idx cannot greater /* forbidden */ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Argment ERROR [idx:%d, l_id:%d]", idx, l_id); AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert _pb_Exit(); // LCOV_EXCL_LINE 6: idx cannot greater /* don't arrive here. */ } else { g_mutex_ctrl_tbl.info->detail[idx].lock_id = l_id; } return; } /** * @brief * Get the Lock ID (Mutex control table) * * If an invalid value is specified for an argument, the system assumes that it is a design problem and calls _pb_Exit(). * * @param[in] idx Control table accessor */ static LOCK_ID MutexGetLockIdOfCtrlTbl(u_int32 idx) { /* check index */ if (idx >= MAX_CTRL_MUTEX_NUM) { // LCOV_EXCL_BR_LINE 6: idx cannot greater /* forbidden */ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Argment ERROR [idx:%d]", idx); AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert _pb_Exit(); // LCOV_EXCL_LINE 6: idx cannot greater /* don't arrive here. */ } return g_mutex_ctrl_tbl.info->detail[idx].lock_id; } /** * @brief * Set the Mutex name (Mutex control table) * * If an invalid value is specified for an argument, the system assumes that it is a design problem and calls _pb_Exit(). * * @param[in] idx Control table accessor * @param[in] name Mutex name */ static void MutexSetMutexNameOfCtrlTbl(u_int32 idx, LPCTSTR name) { /* check index */ if (idx >= MAX_CTRL_MUTEX_NUM) { // LCOV_EXCL_BR_LINE 6: idx cannot greater /* forbidden */ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Argment ERROR [idx:%d, name:%s]", idx, name); AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert _pb_Exit(); // LCOV_EXCL_LINE 6: idx cannot greater /* don't arrive here. */ } else { _tcscpy(g_mutex_ctrl_tbl.info->detail[idx].name, name); } return; } /** * @brief * Set the Mutex handle (Mutex control table) * * If an invalid value is specified for an argument, the system assumes that it is a design problem and calls _pb_Exit(). * * @param[in] idx Control table accessor * @param[in] handle Mutex handle */ static void MutexSetMutexHandleOfCtrlTbl(u_int32 idx, HANDLE handle) { /* check index */ if (idx >= MAX_CTRL_MUTEX_NUM) { // LCOV_EXCL_BR_LINE 6: idx cannot greater /* forbidden */ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Argment ERROR [idx:%d, handle:%p]", idx, handle); AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert _pb_Exit(); // LCOV_EXCL_LINE 6: idx cannot greater /* don't arrive here. */ } else { g_mutex_ctrl_tbl.handle[idx] = handle; } return; } /** * @brief * Get the Mutex handle (Mutex control table) * * If an invalid value is specified for an argument, the system assumes that it is a design problem and calls _pb_Exit(). * * @param[in] idx Control table accessor * * @return Mutex handle */ static HANDLE MutexGetMutexHandleOfCtrlTbl(u_int32 idx) { HANDLE handle = NULL; /* check index */ if (idx >= MAX_CTRL_MUTEX_NUM) { // LCOV_EXCL_BR_LINE 6: idx cannot greater /* forbidden */ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Argment ERROR [idx:%d]", idx); AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert _pb_Exit(); // LCOV_EXCL_LINE 6: idx cannot greater /* don't arrive here. */ } else { handle = g_mutex_ctrl_tbl.handle[idx]; } return handle; } /** * @brief * Set the thread ID during lock acquisition (Mutex control table) * * @param[in] idx Control table accessor * @param[in] tid Thread ID * @note If an invalid value is specified for an argument, the system assumes that it is a design problem and calls _pb_Exit(). */ static void MutexSetTidOfCtrlTbl(uint32_t idx, uint32_t tid) { /* check index */ if (idx >= MAX_CTRL_MUTEX_NUM) { // LCOV_EXCL_BR_LINE 6: idx cannot greater /* forbidden */ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Argument ERROR [idx:%d]", idx); AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert _pb_Exit(); // LCOV_EXCL_LINE 6: idx cannot greater /* don't arrive here. */ } else { g_mutex_ctrl_tbl.info->detail[idx].thread_id = tid; } return; } /** * @brief * Get the thread ID during lock acquisition (Mutex control table) * * @param[in] idx Control table accessor * * @return Thread ID * * @note If an invalid value is specified for an argument, the system assumes that it is a design problem and calls _pb_Exit(). */ static uint32_t MutexGetTidOfCtrlTbl(uint32_t idx) { uint32_t tid = 0; /* check index */ if (idx >= MAX_CTRL_MUTEX_NUM) { // LCOV_EXCL_BR_LINE 6: idx cannot greater /* forbidden */ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Argument ERROR [idx:%d]", idx); AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert _pb_Exit(); // LCOV_EXCL_LINE 6: idx cannot greater /* don't arrive here. */ } else { tid = g_mutex_ctrl_tbl.info->detail[idx].thread_id; } return tid; } /** * @brief * Set the release failure information (Mutex control table) * * @param[in] idx Control table accessor * @param[in] flag Failed to release:TURE * @note If an invalid value is specified for an argument, the system assumes that it is a design problem and calls _pb_Exit(). */ static void MutexSetIsRelFailOfCtrlTbl(uint32_t idx, BOOL flag) { /* check index */ if (idx >= MAX_CTRL_MUTEX_NUM) { // LCOV_EXCL_BR_LINE 6: idx cannot greater /* forbidden */ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Argument ERROR [idx:%d]", idx); AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert _pb_Exit(); // LCOV_EXCL_LINE 6: idx cannot greater /* don't arrive here. */ } else { g_mutex_ctrl_tbl.info->detail[idx].is_rel_fail = flag; } return; } /** * @brief * Set deletion-occurrence information during Lock acquisition (Mutex control table) * * @param[in] idx Control table accessor * @param[in] flag When deletion occurs while Lock is being acquired:TRUE * @note If an invalid value is specified for an argument, the system assumes that it is a design problem and calls _pb_Exit(). */ static void MutexSetIsForbidAccessOfCtrlTbl(uint32_t idx, BOOL flag) { // LCOV_EXCL_START 8:dead code AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert /* check index */ if (idx >= MAX_CTRL_MUTEX_NUM) { // LCOV_EXCL_BR_LINE 6: idx cannot greater /* forbidden */ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Argument ERROR [idx:%d]", idx); AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert _pb_Exit(); // LCOV_EXCL_LINE 6: idx cannot greater /* don't arrive here. */ } else { g_mutex_ctrl_tbl.info->detail[idx].is_forbid_access = flag; } return; } // LCOV_EXCL_STOP /** * @brief * Get index for access (Mutex control table) * * Return the index for accessing the area of the Mutex control table in which
* the specified mutex handle is registered. If the specified handle is not
* registered, the maximum number of mutex management (MAX_MUTEX_CTRL_NUM) is returned. * * @param[in] h_mutex Mutex handle * * @return Index for access (Specified handle is already registered)
* Maximum mutex management value (Specified handle is not registered) */ static u_int32 MutexGetIdxOfCtrlTbl(HANDLE h_mutex) { u_int32 idx; HANDLE handle; for (idx = 0; idx < MAX_CTRL_MUTEX_NUM; idx++) { /* Get handle from Mutex control table */ handle = MutexGetMutexHandleOfCtrlTbl(idx); if (handle == h_mutex) { break; } } return idx; } /** * @brief * Increment the Mutex reference counter (Mutex control table) * * If an invalid value is specified for an argument, the system assumes that it is a design problem and calls _pb_Exit(). * * @param[in] idx Control table accessor */ static void MutexIncRefCntOfCtrlTbl(u_int32 idx) { /* check index */ if (idx >= MAX_CTRL_MUTEX_NUM) { // LCOV_EXCL_BR_LINE 6: idx cannot greater /* forbidden */ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Argment ERROR [idx:%d]", idx); AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert _pb_Exit(); // LCOV_EXCL_LINE 6: idx cannot greater /* don't arrive here. */ } g_mutex_ctrl_tbl.info->detail[idx].ref_cnt++; g_mutex_ctrl_tbl.ref_cnt[idx]++; return; } /** * @brief * Decrement the Mutex reference counter (Mutex control table) * * If an invalid value is specified for an argument, the system assumes that it is a design problem and calls _pb_Exit(). * * @param[in] idx Control table accessor */ static void MutexDecRefCntOfCtrlTbl(u_int32 idx) { /* check index */ if (idx >= MAX_CTRL_MUTEX_NUM) { // LCOV_EXCL_BR_LINE 6: idx cannot greater /* forbidden */ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Argment ERROR [idx:%d]", idx); AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert _pb_Exit(); // LCOV_EXCL_LINE 6: idx cannot greater /* don't arrive here. */ } g_mutex_ctrl_tbl.info->detail[idx].ref_cnt--; g_mutex_ctrl_tbl.ref_cnt[idx]--; return; } /** * @brief * Get the Mutex Reference Counter (Mutex control table) * * If an invalid value is specified for an argument, the system assumes that it is a design problem and calls _pb_Exit(). * * @param[in] idx Control table accessor * * @return Reference counter value */ static int32 MutexGetRefCntOfCtrlTbl(u_int32 idx) { int32 ret = 0; /* check index */ if (idx >= MAX_CTRL_MUTEX_NUM) { // LCOV_EXCL_BR_LINE 6: idx cannot greater /* forbidden */ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Argment ERROR [idx:%d]", idx); AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert _pb_Exit(); // LCOV_EXCL_LINE 6: idx cannot greater /* don't arrive here. */ } else { ret = g_mutex_ctrl_tbl.info->detail[idx].ref_cnt; } return ret; } /** * @brief * Get mutex reference counter (in-process)(Mutex control table) * * If an invalid value is specified for an argument, the system assumes that it is a design problem and calls _pb_Exit(). * * @param[in] idx Control table accessor * * @return Reference counter value */ static int32 MutexGetRefCntLocalOfCtrlTbl(u_int32 idx) { /* check index */ if (idx >= MAX_CTRL_MUTEX_NUM) { // LCOV_EXCL_BR_LINE 6: idx cannot greater /* forbidden */ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Argment ERROR [idx:%d]", idx); AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert _pb_Exit(); // LCOV_EXCL_LINE 6: idx cannot greater /* don't arrive here. */ } return g_mutex_ctrl_tbl.ref_cnt[idx]; } /** * @brief * Search mutex name (Mutex control table) * * Retrieve whether the specified mutex is already registered in the Mutex control table.
* If it is registered, the access index is returned.If it is not registered,
* return the maximum mutex management value(MAX_CTRL_MUTEX_NUM). * * @param[in] name Mutex name * * @return Index for access(If it is registered)
* Maximum mutex management value (Not registered) */ static u_int32 MutexSearchNameOfCtrlTbl(LPCTSTR name) { int32 ret; u_int32 idx; for (idx = 0; idx < MAX_CTRL_MUTEX_NUM; idx++) { ret = _tcscmp(g_mutex_ctrl_tbl.info->detail[idx].name, name); /* If there is a match */ if (ret == 0) { break; } } return idx; } /** * @brief * Search unused area (Mutex control table) * * Return the lowest-numbered index for accessing unused space in the Mutex control table.
* Return the maximum value((MAX_CTRL_MUTEX_NUM)) of message queue management
* when no unused area exists. * * @return Index for access (Unused area exists)
* Maximum mutex management value (No unused area) */ static u_int32 MutexSearchEmptyOfCtrlTbl(void) { u_int32 idx; idx = MutexSearchNameOfCtrlTbl(""); return idx; } /** * @brief * Set the Mutex ownership flag (Ownership-information table) * * @param[in] idx Control table accessor * @param[in] flag ownership-information */ static void MutexSetFlagOfOwnerTbl(u_int32 idx, BOOL flag) { /* check index */ if (idx >= MAX_CTRL_MUTEX_NUM) { // LCOV_EXCL_BR_LINE 6: idx cannot greater /* forbidden */ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Argment ERROR [idx:%d, flag:%d]", idx, flag); AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert _pb_Exit(); // LCOV_EXCL_LINE 6: idx cannot greater /* don't arrive here. */ } else { g_is_mutex_owner_tbl[idx] = flag; } return; } /** * @brief * Get the Mutex ownership flag (Ownership-information table) * * @param[in] idx Control table accessor * * @return TRUE Owned * FALSE Not owned */ static BOOL MutexGetFlagOfOwnerTbl(u_int32 idx) { BOOL bret = FALSE; /* check index */ if (idx >= MAX_CTRL_MUTEX_NUM) { // LCOV_EXCL_BR_LINE 6: idx cannot greater /* forbidden */ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Argment ERROR [idx:%d]", idx); AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert _pb_Exit(); // LCOV_EXCL_LINE 6: idx cannot greater /* don't arrive here. */ } else { bret = g_is_mutex_owner_tbl[idx]; } return bret; } /** * @brief * Create Mutex for accessing the Mutex control table */ static void MutexCreateMutex(void) { g_h_mtx = (HANDLE)CL_LockMap(MUTEX_LOCK_ID_0); // LCOV_EXCL_BR_LINE 4: nsfw error if (g_h_mtx == NULL) { // LCOV_EXCL_BR_LINE 4: nsfw error FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "CL_LockMap ERROR [g_h_mtx:%p]", g_h_mtx); AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert _pb_Exit(); // LCOV_EXCL_LINE 4: nsfw error /* don't arrive here. */ } return; } /** * @brief * Delete Mutex for accessing Mutex control table */ static void MutexDeleteMutex(void) { // LCOV_EXCL_START 8:dead code AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert int32 ret; ret = CL_LockUnmap(g_h_mtx); if (ret != 0) { FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, \ "CL_LockUnmap ERROR [g_h_mtx:%p, ret:%d]", g_h_mtx, ret); _pb_Exit(); /* don't arrive here. */ } return; } // LCOV_EXCL_STOP /** * @brief * Get Mutex for accessing Mutex control table */ static void MutexLockMutex(void) { int32 ret; ret = CL_LockGet(g_h_mtx); // LCOV_EXCL_BR_LINE 4: nsfw error if (ret != 0) { // LCOV_EXCL_BR_LINE 4: nsfw error FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, \ "CL_LockGet ERROR [g_h_mtx:%p, ret:%d]", g_h_mtx, ret); AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert _pb_Exit(); // LCOV_EXCL_LINE 4: nsfw error /* don't arrive here. */ } return; } /** * @brief * Release Mutex for accessing Mutex control table */ static void MutexUnlockMutex(void) { int32 ret; ret = CL_LockRelease(g_h_mtx); // LCOV_EXCL_BR_LINE 4: nsfw error if (ret != 0) { // LCOV_EXCL_BR_LINE 4: nsfw error FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, \ "CL_LockRelease ERROR [g_h_mtx:%p, ret:%d]", g_h_mtx, ret); AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert _pb_Exit(); // LCOV_EXCL_LINE 4: nsfw error /* don't arrive here. */ } return; } /** * @brief * Get dump information * * @param[out] p_buf Dump info * @param[in/out] p_len Buffer size */ void _pb_GetDebugMutexMngTbl(void* p_buf, uint8_t* p_len) { static uint8_t buf[DEBUG_DUMP_MAX_SIZE]; static uint8_t buf_tmp[512]; static uint8_t buf_info[DEBUG_DUMP_MAX_SIZE]; uint32_t i; uint8_t cnt = 0; if ((p_buf != NULL) && (p_len != NULL)) { memset(&buf[0], 0x00, sizeof(buf)); memset(&buf_info[0], 0x00, sizeof(buf_info)); for (i = 0; i < MAX_CTRL_MUTEX_NUM; i++) { memset(&buf_tmp[0], 0x00, sizeof(buf_tmp)); snprintf(reinterpret_cast(&buf_tmp[0]), sizeof(buf_tmp), "\n [%02d]id:%10d, nm:%40s, ref_cnt:%10d, tid:%03d, fail:%01d, " \ "forbid:%01d, handle:%10p, ref_cnt(local):%10d", i, g_mutex_ctrl_tbl.info->detail[i].lock_id, g_mutex_ctrl_tbl.info->detail[i].name, g_mutex_ctrl_tbl.info->detail[i].ref_cnt, g_mutex_ctrl_tbl.info->detail[i].thread_id, g_mutex_ctrl_tbl.info->detail[i].is_rel_fail, g_mutex_ctrl_tbl.info->detail[i].is_forbid_access, g_mutex_ctrl_tbl.handle[i], g_mutex_ctrl_tbl.ref_cnt[i]); strncat(reinterpret_cast(&buf_info[0]), reinterpret_cast(&buf_tmp[0]), \ strlen(reinterpret_cast(&buf_tmp[0]))); if (((i + 1) % 10) == 0) { cnt++; memset(&buf[0], 0x00, sizeof(buf)); snprintf(reinterpret_cast(&buf[0]), sizeof(buf), "Mutex-%d%s", cnt, &buf_info[0]); memcpy(p_buf, &buf[0], sizeof(buf)); p_buf = reinterpret_cast((reinterpret_cast(p_buf)) + sizeof(buf)); memset(&buf_info[0], 0x00, sizeof(buf_info)); if (cnt >= *p_len) { break; } } } if (cnt < *p_len) { if (buf_info[0] != 0x00) { cnt++; memset(&buf[0], 0x00, sizeof(buf)); snprintf(reinterpret_cast(&buf[0]), sizeof(buf), "Mutex-%d%s", cnt, &buf_info[0]); memcpy(p_buf, &buf[0], sizeof(buf)); } *p_len = cnt; } } } /** * @brief * Increment the Mutex using counter * * @param[in] none */ static void MutexIncUseCntOfCtrlInfo(void) { g_mutex_ctrl_tbl.info->use_cnt++; return; } /** * @brief * Decrement Mutex using counter * * @param[in] none */ static void MutexDecUseCntOfCtrlInfo(void) { g_mutex_ctrl_tbl.info->use_cnt--; return; } /** * @brief * Increment Mutex reserved counter * * @param[in] none */ static void MutexIncRsvCntOfCtrlInfo(void) { g_mutex_ctrl_tbl.info->rsv_cnt++; return; } /** * @brief * Decrement Mutex reserved counter * * @param[in] none */ static void MutexDecRsvCntOfCtrlInfo(void) { g_mutex_ctrl_tbl.info->rsv_cnt--; return; } /** * @brief * Determine resources ready (Mutex control data) * * @param[in] none * * @return BOOL * @retval TRUE : Normal * @retval FALSE : Error (Resource shortage) */ BOOL _pb_GetMutexResource(void) { BOOL ret = TRUE; uint32_t cnt; MutexLockMutex(); /* Increment Mutex reserved counter */ MutexIncRsvCntOfCtrlInfo(); cnt = g_mutex_ctrl_tbl.info->use_cnt + g_mutex_ctrl_tbl.info->rsv_cnt; if (cnt >= FULL_CTRL_MUTEX_NUM) { ret = FALSE; FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, \ "Lack of resources [FATAL][use_cnt:%d rsv_cnt:%d]", g_mutex_ctrl_tbl.info->use_cnt, \ g_mutex_ctrl_tbl.info->rsv_cnt); } else if (cnt >= WARN_CTRL_MUTEX_NUM) { FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, \ "Lack of resources [WARN][use_cnt:%d rsv_cnt:%d]", g_mutex_ctrl_tbl.info->use_cnt, \ g_mutex_ctrl_tbl.info->rsv_cnt); } MutexUnlockMutex(); return ret; } /** * @brief * Release resources (Mutex control data) * * @param[in] none * * @return none */ void _pb_ReleaseMutexResource(void) { MutexLockMutex(); /* Decrement Mutex reserved counter */ MutexDecRsvCntOfCtrlInfo(); MutexUnlockMutex(); return; } #endif /* PT_PB_MUTEX_STUB__CWORD71_ */