diff options
Diffstat (limited to 'systemservice/system_manager/server/src/ss_system_manager_callbacks.cpp')
| -rw-r--r-- | systemservice/system_manager/server/src/ss_system_manager_callbacks.cpp | 3411 |
1 files changed, 3411 insertions, 0 deletions
diff --git a/systemservice/system_manager/server/src/ss_system_manager_callbacks.cpp b/systemservice/system_manager/server/src/ss_system_manager_callbacks.cpp new file mode 100644 index 00000000..2e597ce6 --- /dev/null +++ b/systemservice/system_manager/server/src/ss_system_manager_callbacks.cpp @@ -0,0 +1,3411 @@ +/* + * @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_SystemManager +/// \brief This file provides support for System Manager business logic. +/// +/////////////////////////////////////////////////////////////////////////////// +#include <system_service/ss_heartbeat_service_protocol.h> +#include <system_service/ss_system_manager_if.h> +#include <system_service/ss_system_manager_if_local.h> +#include <native_service/frameworkunified_multithreading.h> +#include <sys/wait.h> +#include <system_service/ss_system_manager_notifications.h> +#include <system_service/ss_system_manager_notifications_local.h> +#include <native_service/frameworkunified_framework_if.h> +#include <system_service/ss_services.h> +#include <system_service/ss_power_service_if.h> +#include <processlauncher/ProcessLauncher.h> +#include <processlauncher/ss_sm_process_launcher_protocol.h> +#include <processlauncher/ss_sm_process_launcher.h> +#include <heartbeat/ss_hb_thread.h> + +#include <system_service/ss_power_service_notifications.h> +#include <system_service/ss_power_service_protocol.h> + +#include <native_service/ns_np_service.h> +#include <native_service/ns_np_service_protocol.h> +#include <native_service/ns_backup.h> + +#include <stub/ss_diag.h> + +#include <system_service/ss_error_message.h> +#include <system_service/ss_test_clients.h> +#include <system_service/ss_templates.h> +#include <native_service/ns_plogger_if.h> + +#include <stdlib.h> +#include <stdio.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <iomanip> +#include <vector> +#include <algorithm> +#include <string> + +#include "ss_system_manager_callbacks.h" +#include "ss_system_manager.h" +#include "ss_sm_systemmanagerlog.h" +#include "ss_sm_config.h" + +using namespace std; // NOLINT + +extern SS_String GetStr(SS_SMModuleState f_enum); + +template<typename C, eFrameworkunifiedStatus (C::*M)(HANDLE)> EFrameworkunifiedStatus SysMgrCallback(HANDLE hApp) { + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail; + C * pObj = static_cast<C *>(&CSystemManager::GetInstance()); + if (pObj) { // LCOV_EXCL_BR_LINE 5 : new error + l_eStatus = (pObj->*M)(hApp); + } + return l_eStatus; +} + +template<typename C, eFrameworkunifiedStatus (C::*M)(HANDLE, UI_32)> +EFrameworkunifiedStatus SysMgrCbType2(HANDLE hApp, UI_32 f_UI_32) { + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail; + C * pObj = static_cast<C *>(&CSystemManager::GetInstance()); + if (pObj) { // LCOV_EXCL_BR_LINE 5 : new error + l_eStatus = (pObj->*M)(hApp, f_UI_32); + } + return l_eStatus; +} + +template<typename C, BOOL (C::*M)(UI_32)> +BOOL SysMgrCbType3(UI_32 f_UI_32) { + BOOL l_bValue = FALSE; + C * pObj = static_cast<C *>(&CSystemManager::GetInstance()); + if (pObj) { // LCOV_EXCL_BR_LINE 5 : new error + l_bValue = (pObj->*M)(f_UI_32); + } + return l_bValue; +} + +enum { + POWERON = TRUE, + POWEROFF = FALSE +}; + +VOID CSystemManager::LogGroupModulesState(UI_32 f_groupId, std::string pStr) { + if (IS_ZONE_SET(ZONE_INFO)) { // LCOV_EXCL_BR_LINE 6: Because the applicable variable cannot be changed from the external API (only evaluated by the initial value) + // LCOV_EXCL_START 6: Because the applicable variable cannot be changed from the external API (only evaluated by the initial value) + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + GroupLaunchMapIter l_GroupIterator = m_MapProclaunchGrps.find(f_groupId); + if (l_GroupIterator == m_MapProclaunchGrps.end()) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + " Error: Group %d not found; 'm_MapProclaunchGrps' is empty", + f_groupId); + } else { + std::string sIsOKFlag; + TEXT(__FUNCTION__, " Group %d/%s, %ld modules: %s, %s", f_groupId, + l_GroupIterator->second.name.c_str(), + l_GroupIterator->second.modules.size(), pStr.c_str(), + GetStr(m_SMCurrentState).c_str()); + + ModuleLaunchListIter l_ModuleListIterator = l_GroupIterator->second.modules.begin(); + for (int i = 1; + l_ModuleListIterator != l_GroupIterator->second.modules.end(); + l_ModuleListIterator++, i++) { + sIsOKFlag = GetModuleCondition(l_ModuleListIterator) ? " " : // 'blank' means OK + "X"; // 'X' means state mismatch + + TEXT(__FUNCTION__, + " %2d: %-24s Start Req'd: %-5s %s %-24s %3dms, %3dms, %d", + i, l_ModuleListIterator->name.c_str(), + l_ModuleListIterator->is_start_required ? + "TRUE" : "FALSE", sIsOKFlag.c_str(), + l_ModuleListIterator->ModuleStateStr().c_str(), + static_cast<SI_16>(l_ModuleListIterator->m_startReason.GetDelta()), + static_cast<SI_16>(l_ModuleListIterator->m_stopReason.GetDelta()), + l_ModuleListIterator->pid); + } + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + // LCOV_EXCL_STOP + } +} // End of VOID CSystemManager::LogGroupModulesState( UI_32 f_groupId, std::string pStr) + +VOID CSystemManager::LogAllGroupModulesState(std::string pStr) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + std::string l_sIsOKFlag; + GroupLaunchMapIter l_GroupIterator = m_MapProclaunchGrps.begin(); + + std::stringstream l_comStream; + + l_comStream << pStr << "," << GetStr(m_SMCurrentState); + + std::string l_comStr = l_comStream.str(); + SystemmanagerLogString(ZONE_STATE, __FUNCTION__, l_comStr); + + while (l_GroupIterator != m_MapProclaunchGrps.end()) { + std::stringstream l_tblStream; + l_tblStream << "G" << l_GroupIterator->second.id << "/" << l_GroupIterator->second.name; + + ModuleLaunchListIter l_ModuleListIterator = l_GroupIterator->second.modules.begin(); + + for (int i = 1; + l_ModuleListIterator != l_GroupIterator->second.modules.end(); + l_ModuleListIterator++, i++) { + // Since NPPService exceptionally transitions to STARTED when StartReq'd = N, it is not checked + l_sIsOKFlag = + GetModuleCondition(l_ModuleListIterator) + | (FRAMEWORKUNIFIED_NS_NPSERVICE == l_ModuleListIterator->name) ? + " " : // 'blank' means OK + "X"; // 'X' means state mismatch + + std::string l_isStartReqd = l_ModuleListIterator->is_start_required ? "T" : "F"; + + l_tblStream << endl << " " << std::setw(2) << std::right << i << ":" + << l_ModuleListIterator->pid << " " + << l_ModuleListIterator->name << " " << "StartReq:" + << l_isStartReqd << " " << l_sIsOKFlag + << l_ModuleListIterator->ModuleStateStr(); + + if (l_ModuleListIterator->is_start_required && (FRAMEWORKUNIFIED_NS_NPSERVICE != l_ModuleListIterator->name)) { // LCOV_EXCL_BR_LINE 6: Because the condition cannot be set // NOLINT(whitespace/line_length) + l_tblStream << " " + << static_cast<SI_32>(l_ModuleListIterator->m_startReason.GetDelta()) + << "ms " + << static_cast<SI_32>(l_ModuleListIterator->m_stopReason.GetDelta()) + << "ms"; + } + } + + l_GroupIterator++; + + // Outputs each GROUP so that buffers do not overflow. + std::string l_logMsgStr = l_tblStream.str(); + SystemmanagerLogString(ZONE_STATE, __FUNCTION__, l_logMsgStr); + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} // End of VOID CSystemManager::LogAllGroupModulesState(std::string pStr) + +BOOL CSystemManager::GetModuleCondition(ModuleLaunchListIter & f_ModuleIter) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + BOOL l_bIsModuleStateGood = TRUE; + + switch (m_SMCurrentState) { // LCOV_EXCL_BR_LINE 6: As no values are passed into the default case + case SS_SM_READY_TO_LAUNCH_APP: + l_bIsModuleStateGood = f_ModuleIter->IsModuleState(MODULE_STATE_INVALID); + break; + + case SS_SM_APPS_LAUNCH_IN_PROGRESS: + l_bIsModuleStateGood = f_ModuleIter->IsModuleState(MODULE_STATE_SKIPPED) + || f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCH_FAILED) + || f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCHING) + || f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCHED); + break; + + case SS_SM_APPS_LAUNCHED_READY_TO_START: + l_bIsModuleStateGood = f_ModuleIter->IsModuleState(MODULE_STATE_SKIPPED) + || f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCH_FAILED) + || f_ModuleIter->IsModuleState(MODULE_STATE_CONNECTED) + || f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCHED); + break; + + case SS_SM_APPS_START_IN_PROGRESS: + l_bIsModuleStateGood = f_ModuleIter->IsModuleState(MODULE_STATE_SKIPPED) + || f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCH_FAILED) + || (f_ModuleIter->is_start_required + && (f_ModuleIter->IsModuleState(MODULE_STATE_START_SENT) + || f_ModuleIter->IsModuleState( + MODULE_STATE_STARTED))) + || (!f_ModuleIter->is_start_required + && (f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCHED) + || f_ModuleIter->IsModuleState( + MODULE_STATE_CONNECTED))); + break; + + case SS_SM_APPS_START_COMPLETE: + l_bIsModuleStateGood = + ((f_ModuleIter->IsModuleState(MODULE_STATE_SKIPPED) == TRUE) + || (f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCH_FAILED) == TRUE) + || ((f_ModuleIter->is_start_required == TRUE) + && (f_ModuleIter->IsModuleState(MODULE_STATE_STARTED) == TRUE)) + || ((f_ModuleIter->is_start_required == FALSE) + && ((f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCHED) == TRUE) + || (f_ModuleIter->IsModuleState(MODULE_STATE_CONNECTED) == TRUE)))) ? (BOOL) TRUE : (BOOL) FALSE; + break; + + case SS_SM_APPS_PRE_START_IN_PROGRESS: + l_bIsModuleStateGood = + ((f_ModuleIter->IsModuleState(MODULE_STATE_SKIPPED) == TRUE) + || (f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCH_FAILED) == TRUE) + || ((f_ModuleIter->is_start_required == TRUE) + && ((f_ModuleIter->IsModuleState(MODULE_STATE_START_PRE_SENT) == TRUE) + || (f_ModuleIter->IsModuleState(MODULE_STATE_STARTED_PRE) == TRUE))) + || ((f_ModuleIter->is_start_required == FALSE) + && ((f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCHED) == TRUE) + || (f_ModuleIter->IsModuleState(MODULE_STATE_CONNECTED) == TRUE)))) ? (BOOL) TRUE : (BOOL) FALSE; + break; + + case SS_SM_APPS_PRE_STOP_IN_PROGRESS: + l_bIsModuleStateGood = + ((f_ModuleIter->IsModuleState(MODULE_STATE_SKIPPED) == TRUE) + || (f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCH_FAILED) == TRUE) + || ((f_ModuleIter->is_start_required == TRUE) + && ((f_ModuleIter->IsModuleState(MODULE_STATE_STOP_PRE_SENT) == TRUE) + || (f_ModuleIter->IsModuleState(MODULE_STATE_STOPPED_PRE) == TRUE))) + || ((f_ModuleIter->is_start_required == FALSE) + && ((f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCHED) == TRUE) + || (f_ModuleIter->IsModuleState(MODULE_STATE_CONNECTED) == TRUE)))) ? (BOOL) TRUE : (BOOL) FALSE; + break; + + case SS_SM_APPS_PRE_RUN_COMPLETE: + l_bIsModuleStateGood = + ((f_ModuleIter->IsModuleState(MODULE_STATE_SKIPPED) == TRUE) + || (f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCH_FAILED) == TRUE) + || ((f_ModuleIter->is_start_required == TRUE) + && ((f_ModuleIter->IsModuleState(MODULE_STATE_STARTED_PRE) == TRUE) + || (f_ModuleIter->IsModuleState(MODULE_STATE_STOPPED_PRE) == TRUE))) + || ((f_ModuleIter->is_start_required == FALSE) + && ((f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCHED) == TRUE) + || (f_ModuleIter->IsModuleState(MODULE_STATE_CONNECTED) == TRUE)))) ? (BOOL) TRUE : (BOOL) FALSE; + break; + + case SS_SM_APPS_BACKGROUND_START_IN_PROGRESS: + l_bIsModuleStateGood = + ((f_ModuleIter->IsModuleState(MODULE_STATE_SKIPPED) == TRUE) + || (f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCH_FAILED) == TRUE) + || ((f_ModuleIter->is_start_required == TRUE) + && ((f_ModuleIter->IsModuleState(MODULE_STATE_START_BACKGROUND_SENT) == TRUE) + || (f_ModuleIter->IsModuleState(MODULE_STATE_STARTED_BACKGROUND) == TRUE))) + || ((f_ModuleIter->is_start_required == FALSE) + && ((f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCHED) == TRUE) + || (f_ModuleIter->IsModuleState(MODULE_STATE_CONNECTED) == TRUE)))) ? (BOOL) TRUE : (BOOL) FALSE; + break; + + case SS_SM_APPS_BACKGROUND_STOP_IN_PROGRESS: + l_bIsModuleStateGood = + ((f_ModuleIter->IsModuleState(MODULE_STATE_SKIPPED) == TRUE) + || (f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCH_FAILED) == TRUE) + || ((f_ModuleIter->is_start_required == TRUE) + && ((f_ModuleIter->IsModuleState(MODULE_STATE_STOP_BACKGROUND_SENT) == TRUE) + || (f_ModuleIter->IsModuleState(MODULE_STATE_STOPPED_BACKGROUND) == TRUE))) + || ((f_ModuleIter->is_start_required == FALSE) + && ((f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCHED) == TRUE) + || (f_ModuleIter->IsModuleState(MODULE_STATE_CONNECTED) == TRUE)))) ? (BOOL) TRUE : (BOOL) FALSE; + break; + case SS_SM_APPS_BACKGROUND_RUN_COMPLETE: + l_bIsModuleStateGood = + ((f_ModuleIter->IsModuleState(MODULE_STATE_SKIPPED) == TRUE) + || (f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCH_FAILED) == TRUE) + || ((f_ModuleIter->is_start_required == TRUE) + && ((f_ModuleIter->IsModuleState(MODULE_STATE_STARTED_BACKGROUND) == TRUE) + || (f_ModuleIter->IsModuleState(MODULE_STATE_STOPPED_BACKGROUND) == TRUE))) + || ((f_ModuleIter->is_start_required == FALSE) + && ((f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCHED) == TRUE) + || (f_ModuleIter->IsModuleState(MODULE_STATE_CONNECTED) == TRUE)))) ? (BOOL) TRUE : (BOOL) FALSE; + break; + + case SS_SM_APPS_STOPPING_AT__CWORD56__REQ: + case SS_SM_APPS_STOPPING_AT_INTERNAL_REQ: + l_bIsModuleStateGood = f_ModuleIter->IsModuleState(MODULE_STATE_SKIPPED) + || f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCH_FAILED) + || (f_ModuleIter->is_start_required + && (f_ModuleIter->IsModuleState(MODULE_STATE_STOP_SENT) + || f_ModuleIter->IsModuleState( + MODULE_STATE_STOPPED))) + || (!f_ModuleIter->is_start_required + && (f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCHED) + || f_ModuleIter->IsModuleState( + MODULE_STATE_CONNECTED))); + break; + + case SS_SM_WAITING_FOR_CRITICAL_APPS_AT__CWORD56__REQ: + case SS_SM_WAITING_FOR_CRITICAL_APPS_AT_INTERNAL_REQ: + l_bIsModuleStateGood = f_ModuleIter->IsModuleState(MODULE_STATE_SKIPPED) + || f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCH_FAILED) + || (f_ModuleIter->is_start_required + && f_ModuleIter->IsModuleState(MODULE_STATE_STOPPED)) + || (!f_ModuleIter->is_start_required + && (f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCHED) + || f_ModuleIter->IsModuleState( + MODULE_STATE_CONNECTED))); + break; + + // default: Don't code a 'default' here - let the compiler + // issue a warning ( set via -Wall or -Wswitch ) when the set of + // enumerations changes - then the maintainer will + // automagically know to update this switch statement. + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_bIsModuleStateGood; +} // End of BOOL CSystemManager::GetModuleCondition( ModuleLaunchListIter & f_ModuleIter ) + +/***************************************************************************** + @ingroup: CSystemManager + @brief: Post Termination handler + @note: . + @param void + @return void +*****************************************************************************/ +EFrameworkunifiedStatus CSystemManager::SendRequestToHeartBeat(HANDLE hApp, + EHBProtocolMessages tRequest, VOID *tReqMessageData, + UI_32 u32SizeofMessage) { + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; + BOOL bValid = FALSE; + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + switch (tRequest) { + case SS_HEARTBEAT_START: + bValid = TRUE; + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "SS_HEARTBEAT_START"); + break; + + case SS_HEARTBEAT_STOP: + bValid = TRUE; + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "SS_HEARTBEAT_STOP"); + tReqMessageData = NULL; + break; + + case SS_HEARTBEAT_DELETE_MODULE_ENTRY: + bValid = TRUE; + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "SS_HEARTBEAT_DELETE_MODULE_ENTRY"); + break; + + case SS_HEARTBEAT_APPEND_MODULE_ENTRY: + bValid = TRUE; + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "SS_HEARTBEAT_APPEND_MODULE_ENTRY"); + break; + + default: + bValid = FALSE; + l_eStatus = eFrameworkunifiedStatusInvldParam; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error : Ignored Invalid message id 0x%X", tRequest); + break; + } + + if (TRUE == bValid) { // LCOV_EXCL_BR_LINE 200:tRequest cannot be default, so bValid cannot be false + if (INVALID_HANDLE != m_hHeartbeatThread.m_ThreadHdl) { // LCOV_EXCL_BR_LINE 200:m_ThreadHdl cannot be null + if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedSendChild(hApp, m_hHeartbeatThread.m_ThreadHdl, tRequest, u32SizeofMessage, tReqMessageData))) { // LCOV_EXCL_BR_LINE 4:NSFW error case //NOLINT (whitespace/line_length) + // LCOV_EXCL_START 4: nsfw error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + LOG_ERROR("FrameworkunifiedSendChild()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 200: m_ThreadHdl cannot be null + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_eStatus = eFrameworkunifiedStatusInvldHandle; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error : Invalid Heartbeat Thread Handle, cannot send message"); + // LCOV_EXCL_STOP + } + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup OnModuleConnectWaitTimeout +/// SM maintains timer (40 sec) to check if all modules opened session with him whoever requires Start. +/// This timer is common to all modules. After timeout it checks the status of every module in group map. +/// If a module requires start and does not connect, SM will initiate error event logging followed by Soft Reset +/// \param [in] +/// +/// +/// \return EFrameworkunifiedStatus +/// Success ==> eFrameworkunifiedStatusOK +/// Failure ==> Other values +/////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CSystemManager::OnModuleConnectWaitTimeout(HANDLE hApp) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; + + static SI_32 l_NumTimesChecked = 0; + { + char l_cFormat[] = " Received from (Timer expiration %d)"; + char l_cBuf[sizeof(l_cFormat) + 1]; + snprintf(l_cBuf, sizeof(l_cBuf), l_cFormat, l_NumTimesChecked + 1); + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, l_cBuf); + } + + std::string l_ProcName; + + SetCmdHist("SM_TIMER_MODULE_CONNECT_WAIT_TIMER", m_TimerCmdHist, // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length) + m_TimerHistIter, FrameworkunifiedGetMsgSrc(hApp)); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length) + + BOOL l_bModuleConnMissed = false; + + GroupLaunchMap::reverse_iterator l_grp_riter = m_MapProclaunchGrps.rbegin(); + + ModuleLaunchList::reverse_iterator l_mod_riter; + + if (l_grp_riter == m_MapProclaunchGrps.rend()) { // LCOV_EXCL_BR_LINE 200: group cannot be empty + // LCOV_EXCL_START 200: group cannot be empty + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error: Group Map is Empty"); // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + l_eStatus = eFrameworkunifiedStatusDbRecNotFound; + // LCOV_EXCL_STOP + } else { + // scan the group map in reverse order + for (; l_grp_riter != m_MapProclaunchGrps.rend(); l_grp_riter++) { + l_mod_riter = l_grp_riter->second.modules.rbegin(); + for (; l_mod_riter != l_grp_riter->second.modules.rend(); + l_mod_riter++) { + SMModuleState l_ModuleState = l_mod_riter->GetModuleState(); + // if the module is still in MODULE_STATE_LAUNCHED state at + // this point though it requires start something is wrong with + // the module. SM initiates error event logging followed by + // soft rest + if (l_mod_riter->is_start_required + && ((l_ModuleState == MODULE_STATE_INVALID) + || (l_ModuleState == MODULE_STATE_SKIPPED) + || (l_ModuleState == MODULE_STATE_LAUNCHING) + || (l_ModuleState == MODULE_STATE_LAUNCHED) + || (l_ModuleState == MODULE_STATE_LAUNCH_FAILED))) { + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, + " Module %s/%s is not connected", + l_mod_riter->name.c_str(), + l_mod_riter->ModuleStateStr().c_str()); + l_bModuleConnMissed = true; + l_ProcName.assign(l_mod_riter->name); + + if (l_ModuleState == MODULE_STATE_LAUNCHED) { + CALL_AND_LOG_STATUS_IF_ERRORED( // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + l_mod_riter->SetPriority( // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + m_SystemManagerPriority - 1)); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + } + } + } + } + } + + PreLaunchModuleListIter l_itr; + for (l_itr = m_PreLaunchModuleList.begin(); + m_PreLaunchModuleList.end() != l_itr; l_itr++) { + if ((-1 == l_itr->pid) && (l_itr->critical)) { // LCOV_EXCL_BR_LINE 200: all prelaunch mode is not critical // NOLINT(whitespace/line_length) + // LCOV_EXCL_START 200: all prelaunch mode is not critical + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, " Module %s is not launched", // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + l_itr->name.c_str()); // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + l_bModuleConnMissed = true; + l_ProcName.assign(l_itr->name); + } + // LCOV_EXCL_STOP + } + + l_NumTimesChecked++; + if (true == l_bModuleConnMissed) { + if (l_NumTimesChecked < m_SMConfig.MCConfig.ModuleConnectionNumTimesToCheck) { + char l_cFormat[] = + " l_NumTimesChecked %d < ModuleConnectionNumTimesToCheck %d, " + "will re-check in %d seconds. "; + char l_cBuf[sizeof(l_cFormat) + 1 + 1 + 1]; + snprintf(l_cBuf, sizeof(l_cBuf), l_cFormat, l_NumTimesChecked, + m_SMConfig.MCConfig.ModuleConnectionNumTimesToCheck, + m_SMConfig.MCConfig.ModuleConnectionTimeOutSec); + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, l_cBuf); + + } else { + l_eStatus = eFrameworkunifiedStatusBadConnection; + char l_cFormat[] = + " Module connection timeout for %s and " + "l_NumTimesChecked %d == ModuleConnectionNumTimesToCheck %d. " + " Stopping ModuleConnectTimeOut timer and resetting _CWORD102_."; + char l_cBuf[sizeof(l_cFormat) + MAX_NAME_SIZE_APP + 1 + 1]; + snprintf(l_cBuf, sizeof(l_cBuf), l_cFormat, l_ProcName.c_str(), + l_NumTimesChecked, + m_SMConfig.MCConfig.ModuleConnectionNumTimesToCheck); + LOG_ERROR(l_cBuf); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + + m_GroupLaunchTimer->StopTimer(m_aTimerIDs[eSM_TIMER_MODULE_CONNECT_WAIT_TIMER]); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length) + + SMLoggingInfo l_loggingInfo; // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length) + l_loggingInfo.resetReason = e_SS_SM_CPU_RESET_REASON_GENERIC_ERR; // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length) + + // initiate error event logging + l_eStatus = ErrorEventEnqueue(hApp, eErrorEventTypeModConnFailed, + l_ProcName, eErrorEventResetTypeHard, l_loggingInfo); + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: ModConnFailed %s", + l_ProcName.c_str()); + fprintf(stderr, "SS_SysManager/%s/Error: ModConnFailed %s\n", // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length) + __FUNCTION__, l_ProcName.c_str()); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length) + LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length) + "ErrorEventEnqueue(eErrorEventTypeModConnFailed)"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length) + } + } else { + char l_cFormat[] = + " l_NumTimesChecked = %d, ModuleConnectionNumTimesToCheck = %d. " + "All modules connected. Stopping ModuleConnectTimeOut timer."; + char l_cBuf[sizeof(l_cFormat) + 1 + 1]; + snprintf(l_cBuf, sizeof(l_cBuf), l_cFormat, l_NumTimesChecked, + m_SMConfig.MCConfig.ModuleConnectionNumTimesToCheck); + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, l_cBuf); + + m_GroupLaunchTimer->StopTimer(m_aTimerIDs[eSM_TIMER_MODULE_CONNECT_WAIT_TIMER]); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length) + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::OnModuleConnectWaitTimeout( HANDLE hApp ) + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup OnClientStartMonitorTimerExpiry +/// +/// +/// \param [in] +/// +/// +/// \return EFrameworkunifiedStatus +/// Success ==> eFrameworkunifiedStatusOK +/// Failure ==> Other values +/////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CSystemManager::OnClientStartMonitorTimerExpiry(HANDLE hApp) { + EFrameworkunifiedStatus l_eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " Received from group %d" + //, m_ActiveGroupId); + , m_SystemStarter.get_id()); + + char cBuf[100]; + SetCmdHist("SM_TIMER_CLIENT_START_MONITOR", m_TimerCmdHist, m_TimerHistIter, FrameworkunifiedGetMsgSrc(hApp)); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length) + // sprintf( cBuf, "ProcessGroupAsStarted(%d)", m_ActiveGroupId); + sprintf(cBuf, "ProcessGroupAsStarted(%d)", m_SystemStarter.get_id()); // NOLINT + l_eStatus = ProcessGroupAsStarted(hApp, m_SystemStarter.get_id()); + LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, cBuf); // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length) + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + + + return l_eStatus; +} + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup send_power_request_complete_response +/// send power request completion response to power +/// +/// \param [in] +/// +/// \return EFrameworkunifiedStatus +/// Success ==> eFrameworkunifiedStatusOK +/// Failure ==> Other values +/////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CSystemManager::send_power_request_complete_response(HANDLE hApp, std::string pStr) { + EFrameworkunifiedStatus l_eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // send Wake-up complete response to Power + l_eStatus = FrameworkunifiedSendMsg(m_hPowerServiceSession, + SS_SM_WAKEUP_MODULES_CMPL_RSPN, sizeof(wakeInfo), (PVOID) & m_Wake); + LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, "FrameworkunifiedSendMsg(SS_SM_WAKEUP_MODULES_CMPL_RSPN)"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length) + + LogAllGroupModulesState(pStr); + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::send_power_request_complete_response( HANDLE hApp ) + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup OnNPPStatusCheckMonitorTimerExpiry +/// +/// \brief Called when NPP fails to provide a ready status in the specified. +/// amount of time. This function will periodically request a new status +/// ACK from NPP service until one is received. See OnNPPReadyStatusCallback(). +/// +/// Note: NPP usually pushes a ready event to SM and the reversion to +/// polling the NPP ready ACK is for additional robustness. Failure +/// to receive an NPP ready ACK will prevent system startup. +/// +/// \param [in] hApp - Handle to framework application. +/// +/// \return EFrameworkunifiedStatus +/// Success ==> eFrameworkunifiedStatusOK +/// Failure ==> Other values +/////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CSystemManager::OnNPPStatusCheckMonitorTimerExpiry(HANDLE hApp) { + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + SetCmdHist("SM_TIMER_NPP_STATUS_CHECK_MONITOR", m_TimerCmdHist, // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length) + m_TimerHistIter, FrameworkunifiedGetMsgSrc(hApp)); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length) + + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " m_bIsNPP_ServicesStarted is '%s'", + GetStr(m_bIsNPP_ServicesStarted).c_str()); + + if (FALSE == m_bIsNPP_ServicesStarted) { + l_eStatus = FrameworkunifiedNPGetReadyStatusOfNPP(hApp); + LOG_ERROR_REC_HIST_IF_ERRORED(l_eStatus, "FrameworkunifiedNPGetReadyStatusOfNPP()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length) + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup OnNPPReadyStatusCallback +/// +/// \brief Called when NPP returns a status ACK indicating that the service is +/// operational and ready to respond to subsequent requests. +/// +/// \param [in] hApp - Handle to framework application. +/// +/// \return EFrameworkunifiedStatus +/// Success ==> eFrameworkunifiedStatusOK +/// Failure ==> Other values +/////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CSystemManager::OnNPPReadyStatusCallback(HANDLE hApp) { // LCOV_EXCL_START 6: Because the condition cannot be set + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; + INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp); // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "from %s", FrameworkunifiedGetMsgSrc(hApp)); + + SetCmdHist("NPS_GET_READYSTATUS_ACK", m_SMCmdHist, m_SMHistIter, FrameworkunifiedGetMsgSrc(hApp)); + + l_eStatus = OnNPPReadyEventCallback(hApp); + LOG_ERROR_REC_HIST_IF_ERRORED(l_eStatus, "OnNPPReadyEventCallback()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length) + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} +// LCOV_EXCL_STOP + +EFrameworkunifiedStatus CSystemManager::OnNPPReadyEventCallback(HANDLE hApp) { + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + PCSTR l_moduleName = FrameworkunifiedGetMsgSrc(hApp); + FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "from %s", l_moduleName); + + SetCmdHist("NPS_NPP_READY_EVENT", m_SMCmdHist, m_SMHistIter, l_moduleName); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length) + if (TRUE == m_bIsNPP_ServicesStarted) { + l_eStatus = eFrameworkunifiedStatusMsgNotProcessed; + LOG_ERROR("TRUE == m_bIsNPP_ServicesStarted"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + } else { + ModuleLaunchListIter l_ModuleListIter; + m_bIsNPP_ServicesStarted = TRUE; + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " m_bIsNPP_ServicesStarted set 'TRUE'"); + m_GroupLaunchTimer->StopTimer(m_aTimerIDs[eSM_TIMER_NPP_STATUS_CHECK_MONITOR]); + + UI_32 l_cbCmdIdArrayNPPService[] = { NPS_NPP_READY_EVENT, NPS_GET_READYSTATUS_ACK }; + + if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedDetachCallbacksFromDispatcher(hApp, FRAMEWORKUNIFIED_NS_NPSERVICE, l_cbCmdIdArrayNPPService, static_cast<UI_32>(_countof(l_cbCmdIdArrayNPPService))))) { // LCOV_EXCL_BR_LINE 4:NSFW error case //NOLINT (whitespace/line_length) + // LCOV_EXCL_START 4: nsfw error code + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + LOG_ERROR("FrameworkunifiedDetachCallbacksFromDispatcher()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + // LCOV_EXCL_STOP + } else if (eFrameworkunifiedStatusOK != (l_eStatus = register_all_notification_callbacks(hApp))) { // LCOV_EXCL_BR_LINE 4:NSFW error case //NOLINT (whitespace/line_length) + // LCOV_EXCL_START 4: nsfw error code + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + LOG_ERROR("register_all_notification_callbacks()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + // LCOV_EXCL_STOP + } else if (eFrameworkunifiedStatusOK != (l_eStatus = GetModuleIterator(l_moduleName, l_ModuleListIter))) { // LCOV_EXCL_BR_LINE 200:NPP always in launch map //NOLINT (whitespace/line_length) + // LCOV_EXCL_START 200 : NPP service always in launch map + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + " Error: Module %s not found in Group Launch Map", // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + l_moduleName); // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + // LCOV_EXCL_STOP + } else { + l_ModuleListIter->SetModuleState(MODULE_STATE_STARTED); + + if (m_oSystemLauncher.get_id() == 1) { + m_oSystemLauncher.advance_id(); + } + + l_eStatus = OnLaunchGroup(hApp); + LOG_ERROR_REC_HIST_IF_ERRORED(l_eStatus, "OnLaunchGroup(hApp)"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length) + if (eFrameworkunifiedStatusOK == l_eStatus) { // LCOV_EXCL_BR_LINE 200: OnLaunchGroup() return ok + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " successful"); + } + } + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::OnNPPReadyEventCallback( HANDLE hApp ) + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup OnBackupMgrAvailCallback +/// BackupManager Availability Notification Callback +/// +/// \param [in] +/// +/// +/// \return EFrameworkunifiedStatus +/// Success ==> eFrameworkunifiedStatusOK +/// Failure ==> Other values +/////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CSystemManager::OnBackupMgrAvailCallback(HANDLE hApp) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; + + if (sizeof(ServiceAvailability) != FrameworkunifiedGetMsgLength(hApp)) { // LCOV_EXCL_BR_LINE 4: nsfw error + // LCOV_EXCL_START 4: nsfw error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + SS_ASERT(0); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + // LCOV_EXCL_STOP + l_eStatus = eFrameworkunifiedStatusFail; + } else if (strcmp(FrameworkunifiedGetLastNotification(hApp), NTFY_BackupMgr_Availability) != 0) { // LCOV_EXCL_BR_LINE 200:cannot be false //NOLINT (whitespace/line_length) + // LCOV_EXCL_START 200: cannot be false + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + SS_ASERT(0); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + l_eStatus = eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } else { + m_bIsBackupAvail = FrameworkunifiedIsServiceAvailable(hApp); + FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "BackupAvail:%s", m_bIsBackupAvail ? "T" : "F"); + + l_eStatus = OnLaunchGroup(hApp); + LOG_ERROR_REC_HIST_IF_ERRORED(l_eStatus, "OnLaunchGroup(hApp)"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length) + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::OnBackupMgrAvailCallback(HANDLE hApp) + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup OnPowerRequestCallback +/// PowerRequest callback handler +/// +/// \param [in] +/// +/// +/// \return EFrameworkunifiedStatus +/// Success ==> eFrameworkunifiedStatusOK +/// Failure ==> Other values +/////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CSystemManager::OnPowerRequestCallback(HANDLE hApp) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; + Pwr_ServiceSetInterface tServiceIf; + INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp); // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + + SetCmdHist("SS_SM_POWER_REQUEST_MSG", m__CWORD56_CmdHist, m__CWORD56_HistIter, FrameworkunifiedGetMsgSrc(hApp)); + + // OnSystemManagerDebugDump(hApp); + // ReadMsg(): * + // Check hApp ptr, msg size, msg reception, read msg if all ok. * + // Report any errors found. * + // * + if (eFrameworkunifiedStatusOK != (l_eStatus = ReadMsg < Pwr_ServiceSetInterface > (hApp, tServiceIf))) { // LCOV_EXCL_BR_LINE 4:NSFW error case //NOLINT (whitespace/line_length) + // LCOV_EXCL_START 4: nsfw error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + LOG_ERROR("ReadMsg()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + // LCOV_EXCL_STOP + } else { + // NOTE: interface_unified always set userMode as 0. so don't use m_lastUserMode. + m_lastUserMode = tServiceIf.data.powerRequestMsg.userMode; + // + // 2012 December 04 Temporary hack ( I hope ) to set m_Wake to nominal + // values. At present, the 'Power Request Message Response' is sent + // back to Power Services via the 'send_power_request_complete_response()' + // function, which uses m_Wake. + m_Wake.powerupType = + m_SSBool_to_PowerTypeEnumMap[m_SSUserMode_to_SSBoolEnumMap[m_lastUserMode]]; + + m_Wake.up.factor = tServiceIf.data.powerRequestMsg.startupReason; + + if (epswfINVALID != m_Wake.up.factor) { + m_StartUpReason = m_Wake.up.factor; + } + + m_userModeChangeReason = tServiceIf.data.powerRequestMsg.userModeChangeReason; + m_Wake.up.userModeChangeReason = m_userModeChangeReason; + + FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "UserMode:%s, SM State:%s", + GetStr(m_lastUserMode).c_str(), + GetStr(m_SMCurrentState).c_str()); + FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "UserMode:%s, SM State:%s", + GetStr(m_lastUserMode).c_str(), + GetStr(m_SMCurrentState).c_str()); + CALL_AND_LOG_STATUS(PublishPowerOnOffNotification(hApp)); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + + switch (m_SMCurrentState) { // LCOV_EXCL_BR_LINE 6: As not all cases can be passed through + case SS_SM_READY_TO_LAUNCH_APP: + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + " Error: Received a PowerRequest command while still in " + "the '%s' state !!!", + GetStr(m_SMCurrentState).c_str()); + l_eStatus = eFrameworkunifiedStatusErrOther; + break; + + case SS_SM_APPS_LAUNCH_IN_PROGRESS: + // When Start is received while processes are launching, we + // need to send the Start request later, once the 'Open + // Session Request' is received from the application. + //***** + // Deliberate commenting-out of case-break to allow this case to + // use following case's logic. + // break; + //***** + + case SS_SM_APPS_LAUNCHED_READY_TO_START: + case SS_SM_APPS_START_COMPLETE: + case SS_SM_APPS_PRE_RUN_COMPLETE: + case SS_SM_APPS_BACKGROUND_RUN_COMPLETE: + case SS_SM_APPS_START_IN_PROGRESS: + case SS_SM_APPS_PRE_START_IN_PROGRESS: + case SS_SM_APPS_PRE_STOP_IN_PROGRESS: + case SS_SM_APPS_BACKGROUND_START_IN_PROGRESS: + case SS_SM_APPS_BACKGROUND_STOP_IN_PROGRESS: + FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "Startup Reason is '%s'", GetStr(m_StartUpReason).c_str()); + if ((m_userModeChangeReason == epsumcrPARKING_B) + || ((m_userModeChangeReason == epsumcrPRE_BA) && (m_SMCurrentState == SS_SM_APPS_PRE_RUN_COMPLETE)) + || ((m_userModeChangeReason == epsumcrNORMAL) && (m_SMCurrentState == SS_SM_APPS_START_COMPLETE)) + || ((m_userModeChangeReason == epsumcrBACKGROUND_BA) + && (m_SMCurrentState == SS_SM_APPS_BACKGROUND_RUN_COMPLETE))) { + // send the Power Request complete response to PowerService + // LCOV_EXCL_BR_START 15: Excluded due to inlined functions + CALL_AND_LOG_STATUS_IF_ERRORED(send_power_request_complete_response(hApp, "Power Request")); + // LCOV_EXCL_BR_STOP 15: Excluded due to inlined functions + } else { + // + // Publish the UserMode 'Off' notification now for those + // applications that need immediate notification ( HMI ) + if (m_lastUserMode == epsumOFF) { + CALL_AND_LOG_STATUS(PublishUserModeNotification(hApp)); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + } + + CALL_AND_LOG_STATUS(BeginStartup(hApp)); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + } + break; + + case SS_SM_APPS_STOPPING_AT__CWORD56__REQ: + case SS_SM_WAITING_FOR_CRITICAL_APPS_AT__CWORD56__REQ: + // Abort the Stop. + // Reset System Manager to handle (re)starting as if this is a + // nominal start. + m_GroupLaunchTimer->StopTimer(m_aTimerIDs[eSM_TIMER_CLIENT_STOP_MONITOR]); + + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " Aborted %s, resetting to %s," + " restarting Application groups at group %d", + GetStr(m_SMCurrentState).c_str(), + GetStr(SS_SM_APPS_START_IN_PROGRESS).c_str() + , m_SystemStarter.get_id()); + + CALL_AND_LOG_STATUS(BeginStartup(hApp)); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + + break; + + case SS_SM_APPS_STOPPING_AT_INTERNAL_REQ: + case SS_SM_WAITING_FOR_CRITICAL_APPS_AT_INTERNAL_REQ: // LCOV_EXCL_START 8: As no value is set + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, + " Warning: System Manager state is %d/'%s', ignoring " + "PowerRequest command", m_SMCurrentState, + GetStr(m_SMCurrentState).c_str()); + break; + } // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::OnPowerRequestCallback( HANDLE hApp ) + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup +/// Begin the Startup process +/// +/// \param [in] +/// +/// +/// \return EFrameworkunifiedStatus +/// Success ==> eFrameworkunifiedStatusOK +/// Failure ==> Other values +/////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CSystemManager::BeginStartup(HANDLE hApp) { + EFrameworkunifiedStatus l_eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if ((m_userModeChangeReason != epsumcrPARKING_B) && + (m_userModeChangeReason != epsumcrPRE_BA) && + (m_userModeChangeReason != epsumcrNORMAL) && + (m_userModeChangeReason != epsumcrBACKGROUND_BA)) { + // Not a power state transition request. + return eFrameworkunifiedStatusOK; + } + + switch (m_userModeChangeReason) { // LCOV_EXCL_BR_LINE 6: Excluded because it has been guarded to prevent out-of-range values from entering immediately before. + case epsumcrPRE_BA: + // LCOV_EXCL_BR_START 6: This function is an internal function, and it is guarded so that the value outside the range is not entered by the caller, so it is excluded. + if ((m_SMCurrentState == SS_SM_APPS_START_COMPLETE) || (m_SMCurrentState == SS_SM_APPS_BACKGROUND_RUN_COMPLETE)) { + // LCOV_EXCL_BR_STOP 6: This function is an internal function, and it is guarded so that the value outside the range is not entered by the caller, so it is excluded. + m_SystemStarter.to_end(); + SMSetState(hApp, SS_SM_APPS_PRE_STOP_IN_PROGRESS); + } else { + m_SystemStarter.to_begin(); + SMSetState(hApp, SS_SM_APPS_PRE_START_IN_PROGRESS); + } + break; + case epsumcrNORMAL: + m_SystemStarter.to_begin(); + SMSetState(hApp, SS_SM_APPS_START_IN_PROGRESS); + break; + case epsumcrBACKGROUND_BA: + if (m_SMCurrentState == SS_SM_APPS_START_COMPLETE) { + m_SystemStarter.to_end(); + SMSetState(hApp, SS_SM_APPS_BACKGROUND_STOP_IN_PROGRESS); + } else { + m_SystemStarter.to_begin(); + SMSetState(hApp, SS_SM_APPS_BACKGROUND_START_IN_PROGRESS); + } + break; + default: + break; + } + + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, + " Starting 'Start Resp Monitor' Timer with '%d' sec", + m_SMConfig.MCConfig.ModuleStartRespTimeOutSec); + + m_GroupLaunchTimer->StartTimer( + m_aTimerIDs[eSM_TIMER_START_RESP_MONITOR_WAIT_TIMER], + m_SMConfig.MCConfig.ModuleStartRespTimeOutSec, 0, 0, 0); + + l_eStatus = start_all_modules_of_group(hApp, m_SystemStarter.get_id()); + if (eFrameworkunifiedStatusOK != l_eStatus) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + " Error: start_all_modules_of_group(%d) errored: %d/'%s'", + m_SystemStarter.get_id(), l_eStatus, GetStr(l_eStatus).c_str()); + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::BeginStartup( HANDLE hApp ) + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup OnWakeupCallback +/// WakeUp callback handler +/// +/// \param [in] +/// +/// +/// \return EFrameworkunifiedStatus +/// Success ==> eFrameworkunifiedStatusOK +/// Failure ==> Other values +/////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CSystemManager::OnWakeupCallback(HANDLE hApp) { // LCOV_EXCL_START 6: Because the condition cannot be set + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp); + FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "Received from %s", FrameworkunifiedGetMsgSrc(hApp)); + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::OnWakeupCallback( HANDLE hApp ) +// LCOV_EXCL_STOP + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup OnModuleStartCompleteResponse +/// Start Response\Ack Handlers +/// +/// \param [in] +/// +/// +/// \return EFrameworkunifiedStatus +/// Success ==> eFrameworkunifiedStatusOK +/// Failure ==> Other values +/////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CSystemManager::OnModuleStartCompleteResponse(HANDLE hApp) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus; + INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp); // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "%s", FrameworkunifiedGetMsgSrc(hApp)); + + SetCmdHist("system_manager protocol completion response", m_SMCmdHist, m_SMHistIter, FrameworkunifiedGetMsgSrc(hApp)); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length) + + ModuleLaunchListIter l_ModuleListIter; + std::string l_moduleName = FrameworkunifiedGetMsgSrc(hApp); + l_eStatus = GetModuleIterator(l_moduleName.c_str(), l_ModuleListIter); + if (eFrameworkunifiedStatusOK != l_eStatus) { // LCOV_EXCL_BR_LINE 200:always be eFrameworkunifiedStatusOK + // LCOV_EXCL_START 200: always be eFrameworkunifiedStatusOK + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + " Error: Module %s not found in Group Launch Map", + l_moduleName.c_str()); + // LCOV_EXCL_STOP + } else { + switch (m_SMCurrentState) { // LCOV_EXCL_BR_LINE 200: cannot be SS_SM_READY_TO_LAUNCH_APP + case SS_SM_READY_TO_LAUNCH_APP: + // LCOV_EXCL_START 200: cannot be SS_SM_READY_TO_LAUNCH_APP + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + " Error: Received while in the '%s' state !!!", + GetStr(m_SMCurrentState).c_str()); + l_eStatus = eFrameworkunifiedStatusErrOther; + break; + // LCOV_EXCL_STOP + + case SS_SM_APPS_LAUNCH_IN_PROGRESS: + case SS_SM_APPS_LAUNCHED_READY_TO_START: + case SS_SM_APPS_START_IN_PROGRESS: + case SS_SM_APPS_PRE_START_IN_PROGRESS: + case SS_SM_APPS_PRE_STOP_IN_PROGRESS: + case SS_SM_APPS_BACKGROUND_START_IN_PROGRESS: + case SS_SM_APPS_BACKGROUND_STOP_IN_PROGRESS: + { + const SMModuleState l_state = InProgressStateToState(); // LCOV_EXCL_BR_LINE 11: Gcov constraints (because exception-handling routes are automatically generated) // NOLINT(whitespace/line_length) + if (l_state != MODULE_STATE_INVALID) { + const PCSTR l_loglist[] = {"start", "pre start", "pre stop", "background start", "background stop", ""}; + PCSTR l_logtxt; + switch (l_state) { // LCOV_EXCL_BR_LINE 6: As no other value is returned + case MODULE_STATE_STARTED: + l_logtxt = l_loglist[0]; + break; + case MODULE_STATE_STARTED_PRE: + l_logtxt = l_loglist[1]; + break; + case MODULE_STATE_STOPPED_PRE: + l_logtxt = l_loglist[2]; + break; + case MODULE_STATE_STARTED_BACKGROUND: + l_logtxt = l_loglist[3]; + break; + case MODULE_STATE_STOPPED_BACKGROUND: + l_logtxt = l_loglist[4]; + break; + // LCOV_EXCL_START 6: As no other value is returned + default: + AGL_ASSERT_NOT_TESTED(); + l_logtxt = l_loglist[5]; + break; + // LCOV_EXCL_STOP 6: As no other value is returned + } + l_eStatus = ModuleCompleteResponse(hApp, l_ModuleListIter, l_state, // LCOV_EXCL_BR_LINE 11: Gcov constraints (because exception-handling routes are automatically generated) // NOLINT(whitespace/line_length) + SysMgrCbType3<CSystemManager, &CSystemManager::IsGroupStarted>, + SysMgrCbType2<CSystemManager, &CSystemManager::ProcessGroupAsStarted>, + l_logtxt); + } + } + break; + + case SS_SM_APPS_STOPPING_AT__CWORD56__REQ: + case SS_SM_APPS_STOPPING_AT_INTERNAL_REQ: + case SS_SM_WAITING_FOR_CRITICAL_APPS_AT__CWORD56__REQ: + case SS_SM_WAITING_FOR_CRITICAL_APPS_AT_INTERNAL_REQ: + // SystemManager changed state while this module was starting; + // tell this module to stop. + if (!l_ModuleListIter->IsModuleState(MODULE_STATE_STOP_SENT) + && !l_ModuleListIter->IsModuleState(MODULE_STATE_STOPPED)) { + T_SS_SM_STOP_DataStructType l_SM_STOP_Struct; + l_SM_STOP_Struct.shutdownTrigger = m_shutdownTrigger; + l_SM_STOP_Struct.lastUserMode = m_lastUserMode; + + CALL_AND_LOG_STATUS( // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + l_ModuleListIter->SendMsgAndUpdateState( + &l_SM_STOP_Struct)); + } + break; + default: + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: Received while in the '%s' state !!!", GetStr(m_SMCurrentState).c_str()); + l_eStatus = eFrameworkunifiedStatusErrOther; + break; + } // End switch ( m_SMCurrentState ) + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::OnModuleStartCompleteResponse( HANDLE hApp ) + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup ModuleCompleteResponse +/// Start Response\Ack Handlers +/// +/// \param [in] +/// +/// +/// \return EFrameworkunifiedStatus +/// Success ==> eFrameworkunifiedStatusOK +/// Failure ==> Other values +/////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CSystemManager::ModuleCompleteResponse(HANDLE hApp, + ModuleLaunchListIter f_ModuleListIter, SMModuleState f_moduleState, + FncCbType3 f_isGroupDoneFnc, FncCbType2 f_groupDoneFnc, + PCSTR f_sCompleteTypeText) { + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + std::string l_moduleName = FrameworkunifiedGetMsgSrc(hApp); + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, + " Received from %s, m_SystemStarter.get_id() is %d", + l_moduleName.c_str() + , m_SystemStarter.get_id()); + + f_ModuleListIter->SetModuleState(f_moduleState); + if (f_ModuleListIter->group_id != m_SystemStarter.get_id()) { + // In PastModel002, it is assumed that there is no service that returns a FrameworkunifiedOnStop reply after the NPP service. + // However, since _CWORD71_ does not assume this, completion of waiting for termination of the CRITICAL service must be + // judged even when services other than the Group1 service terminate last. + // Initially, SS_SM_WAITING_FOR_CRITICAL_APPS_AT_XXXX should be handled separately by ProcessModuleStopCompleteResponse(), + // but this is limited to ModuleCompleteResponse in order to avoid code deviation from PastModel002 and limit the scope of effect. + // LCOV_EXCL_BR_START 200 : m_SMCurrentState can't be SS_SM_WAITING_FOR_CRITICAL_APPS_AT__CWORD56__REQ and SS_SM_WAITING_FOR_CRITICAL_APPS_AT_INTERNAL_REQ // NOLINT(whitespace/line_length) + if ((MODULE_STATE_STOPPED == f_moduleState) + && ((m_SMCurrentState + == SS_SM_WAITING_FOR_CRITICAL_APPS_AT__CWORD56__REQ) + || (m_SMCurrentState + == SS_SM_WAITING_FOR_CRITICAL_APPS_AT_INTERNAL_REQ))) { + // LCOV_EXCL_BR_STOP 200 : m_SMCurrentState can't be SS_SM_WAITING_FOR_CRITICAL_APPS_AT__CWORD56__REQ and SS_SM_WAITING_FOR_CRITICAL_APPS_AT_INTERNAL_REQ // NOLINT(whitespace/line_length) + // LCOV_EXCL_START 200 : m_SMCurrentState can't be SS_SM_WAITING_FOR_CRITICAL_APPS_AT__CWORD56__REQ and SS_SM_WAITING_FOR_CRITICAL_APPS_AT_INTERNAL_REQ // NOLINT(whitespace/line_length) + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + check_all_groups_have_stopped(hApp); + // LCOV_EXCL_STOP + } else { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, + " %s ( group %d ) received out-of-synch; m_SystemStarter.get_id() is %d", + l_moduleName.c_str(), f_ModuleListIter->group_id + , m_SystemStarter.get_id()); + } + } else { + if ((*f_isGroupDoneFnc)(f_ModuleListIter->group_id)) { // LCOV_EXCL_BR_LINE 11: Gcov constraints (because exception-handling routes are automatically generated) // NOLINT(whitespace/line_length) + l_eStatus = (*f_groupDoneFnc)(hApp, f_ModuleListIter->group_id); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length) + } else if (IS_ZONE_SET(ZONE_INFO)) { // LCOV_EXCL_BR_LINE 6: Because the applicable variable cannot be changed from the external API (only evaluated by the initial value) + // LCOV_EXCL_START 6: Because the applicable variable cannot be changed from the external API (only evaluated by the initial value) + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + TEXT(__FUNCTION__, // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + " Group %d %s incomplete, m_SystemStarter.get_id() is %d", // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + f_ModuleListIter->group_id, f_sCompleteTypeText // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + , m_SystemStarter.get_id()); // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + char cBuf[100]; + sprintf(cBuf, "%s incomplete", f_sCompleteTypeText); // NOLINT + LogGroupModulesState(f_ModuleListIter->group_id, cBuf); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length) + // LCOV_EXCL_STOP + } + } + + const SMModuleState l_transition_state = InProgressStateToState(); // LCOV_EXCL_BR_LINE 11: Gcov constraints (because exception-handling routes are automatically generated) // NOLINT(whitespace/line_length) + if (l_transition_state == f_moduleState) { // LCOV_EXCL_BR_LINE 6: As no other value is returned + if (have_all_services_start_completed(l_transition_state) == TRUE) { + if ((m_SMCurrentState == SS_SM_APPS_PRE_START_IN_PROGRESS) + || (m_SMCurrentState == SS_SM_APPS_PRE_STOP_IN_PROGRESS)) { + SMSetState(hApp, SS_SM_APPS_PRE_RUN_COMPLETE); // LCOV_EXCL_BR_LINE 11: Gcov constraints (because exception-handling routes are automatically generated) // NOLINT(whitespace/line_length) + } else if ((m_SMCurrentState == SS_SM_APPS_BACKGROUND_START_IN_PROGRESS) + || (m_SMCurrentState == SS_SM_APPS_BACKGROUND_STOP_IN_PROGRESS)) { + SMSetState(hApp, SS_SM_APPS_BACKGROUND_RUN_COMPLETE); // LCOV_EXCL_BR_LINE 11: Gcov constraints (because exception-handling routes are automatically generated) // NOLINT(whitespace/line_length) + } else { + SMSetState(hApp, SS_SM_APPS_START_COMPLETE); // LCOV_EXCL_BR_LINE 11: Gcov constraints (because exception-handling routes are automatically generated) // NOLINT(whitespace/line_length) + } + } + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::ModuleCompleteResponse( + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup OnStartRespMonitorTimeout +/// SM maintains timer to check if all modules sent start response to him whoever requires Start. +/// This timer is common to all modules. After timeout it checks the status of every module in group map. +/// If a module sent start and does not respond, SM will initiate error event logging followed by Soft Reset +/// \param [in] +/// +/// +/// \return EFrameworkunifiedStatus +/// Success ==> eFrameworkunifiedStatusOK +/// Failure ==> Other values +/////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CSystemManager::OnStartRespMonitorTimeout(HANDLE hApp) { // LCOV_EXCL_START 6: Because the condition cannot be set + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp); // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "from %s", FrameworkunifiedGetMsgSrc(hApp)); + + std::string l_ProcName; + BOOL l_isStartRespNotReceived = false; + + SetCmdHist("SM_TIMER_START_RESP_MONITOR_WAIT_TIMER", m_TimerCmdHist, + m_TimerHistIter, FrameworkunifiedGetMsgSrc(hApp)); + GroupLaunchMap::reverse_iterator l_grp_riter = m_MapProclaunchGrps.rbegin(); + ModuleLaunchList::reverse_iterator l_mod_riter; + + if (l_grp_riter == m_MapProclaunchGrps.rend()) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error: Group Map is Empty"); + } else { + // scan the group map in reverse order + for (; l_grp_riter != m_MapProclaunchGrps.rend(); l_grp_riter++) { + l_mod_riter = l_grp_riter->second.modules.rbegin(); + for (; l_mod_riter != l_grp_riter->second.modules.rend(); l_mod_riter++) { + // if a module sent start and not received response from module SM wait for "ModuleStartRespTimeout" + // and initiated error event + // logging followed by soft reset + + if (l_mod_riter->is_start_required) { + if (l_mod_riter->IsModuleState(MODULE_STATE_START_SENT)) { + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, + " Module [%s] did not respond(%s) to SM in allocated time [%d] sec", + l_mod_riter->name.c_str(), + l_mod_riter->ModuleStateStr().c_str(), + m_SMConfig.MCConfig.ModuleStartRespTimeOutSec); + l_isStartRespNotReceived = true; + l_ProcName.assign(l_mod_riter->name); + } + } + } + } + } + + if (true == l_isStartRespNotReceived) { + char l_cFormat[] = " Error. Module '%s' start response timeout."; + char l_cBuf[sizeof(l_cFormat) + MAX_NAME_SIZE_APP]; + snprintf(l_cBuf, sizeof(l_cBuf), l_cFormat, l_ProcName.c_str()); + TEXT(__FUNCTION__, l_cBuf); // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, l_cBuf); + + SMLoggingInfo l_loggingInfo; + l_loggingInfo.resetReason = e_SS_SM_CPU_RESET_REASON_GENERIC_ERR; + + // initate error event logging + l_eStatus = ErrorEventEnqueue(hApp, eErrorEventTypeStartRespFailed, + l_ProcName, eErrorEventResetTypeHard, l_loggingInfo); + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: StartRespFailed %s", l_ProcName.c_str()); + fprintf(stderr, "SS_SysManager/%s/Error: StartRespFailed %s\n", + __FUNCTION__, l_ProcName.c_str()); + LOG_ERROR_REC_HIST_IF_ERRORED(l_eStatus, // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length) + "ErrorEventEnqueue(eErrorEventTypeStartRespFailed)"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length) + } else { + FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, + " All modules returned Start Response."); + + l_eStatus = FrameworkunifiedSendChild(hApp, m_hHeartbeatThread.m_ThreadHdl, + SS_HEARTBEAT_AVAIL_CHECK_REQ, 0, NULL); + SS_ASERT(l_eStatus == eFrameworkunifiedStatusOK); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::OnStartRespMonitorTimeout(HANDLE hApp) +// LCOV_EXCL_STOP + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup OnShutdownCompleteMonitorTimeout +/// SM maintains timer to check if all modules sent start response to him whoever requires Start. +/// This timer is common to all modules. After timeout it checks the status of every module in group map. +/// If a module sent start and does not respond, SM will initiate error event logging followed by Soft Reset +/// \param [in] +/// +/// +/// \return EFrameworkunifiedStatus +/// Success ==> eFrameworkunifiedStatusOK +/// Failure ==> Other values +/////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CSystemManager::OnShutdownCompleteMonitorTimeout(HANDLE hApp) { + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp); // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error: Reset Timeout"); + + l_eStatus = SecureChipOff(); + if (eFrameworkunifiedStatusOK != l_eStatus) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error: SecureChipOff Failed"); + } + + m_ResetFactor = PSM_FACTOR_AGL_WITH_HISTORY; + + l_eStatus = perform_force_reset(hApp); + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::OnShutdownCompleteMonitorTimeout(HANDLE hApp) + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup start_all_modules_of_group +/// Send START to all modules of the given group +/// +/// \param [in] +/// +/// +/// \return EFrameworkunifiedStatus +/// Success ==> eFrameworkunifiedStatusOK +/// Failure ==> Other values +/////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CSystemManager::start_all_modules_of_group(HANDLE hApp, UI_32 f_ui32GroupNumber) { + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + GroupLaunchMapIter l_GroupIterator = m_MapProclaunchGrps.find( + f_ui32GroupNumber); + if (l_GroupIterator == m_MapProclaunchGrps.end()) { // LCOV_EXCL_BR_LINE 6: Because the condition cannot be set + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, + __FUNCTION__ + , " Error: Group %d not found; 'm_MapProclaunchGrps' is empty", + f_ui32GroupNumber); + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_eStatus = eFrameworkunifiedStatusInvldParam; // LCOV_EXCL_LINE 6: Because the condition cannot be set + } else { + T_SS_SM_START_DataStructType f_startupData(m_StartUpReason, + m_PowerType_to_SSBoolEnumMap[m_Wake.powerupType], + m_DataResetMode, m_startUpConfirmationMsg.securityStatus, + m_startUpConfirmationMsg.wakeupType, m_DramBackupStatus, + m_ResetStatus, m_ResetCount); + + UI_32 l_numModulesMessaged = 0; + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, + " Attempting to send Start Requests to Group %d/'%s'", + f_ui32GroupNumber, l_GroupIterator->second.name.c_str()); + + for (ModuleLaunchListIter l_ModuleListIterator = + l_GroupIterator->second.modules.begin(); + l_ModuleListIterator != l_GroupIterator->second.modules.end(); + l_ModuleListIterator++) { + // + // Every branch below must ZONE_INFO log how it dispenses w/ + // the module. + // Note: ModuleLaunchParams::SetModuleState() performs that + // ZONE_INFO logging internally. + if (!l_ModuleListIterator->is_start_required) { + if (FRAMEWORKUNIFIED_NS_NPSERVICE == l_ModuleListIterator->name) { + const SMModuleState l_transition_state = InProgressStateToState(); // LCOV_EXCL_BR_LINE 11:Gcov constraints (because exception-handling routes are automatically generated) + l_ModuleListIterator->SetModuleState(l_transition_state); // LCOV_EXCL_BR_LINE 11:Gcov constraints (because exception-handling routes are automatically generated) + } else { + // Not an error + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, + " %s 'is_start_required' is False;" + " leaving state as '%s'", + l_ModuleListIterator->name.c_str(), + l_ModuleListIterator->ModuleStateStr().c_str()); + } + l_eStatus = eFrameworkunifiedStatusOK; + } else if (NULL == l_ModuleListIterator->hsession) { // LCOV_EXCL_BR_LINE 6: hsession can not be null. + l_eStatus = eFrameworkunifiedStatusOK; // Log a message. But its not a failure + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, " Warning: NULL == hsession;" + " %s not connected yet", + l_ModuleListIterator->name.c_str()); + } else { + switch (l_ModuleListIterator->GetModuleState()) { // LCOV_EXCL_BR_LINE 6: As not all cases can be passed through + case MODULE_STATE_INVALID: + case MODULE_STATE_SKIPPED: + case MODULE_STATE_LAUNCH_FAILED: + // LCOV_EXCL_START 6: Because the state of the corresponding variable cannot be set + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_eStatus = eFrameworkunifiedStatusOK; // Log a message. But its not a failure + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, + " %s is %s, NOT sending system_manager protocol message", + l_ModuleListIterator->name.c_str(), + l_ModuleListIterator->ModuleStateStr().c_str()); + break; + // LCOV_EXCL_STOP + + case MODULE_STATE_START_SENT: + case MODULE_STATE_START_PRE_SENT: + case MODULE_STATE_STOP_PRE_SENT: + case MODULE_STATE_START_BACKGROUND_SENT: + case MODULE_STATE_STOP_BACKGROUND_SENT: + l_eStatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, + " %s is %s, NOT sending system_manager protocol message", + l_ModuleListIterator->name.c_str(), + l_ModuleListIterator->ModuleStateStr().c_str()); + l_numModulesMessaged++; + break; + + case MODULE_STATE_LAUNCHING: + case MODULE_STATE_LAUNCHED: + // LCOV_EXCL_START 6: Because the state of the corresponding variable cannot be set + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_eStatus = eFrameworkunifiedStatusOK; // Log a message. But its not a failure + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, + " %s is %s, NOT sending system_manager protocol message", + l_ModuleListIterator->name.c_str(), + l_ModuleListIterator->ModuleStateStr().c_str()); + break; + // LCOV_EXCL_STOP + + case MODULE_STATE_CONNECTED: + case MODULE_STATE_STARTED: + case MODULE_STATE_START_FAILED: + case MODULE_STATE_STOP_FAILED: + case MODULE_STATE_STOP_SENT: + case MODULE_STATE_STOPPED: + case MODULE_STATE_STARTED_PRE: + case MODULE_STATE_START_PRE_FAILED: + case MODULE_STATE_STOPPED_PRE: + case MODULE_STATE_STOP_PRE_FAILED: + case MODULE_STATE_STARTED_BACKGROUND: + case MODULE_STATE_START_BACKGROUND_FAILED: + case MODULE_STATE_STOPPED_BACKGROUND: + case MODULE_STATE_STOP_BACKGROUND_FAILED: + { + const UI_32 l_iCmd = InProgressStateToSendMsg(); // LCOV_EXCL_BR_LINE 11:Gcov constraints (because exception-handling routes are automatically generated) + if (l_iCmd != SS_SYSTEM_MANAGER_PROTOCOL_ENDING_INDEX) { // LCOV_EXCL_BR_LINE 6: Excluded due to value never returned at present + // LCOV_EXCL_BR_START 15: Excluded due to inlined functions + CALL_AND_LOG_STATUS_IF_ERRORED(l_ModuleListIterator->SendMsgAndUpdateState(l_iCmd, &f_startupData)); + // LCOV_EXCL_BR_STOP 15: Excluded due to inlined functions + l_numModulesMessaged++; + } + } + break; + // default: Don't code a 'default' here - let the compiler + // detect when the set of module_state enumerations changes - + // then the System Service's System Manager maintainer will + // automagically know to update this switch statement. + } + } + } + + if (0 == l_numModulesMessaged) { + LogGroupModulesState(f_ui32GroupNumber, " Warning: NO modules were sent system_manager protocol message"); // LCOV_EXCL_BR_LINE 11:Gcov constraints (because exception-handling routes are automatically generated) + + char l_cBuf[100]; + snprintf(l_cBuf, sizeof(l_cBuf), "ProcessGroupAsStarted(%d)", l_GroupIterator->second.id); + l_eStatus = ProcessGroupAsStarted(hApp, l_GroupIterator); + LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, l_cBuf); // LCOV_EXCL_BR_LINE 6: Because the condition cannot be set + } else { + m_GroupLaunchTimer->StartTimer( + m_aTimerIDs[eSM_TIMER_CLIENT_START_MONITOR], + SS_CLIENT_START_MONITOR_TIMER_CONFIG, 0, 0, 0); + } + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::start_all_modules_of_group(HANDLE hApp, UI_32 f_ui32GroupNumber) + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup start_all_modules_of_group +/// mark the specified group as started. If there is another group to start, +/// do so, else send Start Complete Response to the Start Requester. +/// +/// \param [in] +/// +/// +/// \return EFrameworkunifiedStatus +/// Success ==> eFrameworkunifiedStatusOK +/// Failure ==> Other values +/////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CSystemManager::ProcessGroupAsStarted(HANDLE hApp, UI_32 f_groupId) { + EFrameworkunifiedStatus l_eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + GroupLaunchMapIter l_GroupIterator = m_MapProclaunchGrps.find(f_groupId); + if (l_GroupIterator == m_MapProclaunchGrps.end()) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + " Error: Group %d not found; 'm_MapProclaunchGrps' is empty", f_groupId); + l_eStatus = eFrameworkunifiedStatusInvldParam; + } else { + l_eStatus = ProcessGroupAsStarted(hApp, l_GroupIterator); + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::ProcessGroupAsStarted( HANDLE hApp, UI_32 f_groupId ) + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup start_all_modules_of_group +/// mark the specified group as started. If there is another group to start, +/// do so, else send Start Complete Response to the Start Requester. +/// +/// \param [in] +/// +/// +/// \return EFrameworkunifiedStatus +/// Success ==> eFrameworkunifiedStatusOK +/// Failure ==> Other values +/////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CSystemManager::ProcessGroupAsStarted(HANDLE hApp, + GroupLaunchMapIter f_GroupIterator) { + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + UI_32 l_groupID = m_SystemStarter.get_id(); + + + m_GroupLaunchTimer->StopTimer(m_aTimerIDs[eSM_TIMER_CLIENT_START_MONITOR]); + + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, + " Group %d/%s start completed, m_SystemStarter.get_id() is %d", + f_GroupIterator->second.id, f_GroupIterator->second.name.c_str(), + l_groupID); + + if (f_GroupIterator->second.id != l_groupID) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, + __FUNCTION__ + , " The just-started group ( %d/%s ) is not the current Active " + " Group ( %d ); not starting next group's modules", + f_GroupIterator->second.id, + f_GroupIterator->second.name.c_str(), l_groupID); + } else { + if ((m_SMCurrentState == SS_SM_APPS_START_IN_PROGRESS) + || (m_SMCurrentState == SS_SM_APPS_PRE_START_IN_PROGRESS) + || (m_SMCurrentState == SS_SM_APPS_BACKGROUND_START_IN_PROGRESS)) { + // check if WakeUp Level has been achieved + if (m_SystemStarter.is_end() == FALSE) { + // Start modules from next group + l_groupID = m_SystemStarter.advance_id(); // LCOV_EXCL_BR_LINE 11:Gcov constraints (because exception-handling routes are automatically generated) + char l_cBuf[100] = {0}; + snprintf(l_cBuf, sizeof(l_cBuf), "start_all_modules_of_group(%u)", l_groupID); + l_eStatus = start_all_modules_of_group(hApp, l_groupID); // LCOV_EXCL_BR_LINE 11:Gcov constraints (because exception-handling routes are automatically generated) + LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, l_cBuf); // LCOV_EXCL_BR_LINE 6: Because the condition cannot be set + } + } else if ((m_SMCurrentState == SS_SM_APPS_PRE_STOP_IN_PROGRESS) + || (m_SMCurrentState == SS_SM_APPS_BACKGROUND_STOP_IN_PROGRESS)) { + if (m_SystemStarter.is_begin() == FALSE) { + // Stop modules from next group + l_groupID = m_SystemStarter.decrement_id(); // LCOV_EXCL_BR_LINE 11:Gcov constraints (because exception-handling routes are automatically generated) + char l_cBuf[100] = {0}; + snprintf(l_cBuf, sizeof(l_cBuf), "stop_all_modules_of_group(%u)", l_groupID); + l_eStatus = start_all_modules_of_group(hApp, l_groupID); // LCOV_EXCL_BR_LINE 11:Gcov constraints (because exception-handling routes are automatically generated) + LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, l_cBuf); // LCOV_EXCL_BR_LINE 6: Because the condition cannot be set + } + } else { + // MISRA C++-2008 Rule 6-4-2 + // NOP + } + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::ProcessGroupAsStarted( GroupLaunchMapIter f_GroupIterator ) + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup calculate_max_shutdown_time +/// Calculate maximum shutdown time of apps critical to shutdown +/// from the launch group map +/// +/// \param [in] +/// +/// \return UI_32 +/// Max Value of critical shutdown apps shutdown time +/////////////////////////////////////////////////////////////////////////////// +UI_32 CSystemManager::calculate_max_shutdown_time() { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + UI_32 l_MaxShutdownTimeValue = 0; + std::string moduleName; + + GroupLaunchMapIter l_GroupIterator = m_MapProclaunchGrps.begin(); + for (; l_GroupIterator != m_MapProclaunchGrps.end(); l_GroupIterator++) { + ModuleLaunchListIter l_ModuleListIterator = + l_GroupIterator->second.modules.begin(); + for (; l_ModuleListIterator != l_GroupIterator->second.modules.end(); + l_ModuleListIterator++) { + if (l_ModuleListIterator->shutdown_critical) { + if (l_MaxShutdownTimeValue < l_ModuleListIterator->shutdown_wait_time) { + moduleName = l_ModuleListIterator->name; + l_MaxShutdownTimeValue = l_ModuleListIterator->shutdown_wait_time; + } + } + } + } + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " Max time: Module %s, time %d s", + moduleName.c_str(), l_MaxShutdownTimeValue); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_MaxShutdownTimeValue; +} + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup OnShutdownModulesRequest +/// Send Shutdown to all modules in reverse order of group +/// +/// \param [in] +/// +/// \return EFrameworkunifiedStatus +/// Success ==> eFrameworkunifiedStatusOK +/// Failure ==> Other values +/////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CSystemManager::OnShutdownModulesRequest(HANDLE hApp) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; + + FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, + " Received from %s, m_SystemStarter.get_id() is %d", + FrameworkunifiedGetMsgSrc(hApp) + , m_SystemStarter.get_id()); + + FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "m_SystemStarter.get_id() is %d", m_SystemStarter.get_id()); + + SetCmdHist("SS_SM_SHUTDOWN_MODULES", m__CWORD56_CmdHist, m__CWORD56_HistIter, FrameworkunifiedGetMsgSrc(hApp)); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length) + + Pwr_ServiceSetInterface l_tServiceSetIf; + // ReadMsg(): * + // Check hApp ptr, msg size, msg reception, read msg if all ok. * + if (eFrameworkunifiedStatusOK != (l_eStatus = ReadMsg < Pwr_ServiceSetInterface > (hApp, l_tServiceSetIf))) { // LCOV_EXCL_BR_LINE 4: nsfw error + // LCOV_EXCL_START 4: nsfw error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + LOG_ERROR("ReadMsg()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + // LCOV_EXCL_STOP + } else { + BOOL isImmShutdown = FALSE; + + // If the Shutdown is not completed after the Shutdown is requested, it is forcibly reset. + m_GroupLaunchTimer->StartTimer( + m_aTimerIDs[eSM_TIMER_SHUTDOWN_COMPLETE_MONITOR], + SM_SHUTDOWN_COMPLETE_MONITOR_TIMEOUT, 0, 0, 0); + + if (m_isImmResetReq) { + FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, " ImmReset"); + isImmShutdown = TRUE; + } + + switch (l_tServiceSetIf.data.shutdownRequestMsg.lastUserMode) { + case epsumINVALID: + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + " Error: shutdownRequestMsg.lastUserMode == epsumINVALID"); + l_eStatus = eFrameworkunifiedStatusInvldParam; + break; + + case epsumOFF: + case epsumON: { + switch (m_SMCurrentState) { + case SS_SM_READY_TO_LAUNCH_APP: + case SS_SM_APPS_LAUNCH_IN_PROGRESS: + case SS_SM_APPS_LAUNCHED_READY_TO_START: + isImmShutdown = TRUE; + case SS_SM_APPS_START_COMPLETE: + case SS_SM_APPS_START_IN_PROGRESS: + case SS_SM_APPS_PRE_START_IN_PROGRESS: + case SS_SM_APPS_PRE_STOP_IN_PROGRESS: + case SS_SM_APPS_PRE_RUN_COMPLETE: + case SS_SM_APPS_BACKGROUND_START_IN_PROGRESS: + case SS_SM_APPS_BACKGROUND_STOP_IN_PROGRESS: + case SS_SM_APPS_BACKGROUND_RUN_COMPLETE: + + if (l_tServiceSetIf.data.shutdownRequestMsg.shutdownTrigger == + epssdmsdtIGN_OFF) { + m_ResetCount = 0; + if (PowerHalSetResetInfo(AGL_RESET_COUNTER, m_ResetCount)) { // LCOV_EXCL_BR_LINE 11:Gcov constraints (because exception-handling routes are automatically generated) + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Could not back up m_ResetCount(%lu) to power_hal", m_ResetCount); + } + + if (PowerHalSetResetInfo(AGL_ERRLOG_COUNTER, 0)) { // LCOV_EXCL_BR_LINE 11:Gcov constraints (because exception-handling routes are automatically generated) + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Could not reset AGL_ERRLOG_COUNTER"); + } + } + if (!m_isPrevErrEventCompleted + || ((!((m_SMCurrentState == SS_SM_APPS_START_COMPLETE) + || (m_SMCurrentState == SS_SM_APPS_PRE_RUN_COMPLETE) + || (m_SMCurrentState == SS_SM_APPS_BACKGROUND_RUN_COMPLETE))) + && (l_tServiceSetIf.data.shutdownRequestMsg.shutdownTrigger + == epssdmsdtIGN_OFF + || l_tServiceSetIf.data.shutdownRequestMsg.shutdownTrigger + == epssdmsdtNORMAL_RESET))) { + FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "shutdown pending"); + if (!m_dqDeferMsg.empty()) { + SS_ASERT(0); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + } else { + SM_POWER_EVENT_INFO deferMsg(SS_SM_SHUTDOWN_MODULES, l_tServiceSetIf); + m_dqDeferMsg.push(deferMsg); + } + } else { + // The shutdownTrigger has already been validated by + // Power::OnShutdownRequestMsg() + m_shutdownTrigger = l_tServiceSetIf.data.shutdownRequestMsg.shutdownTrigger; + m_lastUserMode = l_tServiceSetIf.data.shutdownRequestMsg.lastUserMode; + + // Notify services ShutDownTrigger the FrameworkunifiedOnStop, if dataResetMode is configured + // When using FastSleep, be aware that it may be overwritten here + switch (m_DataResetMode) { + case e_SS_SM_DATA_RESET_MODE_FACTORY: + m_shutdownTrigger = epssdmsdtFACTORY_DATA_RESET; + break; + case e_SS_SM_DATA_RESET_MODE_USER: + m_shutdownTrigger = epssdmsdtUSER_DATA_RESET; + break; + default: + break; + } + + if (isImmShutdown) { + m_GroupLaunchTimer->StopTimer(m_aTimerIDs[eSM_TIMER_GROUP_LAUNCH_WAIT_TIMER]); + + // Do not use m_shutdownTrigger because it is updated on DataReset + switch (l_tServiceSetIf.data.shutdownRequestMsg.shutdownTrigger) { + case epssdmsdtGENERIC_ERROR_RESET: + case epssdmsdtFATAL_ERROR_RESET: + CALL_AND_LOG_STATUS((*m_pfStopCompleteHandler)(hApp)); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + break; + default: + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, + " Warning: Received a Shutdown command while in " + "the '%s' state - returning Shutdown " + "Response msg now", + GetStr(m_SMCurrentState).c_str()); + + CALL_AND_LOG_STATUS(SendShutdownResponseMessage(hApp)); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + break; + } + + } else { + InitiateAllGroupsShutdown(hApp); + } + } + break; + + case SS_SM_APPS_STOPPING_AT__CWORD56__REQ: + case SS_SM_APPS_STOPPING_AT_INTERNAL_REQ: + case SS_SM_WAITING_FOR_CRITICAL_APPS_AT__CWORD56__REQ: + case SS_SM_WAITING_FOR_CRITICAL_APPS_AT_INTERNAL_REQ: + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, + " Warning: Received a Shutdown command while already in " + "the '%s' state !!!", + GetStr(m_SMCurrentState).c_str()); + break; + } // End switch ( m_SMCurrentState ) + break; + } // End case epsumOFF | epsumON + } // End switch (m_lastUserMode ) + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::OnShutdownModulesRequest( HANDLE hApp ) + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup SendSystemModeInfoResponse +/// send SystemModeInfo to +/// _CWORD56_ ( via Power Service-> PSMShadow ) as an IPC 'Start Notification' +/// message, informing _CWORD56_ of the startup state of the _CWORD102_. +/// +/// \param [in] HANDLE hApp +/// +/// \return EFrameworkunifiedStatus +/// Success ==> eFrameworkunifiedStatusOK +/// Failure ==> Other values +/////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CSystemManager::SendSystemModeInfoResponse(HANDLE hApp, EPWR_STARTUP_STAGE_TYPE f_startupStage) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; + SystemModeInfo l_SystemModeInfo; + + memcpy(&l_SystemModeInfo, &m_SystemModeInfo, sizeof(l_SystemModeInfo)); + + FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "stage:%d", f_startupStage); + l_SystemModeInfo.startupStage = f_startupStage; + + l_eStatus = FrameworkunifiedSendMsg(m_hPowerServiceSession, SS_SM_SYSTEM_MODE_INFO_RSPN, + sizeof(l_SystemModeInfo), (PVOID) & l_SystemModeInfo); + + if (eFrameworkunifiedStatusOK != l_eStatus) { // LCOV_EXCL_BR_LINE 4: NSFW error case. + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + " Error: SendSystemModeInfoResponse(%s) errored: 0x%X", + GetStr(l_SystemModeInfo.startupStage).c_str(), l_eStatus); + } else { + // LCOV_EXCL_START 4: NSFW error case. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, + " SendSystemModeInfoResponse(%s) successful", + GetStr(l_SystemModeInfo.startupStage).c_str()); + // LCOV_EXCL_STOP + } + + LOG_STATUS(l_eStatus, "FrameworkunifiedSendMsg(SS_SM_SYSTEM_MODE_INFO_RSPN)"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::SendSystemModeInfoResponse( HANDLE hApp ) + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup OnSystemModeInfoRequest +/// Handle System Mode Info request. Send System Mode Info read from NVM +/// +/// \param [in] HANDLE hApp +/// +/// \return EFrameworkunifiedStatus +/// Success ==> eFrameworkunifiedStatusOK +/// Failure ==> Other values +/////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CSystemManager::OnSystemModeInfoRequest(HANDLE hApp) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; + INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp); // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "from %s", FrameworkunifiedGetMsgSrc(hApp)); + m_isRcvModeInfo = TRUE; + + SetCmdHist("SS_SM_SYSTEM_MODE_INFO_REQ", m__CWORD56_CmdHist, m__CWORD56_HistIter, FrameworkunifiedGetMsgSrc(hApp)); + + if (m_SystemModeInfo.startupStage == epssusfINVALID) { + // Transitioning to SYSTEM_SERVICES_STARTED if startupStage == INVALID + m_SystemModeInfo.startupStage = epssusSYSTEM_SERVICES_STARTED; + } + + l_eStatus = SendSystemModeInfoResponse(hApp, epssusSYSTEM_SERVICES_STARTED); + LOG_STATUS(l_eStatus, "SendSystemModeInfoResponse()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + + if (TRUE == m_isRstPending) { + ESMCpuResetReason l_resetReason = m_rstPendingInfo.resetReason; + std::string l_messageStr = m_rstPendingInfo.messageStr; + + m_isRstPending = FALSE; + m_rstPendingInfo.resetReason = e_SS_SM_CPU_RESET_REASON_INVALID; + memset(m_rstPendingInfo.messageStr, 0, sizeof(m_rstPendingInfo.messageStr)); + + l_eStatus = PerformCpuReset(hApp, l_resetReason, l_messageStr); + LOG_STATUS(l_eStatus, "PerformCpuReset()"); // LCOV_EXCL_BR_LINE 6: Because it is executed only once and cannot see all branches + } + + if (m_SystemModeInfo.startupStage == epssusALL_SERVICES_LAUNCHED) { + // If startupStage == ALL_SERVICES_LAUNCHED + // Notify here because Launch of all SVCs is completed first. + l_eStatus = SendSystemModeInfoResponse(hApp, epssusALL_SERVICES_LAUNCHED); + LOG_STATUS(l_eStatus, "SendSystemModeInfoResponse()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::OnSystemModeInfoRequest( HANDLE hApp ) + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup OnInitCompReportCallback +/// Handle InitComp report. +/// +/// \param [in] HANDLE hApp +/// +/// \return EFrameworkunifiedStatus +/// Success ==> eFrameworkunifiedStatusOK +/// Failure ==> Other values +/////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CSystemManager::OnInitCompReportCallback(HANDLE hApp) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; + INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp); // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "from %s", FrameworkunifiedGetMsgSrc(hApp)); + + SetCmdHist("SS_SM_INITCOMP_REP", m__CWORD56_CmdHist, m__CWORD56_HistIter, FrameworkunifiedGetMsgSrc(hApp)); + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::OnInitCompReportCallback( HANDLE hApp ) + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup have_all_services_start_completed +/// check if state of all services is MODULE_STATE_STARTED +/// +/// \param [in] +/// +/// +/// \return BOOL +/// Success ==> TRUE +/// Failure ==> FALSE +/////////////////////////////////////////////////////////////////////////////// +BOOL CSystemManager::have_all_services_start_completed(const SMModuleState f_moduleState) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + BOOL bIsStartCompleted = TRUE; + SMModuleState l_failedState = MODULE_STATE_INVALID; + + switch (f_moduleState) { + case MODULE_STATE_STARTED: + l_failedState = MODULE_STATE_START_FAILED; + break; + case MODULE_STATE_STARTED_PRE: + l_failedState = MODULE_STATE_START_PRE_FAILED; + break; + case MODULE_STATE_STOPPED_PRE: + l_failedState = MODULE_STATE_STOP_PRE_FAILED; + break; + case MODULE_STATE_STARTED_BACKGROUND: + l_failedState = MODULE_STATE_START_BACKGROUND_FAILED; + break; + case MODULE_STATE_STOPPED_BACKGROUND: + l_failedState = MODULE_STATE_STOP_BACKGROUND_FAILED; + break; + default: + bIsStartCompleted = FALSE; + break; + } + if (l_failedState != MODULE_STATE_INVALID) { + GroupLaunchMapIter l_GroupIterator = m_MapProclaunchGrps.begin(); + for (; l_GroupIterator != m_MapProclaunchGrps.end(); l_GroupIterator++) { + ModuleLaunchListIter l_ModuleListIterator = l_GroupIterator->second.modules.begin(); + for (; l_ModuleListIterator != l_GroupIterator->second.modules.end(); l_ModuleListIterator++) { + if ((l_ModuleListIterator->is_start_required == TRUE) + && ((l_ModuleListIterator->IsModuleState(f_moduleState) == FALSE) // LCOV_EXCL_BR_LINE 11:Gcov constraints (because exception-handling routes are automatically generated) + && (l_ModuleListIterator->IsModuleState(MODULE_STATE_SKIPPED) == FALSE) // LCOV_EXCL_BR_LINE 11:Gcov constraints (because exception-handling routes are automatically generated) + && (l_ModuleListIterator->IsModuleState(l_failedState) == FALSE))) { // LCOV_EXCL_BR_LINE 11:Gcov constraints (because exception-handling routes are automatically generated) + // Allow _SKIPPED/START_FAILED for StartRespMonitor conditions + bIsStartCompleted = FALSE; + break; + } + } + } + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return bIsStartCompleted; +} + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup is_critical_service_stopped +/// +/// +/// \param [in] +/// +/// +/// \return BOOL +/// Success ==> TRUE +/// Failure ==> FALSE +/////////////////////////////////////////////////////////////////////////////// +BOOL CSystemManager::is_service_shutdown_ready(ModuleLaunchListIter &modIte) { + if (((modIte->shutdown_critical && modIte->is_start_required) + || (modIte->name == FRAMEWORKUNIFIED_NS_NPSERVICE)) + && modIte->IsModuleState(MODULE_STATE_STOPPED) == FALSE) { + // Not shutdown_ready if NPP or shutdown_critical services are not STOPPED. + return FALSE; + } + return TRUE; +} + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup have_critical_services_stopped +/// check if state of all critical services is MODULE_STATE_STOPPED +/// +/// \param [in] +/// +/// +/// \return BOOL +/// Success ==> TRUE +/// Failure ==> FALSE +/////////////////////////////////////////////////////////////////////////////// +BOOL CSystemManager::have_critical_services_stopped() { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + uint numStoppingModules = 0; + + GroupLaunchMapIter l_GroupIterator = m_MapProclaunchGrps.begin(); + for (; l_GroupIterator != m_MapProclaunchGrps.end(); l_GroupIterator++) { + ModuleLaunchListIter l_ModuleListIterator = l_GroupIterator->second.modules.begin(); + for (; l_ModuleListIterator != l_GroupIterator->second.modules.end(); l_ModuleListIterator++) { + if (l_ModuleListIterator->IsModuleState(MODULE_STATE_STOP_SENT) + && l_ModuleListIterator->shutdown_critical) { + numStoppingModules++; + } + } + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return (numStoppingModules == 0); +} + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup perform_force_reset +/// +/// +/// \param [in] +/// +/// +/// \return EFrameworkunifiedStatus +/// Success ==> eFrameworkunifiedStatusOK +/// Failure ==> Other values +/////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CSystemManager::perform_force_reset(HANDLE hApp) { + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "+"); + + // Since initialization must be performed by the PSMs during FactReset, do not NaviDet them as much as possible. + if (e_SS_SM_DATA_RESET_MODE_FACTORY == m_DataResetMode) { + fprintf(stderr, + "SS_SysManager/%s/NO NAVIDET!! but SendShutdownComp for FactReset\n", __FUNCTION__); + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "NO NAVIDET!! but SendShutdownComp for FactReset"); + CALL_AND_LOG_STATUS(send_shutdown_complete_response(hApp)); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + sleep(60); + } else if (access("/nv/BS/ss/system_manager/rwdata/ss_debug", F_OK) == 0) { + fprintf(stderr, "SS_SysManager/%s/NO NAVIDET!! but SendShutdownComp\n", __FUNCTION__); + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "NO NAVIDET!! but SendShutdownComp"); + CALL_AND_LOG_STATUS(send_shutdown_complete_response(hApp)); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + sleep(60); + } + + fflush(stderr); + usleep(100 * 1000); + + if (0 == PsmNaviResetPower(hApp, m_ResetFactor)) { // LCOV_EXCL_BR_LINE 200: power_hal if, can not to be error. + SS_ASERT_ERRNO(0); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + } else { + usleep(300 * 1000); + fprintf(stderr, "SS_SysManager/%s/Error: Not Reset !!!\n", __FUNCTION__); + l_eStatus = eFrameworkunifiedStatusFail; + } + + send_shutdown_complete_response(hApp); // Try to NAVI_RESET even if ignored + + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "-"); + return l_eStatus; +} + +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup send_shutdown_complete_response +/// +/// +/// \param [in] +/// +/// +/// \return EFrameworkunifiedStatus +/// Success ==> eFrameworkunifiedStatusOK +/// Failure ==> Other values +/////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CSystemManager::send_shutdown_complete_response(HANDLE hApp) { + EFrameworkunifiedStatus l_eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + CALL_AND_LOG_STATUS(ResetModulesStateToConnected(hApp)); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + + SMSetState(hApp, SS_SM_APPS_LAUNCHED_READY_TO_START); + // m_ActiveGroupId = SS_SM_INITIAL_GROUP; + + // all the modules have stopped, send Shutdown Response to Power Service + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, + " All critical services have stopped, Active Group ID is now %d", + m_SystemStarter.get_id()); +#if 1 + CALL_AND_LOG_STATUS(SendShutdownResponseMessage(hApp)); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) +#else + // + // Normal, production flow is to call SendShutdownResponseMessage(), which + // sends the Shutdown Response message to the _CWORD56_, causing the _CWORD56_ to + // remove power from the _CWORD102_ before queued-up FRAMEWORKUNIFIEDLOG messages can be // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + // processed by SS_LoggerService. + // + // Optional development flow is to NOT call SendShutdownResponseMessage(), + // thus giving the _CWORD102_ time to process its FRAMEWORKUNIFIEDLOG messages. Since this is an // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + // abnormal, 'bad' condition of NOT sending a Shutdown Response message to + // the _CWORD56_, be very obvious about this state by displaying both + // compile-time and run-time warning messages. + // +#warning NOT calling SendShutdownResponseMessage(hApp) ! + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + " Warning: SendShutdownResponseMessage( hApp ) " + "#def'f out; ShutdownResponse NOT sent to _CWORD56_"); +#endif + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} + +/////////////////////////////////////////////////////////////////////////////// +/// +/////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CSystemManager::SendShutdownResponseMessage(HANDLE hApp) { + EFrameworkunifiedStatus l_eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + l_eStatus = FrameworkunifiedSendMsg(m_hPowerServiceSession, // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + SS_SM_SHUTDOWN_MODULES_CMPL_RSPN, 0, (PVOID) NULL); // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length) + "FrameworkunifiedSendMsg(PowerService,SS_SM_SHUTDOWN_MODULES_CMPL_RSPN)"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length) + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::SendShutdownResponseMessage( HANDLE hApp ) + + +PsmFactorT CSystemManager::GetResetFactor(PCSTR f_module_name, BOOL f_user_reset) { + PsmFactorT l_reset_factor = PSM_FACTOR_NONE; + EFrameworkunifiedStatus l_eStatus; + ModuleLaunchListIter l_moduleIter; + l_eStatus = GetModuleIterator(f_module_name, l_moduleIter); // LCOV_EXCL_BR_LINE 11:Gcov constraints (because exception-handling routes are automatically generated) + if (eFrameworkunifiedStatusOK != l_eStatus) { + LOG_ERROR("GetModuleIterator()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + } else { + l_reset_factor = GetResetFactor(l_moduleIter, f_user_reset); + } + return l_reset_factor; +} // End of PsmFactorT CSystemManager::GetResetFactor(PCSTR f_module_name) + + +PsmFactorT CSystemManager::GetResetFactor(const ModuleLaunchListIter f_module_iter, BOOL f_user_reset) { + PsmFactorT l_reset_factor; + if (f_module_iter->IsAGLUnit() == TRUE) { + if (f_module_iter->IsAGLResetHistoryDisable() == TRUE) { + l_reset_factor = PSM_FACTOR_AGL; + } else { + l_reset_factor = PSM_FACTOR_AGL_WITH_HISTORY; + } + } else { + if (f_module_iter->IsNonAGLResetHistoryDisable() == TRUE) { + l_reset_factor = PSM_FACTOR_TIER1; + } else { + l_reset_factor = PSM_FACTOR_TIER1_WITH_HISTORY; + } + } + + if (f_user_reset == TRUE) { + if ((l_reset_factor == PSM_FACTOR_AGL) || (l_reset_factor == PSM_FACTOR_TIER1)) { + l_reset_factor = PSM_FACTOR_USER; + } else { + l_reset_factor = PSM_FACTOR_USER_WITH_HISTORY; + } + } + return l_reset_factor; +} // End of PsmFactorT GetResetFactor(ModuleLaunchListIter & f_module_iter) +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup OnClientStopMonitorTimerExpiry +/// +/// +/// \param [in] +/// +/// +/// \return EFrameworkunifiedStatus +/// Success ==> eFrameworkunifiedStatusOK +/// Failure ==> Other values +/////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CSystemManager::OnClientStopMonitorTimerExpiry(HANDLE hApp) { + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " Received from group %d", m_SystemStarter.get_id()); + + SetCmdHist("SM_TIMER_CLIENT_STOP_MONITOR", m_TimerCmdHist, m_TimerHistIter, FrameworkunifiedGetMsgSrc(hApp)); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length) + + if ((m_SMCurrentState == SS_SM_WAITING_FOR_CRITICAL_APPS_AT__CWORD56__REQ) + || (m_SMCurrentState == SS_SM_WAITING_FOR_CRITICAL_APPS_AT_INTERNAL_REQ) + || m_SystemStarter.get_id() <= SS_SM_THIRD_GROUP) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: StopCompTimeout:gid:%d", m_SystemStarter.get_id()); + fprintf(stderr, "SS_SysManager/%s/Error: StopCompTimeout:gid:%d\n", __FUNCTION__, m_SystemStarter.get_id()); + + for (GroupLaunchMapIter l_GroupIterator = m_MapProclaunchGrps.begin(); + l_GroupIterator != m_MapProclaunchGrps.end(); + l_GroupIterator++) { + for (ModuleLaunchListIter l_ModuleListIterator = l_GroupIterator->second.modules.begin(); + l_ModuleListIterator != l_GroupIterator->second.modules.end(); + l_ModuleListIterator++) { + if (l_ModuleListIterator->group_id >= m_SystemStarter.get_id() + && is_service_shutdown_ready(l_ModuleListIterator) == FALSE) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: %s", l_ModuleListIterator->name.c_str()); + fprintf(stderr, "SS_SysManager/%s/Error: %s\n", __FUNCTION__, l_ModuleListIterator->name.c_str()); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length) + } + } + } + + if (!m_SystemStarter.is_begin()) { + // Continue termination processing to perform BackupManager termination processing. + m_SystemStarter.decrement_id(); + check_all_groups_have_stopped(hApp); + } else { + // DEAD CODE + fprintf(stderr, "SS_SysManager/%s:SVC stop timeout\n", __FUNCTION__); + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " SVC stop timeout"); + l_eStatus = CallStopCompleteHandler(hApp); + LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, "CallStopCompleteHandler( hApp )"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length) + } + } else { + // The current m_ActiveGroupId group just timed out. If possible, + // decrement it, and then see if there are more groups to send + // stop requests to. + if (!m_SystemStarter.is_begin()) { + m_SystemStarter.decrement_id(); + } + check_all_groups_have_stopped(hApp); + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::OnClientStopMonitorTimerExpiry( HANDLE hApp ) + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup check_all_groups_have_stopped +/// check that all the groups has stopped +/// +/// \param [in] +/// +/// +/// \return VOID +/////////////////////////////////////////////////////////////////////////////// +VOID CSystemManager::check_all_groups_have_stopped(HANDLE hApp) { + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; + UI_32 l_ActiveGroupId = m_SystemStarter.get_id(); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, + " m_SystemStarter.get_id() is %d, 'm_NPPStopSent' is '%s'" + , m_SystemStarter.get_id(), GetStr(m_NPPStopSent).c_str()); + + // send stop to next group in reverse order +// FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " m_NPPStopSent is %s", GetStr(m_NPPStopSent).c_str()); // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + if (!m_NPPStopSent) { + l_eStatus = stop_all_modules_of_group(hApp); + if (eFrameworkunifiedStatusOK != l_eStatus) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + " Error: stop_all_modules_of_group(%d) errored: %d/'%s'", + l_ActiveGroupId, l_eStatus, GetStr(l_eStatus).c_str()); + } + } else { // (m_ActiveGroupId < SS_SM_INITIAL_GROUP) + BOOL l_bIsDetectTimeout; + + if ((l_bIsDetectTimeout = !have_critical_services_stopped())) { + // If the Critical service is not terminated even when the final GROUP is completed, DUMP the applicable service and issue NAVI_DET. + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " FinalCriticalCheck"); + fprintf(stderr, "SS_SysManager/%s:FinalCriticalCheck\n", __FUNCTION__); // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + + for (GroupLaunchMapIter l_GroupIterator = m_MapProclaunchGrps.begin(); + l_GroupIterator != m_MapProclaunchGrps.end(); + l_GroupIterator++) { + for (ModuleLaunchListIter l_ModuleListIterator = l_GroupIterator->second.modules.begin(); + l_ModuleListIterator != l_GroupIterator->second.modules.end(); + l_ModuleListIterator++) { + if (is_service_shutdown_ready(l_ModuleListIterator) == FALSE) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: %s", + l_ModuleListIterator->name.c_str()); + fprintf(stderr, "SS_SysManager/%s/Error: %s\n", // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length) + __FUNCTION__, + l_ModuleListIterator->name.c_str()); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length) + } + } + } + fprintf(stderr, "SS_SysManager/%s:critical service no stop\n", __FUNCTION__); + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "critical service no stop"); + } + + CALL_AND_LOG_STATUS(CallStopCompleteHandler(hApp, l_bIsDetectTimeout)); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + + // In PastModel002, there was a transition to WAITING_FOR_CRITICAL_APPS in the following processing, but in _CWORD71_, + // the transition to WAITING_FOR_CRITICAL_APPS was eliminated by revising the termination processing. + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return; +} // End of VOID CSystemManager::check_all_groups_have_stopped( HANDLE hApp ) + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup MarkModuleStateStopped +/// Sets Module State to STOP COMPLETE +/// +/// \param [in] +/// +/// +/// \return EFrameworkunifiedStatus +/// Success ==> eFrameworkunifiedStatusOK +/// Failure ==> Other values +/////////////////////////////////////////////////////////////////////////////// + + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup OnNppStopComplete +/// Npp Stop Complete complete Response\Ack Handlers +/// +/// \param [in] +/// +/// +/// \return EFrameworkunifiedStatus +/// Success ==> eFrameworkunifiedStatusOK +/// Failure ==> Other values +/////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CSystemManager::OnNppStopComplete(HANDLE hApp) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; + INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp); // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "from %s", FrameworkunifiedGetMsgSrc(hApp)); + + SetCmdHist("NPS_NPP_STOP_ACK", m_SMCmdHist, m_SMHistIter, FrameworkunifiedGetMsgSrc(hApp)); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length) + + char l_cBuf[100]; + snprintf(l_cBuf, sizeof(l_cBuf), "ProcessModuleStopCompleteResponse(%s)", FRAMEWORKUNIFIED_NS_NPSERVICE); + l_eStatus = ProcessModuleStopCompleteResponse(hApp, FRAMEWORKUNIFIED_NS_NPSERVICE); + LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, l_cBuf); // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length) + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eFrameworkunifiedStatusOK; +} + +EFrameworkunifiedStatus CSystemManager::GetModuleIterator(PCSTR f_moduleName, ModuleLaunchListIter &f_moduleIter) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus; + + ModuleLaunchListIter l_moduleIter; +// static int l_numTimesEntered = 0 ; +// l_numTimesEntered++ ; +// FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__ // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) +// , " NTE %d: Looking for %s" +// , l_numTimesEntered +// , f_moduleName); + + BOOL l_bIsFound = FALSE; + for (GroupLaunchMapIter l_GroupIter = m_MapProclaunchGrps.begin(); + !l_bIsFound && l_GroupIter != m_MapProclaunchGrps.end(); + l_GroupIter++) { +// FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__ // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) +// , " NTE %d: Checking group %d/%s" +// , l_numTimesEntered +// , l_GroupIter->second.id +// , l_GroupIter->second.name.c_str()); + + for (l_moduleIter = l_GroupIter->second.modules.begin(); + !l_bIsFound && (l_moduleIter != l_GroupIter->second.modules.end()); + l_moduleIter++) { +// FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__ // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) +// , " NTE %d: Checking PCSTR '%s' against std::string '%s': %d, %s" +// , l_numTimesEntered +// , f_moduleName +// , l_moduleIter->name.c_str() +// , strcmp(l_moduleIter->name.c_str(), f_moduleName) +// , (0 == strcmp(l_moduleIter->name.c_str(), f_moduleName) ? "True" : "False")); + + l_bIsFound = + (0 == strcmp(l_moduleIter->name.c_str(), f_moduleName)); + if (l_bIsFound) { + f_moduleIter = l_moduleIter; +// FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) +//// " NTE %d:" +// " '%s' is in group %d/%s" +//// , l_numTimesEntered +// , f_moduleIter->name.c_str() +// , l_GroupIter->second.id +// , l_GroupIter->second.name.c_str()); + l_eStatus = eFrameworkunifiedStatusOK; + } + } + } + + if (!l_bIsFound) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, +// " NTE %d:" + " Error: '%s' is not in group map 'm_MapProclaunchGrps'" +// , l_numTimesEntered + , f_moduleName); + if (0 != strcmp(f_moduleName, SERVICE_SYSMANAGER)) { + SysMgrConfiguration m_launchConfig; + m_launchConfig.PrintAllInfo(m_MapProclaunchGrps); + } + l_eStatus = eFrameworkunifiedStatusDbRecNotFound; + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::GetModuleIterator( PCSTR f_moduleName + +BOOL CSystemManager::IsGroupStarted(UI_32 f_groupID) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + BOOL l_bIsStarted = TRUE; + + GroupLaunchMapIter l_GroupIter = m_MapProclaunchGrps.find(f_groupID); + if (l_GroupIter == m_MapProclaunchGrps.end()) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: Group Map Empty; was looking for group %d", f_groupID); + } else { + ModuleLaunchListIter l_ModuleListIter = l_GroupIter->second.modules.begin(); + const SMModuleState l_dest_state = InProgressStateToState(); // LCOV_EXCL_BR_LINE 11: Gcov constraints (because exception-handling routes are automatically generated) // NOLINT(whitespace/line_length) + if (l_dest_state != MODULE_STATE_INVALID) { + for (; l_ModuleListIter != l_GroupIter->second.modules.end(); l_ModuleListIter++) { + if (((l_ModuleListIter->IsModuleState(l_dest_state) == FALSE) // LCOV_EXCL_BR_START 11:Gcov constraints (because exception-handling routes are automatically generated) + && (l_ModuleListIter->IsModuleState(MODULE_STATE_START_FAILED) == FALSE) + && (l_ModuleListIter->IsModuleState(MODULE_STATE_START_PRE_FAILED) == FALSE) + && (l_ModuleListIter->IsModuleState(MODULE_STATE_STOP_PRE_FAILED) == FALSE) + && (l_ModuleListIter->IsModuleState(MODULE_STATE_START_BACKGROUND_FAILED) == FALSE) + && (l_ModuleListIter->IsModuleState(MODULE_STATE_STOP_BACKGROUND_FAILED) == FALSE) + && (l_ModuleListIter->IsModuleState(MODULE_STATE_STOP_FAILED) == FALSE)) + // LCOV_EXCL_BR_STOP 11:Gcov constraints (because exception-handling routes are automatically generated) + || ((l_ModuleListIter->is_start_required == TRUE) + // LCOV_EXCL_START 6: Because the value cannot be stored to make the condition true + && ((l_ModuleListIter->IsModuleState(MODULE_STATE_LAUNCHING) == TRUE) + || (l_ModuleListIter->IsModuleState(MODULE_STATE_CONNECTED) == TRUE) + || (l_ModuleListIter->IsModuleState(MODULE_STATE_LAUNCHED) == TRUE)))) { + // LCOV_EXCL_STOP 6: Because the value cannot be stored to make the condition true + l_bIsStarted = FALSE; + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " No: '%s' in group %d/%s is '%s'", l_ModuleListIter->name.c_str(), + l_GroupIter->second.id, l_GroupIter->second.name.c_str(), + l_ModuleListIter->ModuleStateStr().c_str()); + break; + } + } + } + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_bIsStarted; +} // End of BOOL CSystemManager::IsGroupStarted(UI_32 f_groupId) + +BOOL CSystemManager::IsGroupStopped(UI_32 f_groupID) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + BOOL l_bIsStopped = TRUE; + ModuleLaunchListIter l_ModuleListIter; + + GroupLaunchMapIter l_GroupIter = m_MapProclaunchGrps.find(f_groupID); + if (l_GroupIter == m_MapProclaunchGrps.end()) { + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, + " Warning: Group Map Empty; was looking for group %d", + f_groupID); + } else { + for (l_ModuleListIter = l_GroupIter->second.modules.begin(); + l_bIsStopped + && l_ModuleListIter != l_GroupIter->second.modules.end(); + l_ModuleListIter++) { + if (l_ModuleListIter->IsModuleState(MODULE_STATE_STOP_SENT)) { + l_bIsStopped = FALSE; + } + } + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_bIsStopped; +} // End of BOOL CSystemManager::IsGroupStopped(UI_32 f_groupId) + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup OnStopComplete +/// Shutdown complete Response\Ack Handlers +/// +/// \param [in] +/// +/// +/// \return EFrameworkunifiedStatus +/// Success ==> eFrameworkunifiedStatusOK +/// Failure ==> Other values +/////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CSystemManager::OnModuleStopCompleteResponse(HANDLE hApp) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusErrOther; + INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp); // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + + PCSTR l_moduleName = FrameworkunifiedGetMsgSrc(hApp); + + FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "from %s", l_moduleName); + SetCmdHist("SS_SM_STOP_COMPL_RSPN", m_SMCmdHist, m_SMHistIter, l_moduleName); + + char l_cBuf[100]; + snprintf(l_cBuf, sizeof(l_cBuf), "ProcessModuleStopCompleteResponse(%s)", l_moduleName); + l_eStatus = ProcessModuleStopCompleteResponse(hApp, l_moduleName); + LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, l_cBuf); // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length) + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::OnModuleStopCompleteResponse( HANDLE hApp ) + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup OnGetStartExtInfo +/// +/// \param [in] +/// +/// +/// \return EFrameworkunifiedStatus +/// Success ==> eFrameworkunifiedStatusOK +/// Failure ==> Other values +/////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CSystemManager::OnGetStartExtInfo(HANDLE hApp) { + EFrameworkunifiedStatus l_eStatus; + T_SS_SM_START_ExtDataStructType l_extInfo = { 0 }; + + SS_STATIC_ASERT(sizeof(T_SS_SM_START_ExtDataStructType) == SS_SM_START_EXT_INFO_SIZE); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+ "); + + SetCmdHist("SS_SM_GET_START_EXT_INFO", m_SMCmdHist, m_SMHistIter, FrameworkunifiedGetMsgSrc(hApp)); + + l_extInfo.isProgUpdated = + (m_ProgUpdateState & SS_SM_PROG_UPDATE_STATE_UPDATED) ? TRUE : FALSE; + l_extInfo.isMapUpdated = + (m_ProgUpdateState & SS_SM_PROG_UPDATE_STATE_MAP_UPDATED) ? TRUE : FALSE; // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length) + l_extInfo.isMapDiffUpdated = + (m_ProgUpdateState & SS_SM_PROG_UPDATE_STATE_MAPDIFF_UPDATED) ? TRUE : FALSE; // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length) + + ModuleLaunchListIter l_ModuleListIter; + + l_eStatus = GetModuleIterator(FrameworkunifiedGetMsgSrc(hApp), l_ModuleListIter); + if (eFrameworkunifiedStatusOK != l_eStatus) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: %s not found", FrameworkunifiedGetMsgSrc(hApp)); + } else { + switch (l_ModuleListIter->relaunch_status) { + case NotRelaunched: + l_extInfo.relaunchStatus = e_SS_SM_RELAUNCH_STATUS_NONE; + break; + case RelaunchSafe: + // LCOV_EXCL_START 6: Because the applicable variable cannot be changed from the external API (only evaluated by the initial value) + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_extInfo.relaunchStatus = e_SS_SM_RELAUNCH_STATUS_SAFE; + break; + case RelaunchErr: + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_extInfo.relaunchStatus = e_SS_SM_RELAUNCH_STATUS_ERR; + break; + default: + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + SS_ASERT(0); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + l_extInfo.relaunchStatus = e_SS_SM_RELAUNCH_STATUS_NONE; + break; + // LCOV_EXCL_STOP + } + } + + // Instead of sending Return Message, this function must call FrameworkunifiedSetSyncResponseData() + // because this request is sent by FrameworkunifiedInvokeSync() + l_eStatus = FrameworkunifiedSetSyncResponseData(hApp, &l_extInfo, sizeof(l_extInfo)); + LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedSetSyncResponseData()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::OnGetStartExtInfo( HANDLE hApp ) + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup OnGetStopExtInfo +/// +/// \param [in] +/// +/// +/// \return EFrameworkunifiedStatus +/// Success ==> eFrameworkunifiedStatusOK +/// Failure ==> Other values +/////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CSystemManager::OnGetStopExtInfo(HANDLE hApp) { + EFrameworkunifiedStatus l_eStatus; + T_SS_SM_STOP_ExtDataStructType l_extInfo = { 0 }; + + SS_STATIC_ASERT(sizeof(T_SS_SM_STOP_ExtDataStructType) == SS_SM_STOP_EXT_INFO_SIZE); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+ "); + + SetCmdHist("SS_SM_GET_STOP_EXT_INFO", m_SMCmdHist, m_SMHistIter, FrameworkunifiedGetMsgSrc(hApp)); + + l_extInfo.isProgUpdated = + (m_ProgUpdateState & SS_SM_PROG_UPDATE_STATE_UPDATED) ? TRUE : FALSE; + + // Instead of sending Return Message, this function must call FrameworkunifiedSetSyncResponseData() + // because this request is sent by FrameworkunifiedInvokeSync() + l_eStatus = FrameworkunifiedSetSyncResponseData(hApp, &l_extInfo, sizeof(l_extInfo)); + LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedSetSyncResponseData()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::OnGetStopExtInfo( HANDLE hApp ) + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup OnModuleStopCompleteNotification +/// +/// \param [in] +/// +/// +/// \return EFrameworkunifiedStatus +/// Success ==> eFrameworkunifiedStatusOK +/// Failure ==> Other values +/////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CSystemManager::OnModuleStopCompleteNotification(HANDLE hApp) { // LCOV_EXCL_START 6: Because the condition cannot be set + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + EFrameworkunifiedStatus l_eStatus; + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+ "); + INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp); // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "from %s", FrameworkunifiedGetMsgSrc(hApp)); + + ShutdownComplete l_shutdownNotif; /// \file frameworkunified_framework_types.h + // ReadMsg(): * + // Check hApp ptr, msg size, msg reception, read msg if all ok. * + // Report any errors found. * + // * + if (eFrameworkunifiedStatusOK != (l_eStatus = ReadMsg < ShutdownComplete > (hApp, l_shutdownNotif))) { + LOG_ERROR("ReadMsg()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + } else { + PCSTR l_moduleName = l_shutdownNotif.cServiceName; + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, + " '%s' 'Shutdown Complete Status' is 0x%X", l_moduleName, + l_shutdownNotif.eShutdownCompleteStatus); + + char l_cBuf[100]; + snprintf(l_cBuf, sizeof(l_cBuf), + "ProcessModuleStopCompleteResponse(%s)", l_moduleName); + l_eStatus = ProcessModuleStopCompleteResponse(hApp, l_moduleName); + LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, l_cBuf); // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length) + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::onmodulestopcompletenotification( HANDLE hApp ) +// LCOV_EXCL_STOP + +EFrameworkunifiedStatus CSystemManager::ProcessModuleStopCompleteResponse(HANDLE hApp, PCSTR f_moduleName) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus; + + ModuleLaunchListIter l_ModuleListIter; + l_eStatus = GetModuleIterator(f_moduleName, l_ModuleListIter); + if (eFrameworkunifiedStatusOK != l_eStatus) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: Module %s not found in Group Launch Map", f_moduleName); + } else { + switch (m_SMCurrentState) { + case SS_SM_READY_TO_LAUNCH_APP: + case SS_SM_APPS_LAUNCH_IN_PROGRESS: + case SS_SM_APPS_LAUNCHED_READY_TO_START: + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + " Error: Received from client while in " + "the '%s' state !!!", + GetStr(m_SMCurrentState).c_str()); + l_eStatus = eFrameworkunifiedStatusErrOther; + break; + + case SS_SM_APPS_STOPPING_AT__CWORD56__REQ: + case SS_SM_APPS_STOPPING_AT_INTERNAL_REQ: + case SS_SM_WAITING_FOR_CRITICAL_APPS_AT__CWORD56__REQ: + case SS_SM_WAITING_FOR_CRITICAL_APPS_AT_INTERNAL_REQ: + if (m_SystemStarter.get_id() == SS_SM_THIRD_GROUP) { + // Execute shutdown_critical services termination synchronization prior to CoreModule(backupManager termination processing + l_ModuleListIter->SetModuleState(MODULE_STATE_STOPPED); + if (have_critical_services_stopped()) { // Transition after all critical services have ended + ProcessGroupOnModuleStopResponse(hApp, m_SystemStarter.get_id()); + } + } else { + l_eStatus = ModuleCompleteResponse(hApp, l_ModuleListIter, + MODULE_STATE_STOPPED, + (SysMgrCbType3<CSystemManager, + &CSystemManager::IsGroupStopped>), + (SysMgrCbType2<CSystemManager, + &CSystemManager::ProcessGroupOnModuleStopResponse>), + "stop"); + } + break; + + case SS_SM_APPS_START_COMPLETE: + case SS_SM_APPS_START_IN_PROGRESS: + case SS_SM_APPS_PRE_RUN_COMPLETE: + case SS_SM_APPS_PRE_START_IN_PROGRESS: + case SS_SM_APPS_PRE_STOP_IN_PROGRESS: + case SS_SM_APPS_BACKGROUND_RUN_COMPLETE: + case SS_SM_APPS_BACKGROUND_START_IN_PROGRESS: + case SS_SM_APPS_BACKGROUND_STOP_IN_PROGRESS: + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + " Error: Received from client while in " + "the '%s' state !!!", + GetStr(m_SMCurrentState).c_str()); + l_eStatus = eFrameworkunifiedStatusErrOther; + break; + } // End switch ( m_SMCurrentState ) + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::ProcessModuleStopCompleteResponse( + +EFrameworkunifiedStatus CSystemManager::ProcessGroupOnModuleStopResponse(HANDLE hApp, UI_32 f_groupID) { + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + UI_32 l_ActiveGroupId = m_SystemStarter.get_id(); + + m_GroupLaunchTimer->StopTimer(m_aTimerIDs[eSM_TIMER_CLIENT_STOP_MONITOR]); + + if (f_groupID != l_ActiveGroupId) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, + " Group %d stop complete, but m_SystemStarter.get_id() is %d", + f_groupID + // , m_ActiveGroupId); // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + , l_ActiveGroupId); + } else { + if (!m_SystemStarter.is_begin()) { + m_SystemStarter.decrement_id(); + } + check_all_groups_have_stopped(hApp); + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::ProcessGroupOnModuleStopResponse( HANDLE hApp + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup stop_all_modules_of_group +/// Send SS_SM_STOP to all modules of the given group +/// +/// \param [in] +/// +/// +/// \return VOID +/////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CSystemManager::stop_all_modules_of_group(HANDLE hApp) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; + ModuleLaunchList::reverse_iterator l_revIter; + + UI_32 l_uiMaxGroupWaitTime_sec = 0; + UI_32 l_uiMaxGroupWaitTime_msec = 0; + UI_32 l_uiModuleWaitTime = 0; + + // GroupLaunchMapIter l_GroupIterator = m_MapProclaunchGrps.find(m_ActiveGroupId); + GroupLaunchMapIter l_GroupIterator = m_MapProclaunchGrps.find(m_SystemStarter.get_id()); + if (l_GroupIterator == m_MapProclaunchGrps.end()) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + " Error: Group %d not found; 'm_MapProclaunchGrps' is empty" + //, m_ActiveGroupId); // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + , m_SystemStarter.get_id()); + l_eStatus = eFrameworkunifiedStatusDbRecNotFound; + } else { + int l_numModulesMessaged = 0; + FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "StopReq grp:%d", m_SystemStarter.get_id()); + + T_SS_SM_STOP_DataStructType l_SM_STOP_Struct; + l_SM_STOP_Struct.shutdownTrigger = m_shutdownTrigger; + l_SM_STOP_Struct.lastUserMode = m_lastUserMode; + + for (l_revIter = l_GroupIterator->second.modules.rbegin(); + l_revIter != l_GroupIterator->second.modules.rend(); + l_revIter++) { + // LCOV_EXCL_BR_START 11: Excluded due to gcov constraints (others) + if ((l_revIter->IsModuleState(MODULE_STATE_START_SENT) == TRUE) + || (l_revIter->IsModuleState(MODULE_STATE_STARTED) == TRUE) + || (l_revIter->IsModuleState(MODULE_STATE_START_PRE_SENT) == TRUE) + || (l_revIter->IsModuleState(MODULE_STATE_STARTED_PRE) == TRUE) + || (l_revIter->IsModuleState(MODULE_STATE_STOP_PRE_SENT) == TRUE) + || (l_revIter->IsModuleState(MODULE_STATE_STOPPED_PRE) == TRUE) + || (l_revIter->IsModuleState(MODULE_STATE_START_BACKGROUND_SENT) == TRUE) + || (l_revIter->IsModuleState(MODULE_STATE_STARTED_BACKGROUND) == TRUE) + || (l_revIter->IsModuleState(MODULE_STATE_STOP_BACKGROUND_SENT) == TRUE) + || (l_revIter->IsModuleState(MODULE_STATE_STOPPED_BACKGROUND) == TRUE)) { + // LCOV_EXCL_BR_STOP 11: Excluded due to gcov constraints (others) + if (FRAMEWORKUNIFIED_NS_NPSERVICE == l_revIter->name) { + if (epssdmsdtFACTORY_DATA_RESET == m_shutdownTrigger) { + CALL_AND_LOG_STATUS(FrameworkunifiedSendStopToNSNPP(hApp, eFrameworkunifiedDataResetShutdown, eFrameworkunifiedUserData | eFrameworkunifiedFactoryData)); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + } else if (epssdmsdtUSER_DATA_RESET == m_shutdownTrigger) { + CALL_AND_LOG_STATUS(FrameworkunifiedSendStopToNSNPP(hApp, eFrameworkunifiedDataResetShutdown, eFrameworkunifiedUserData)); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + } else if (epssdmsdtFAST_SLEEP_MODE == m_shutdownTrigger) { + CALL_AND_LOG_STATUS(FrameworkunifiedSendStopToNSNPP(hApp, eFrameworkunifiedQuickShutdown)); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + } else { + CALL_AND_LOG_STATUS(FrameworkunifiedSendStopToNSNPP(hApp, eFrameworkunifiedNormalShutdown)); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + } + + if (eFrameworkunifiedStatusOK != l_eStatus) { + l_revIter->SetModuleState(MODULE_STATE_STOP_FAILED); + } else { + l_revIter->SetModuleState(MODULE_STATE_STOP_SENT); + l_numModulesMessaged++; + } + + m_NPPStopSent = TRUE; + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " m_NPPStopSent is %s", GetStr(m_NPPStopSent).c_str()); // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + // End else if ( FRAMEWORKUNIFIED_NS_NPSERVICE == l_ModuleListIter->name ) + } else { + l_eStatus = l_revIter->SendMsgAndUpdateState(&l_SM_STOP_Struct); + LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, "l_revIter->SendMsgAndUpdateState(&l_SM_STOP_Struct)"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length) + if (eFrameworkunifiedStatusOK == l_eStatus) { + if (epssdmsdtFAST_SLEEP_MODE == m_shutdownTrigger) { + l_uiModuleWaitTime = l_revIter->fast_shutdown_wait_time; + + } else { + l_uiModuleWaitTime = l_revIter->shutdown_wait_time; + } + if (l_uiModuleWaitTime > l_uiMaxGroupWaitTime_sec) { + l_uiMaxGroupWaitTime_sec = l_uiModuleWaitTime; + } + l_numModulesMessaged++; + } + } // End if MODULE_STATE_STARTED || MODULE_STATE_START_SENT + } else if (l_revIter->IsModuleState(MODULE_STATE_INVALID) + && FRAMEWORKUNIFIED_NS_NPSERVICE == l_revIter->name) { + m_NPPStopSent = TRUE; + FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "StopNotSent:%s is INVALID", FRAMEWORKUNIFIED_NS_NPSERVICE); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "StopNotSent:%s is %s", + l_revIter->name.c_str(), + l_revIter->ModuleStateStr().c_str()); + } + } + + if (0 == l_numModulesMessaged) { + LogGroupModulesState(m_SystemStarter.get_id() // m_ActiveGroupId // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length) + , " Warning: NO modules were sent SS_SM_STOP"); + + FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "StopComp grp:%d", l_GroupIterator->second.id); + + if (m_SystemStarter.get_id() > SS_SM_INITIAL_GROUP) { + m_SystemStarter.decrement_id(); + FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, " m_ActiveGroupId is now %d", m_SystemStarter.get_id()); + + check_all_groups_have_stopped(hApp); + } + } else { + if (epssdmsdtFAST_SLEEP_MODE == m_shutdownTrigger) { + // fast shutdown wait time always comes in milli seconds + UI_32 l_uiTotalWaitTime = l_uiMaxGroupWaitTime_sec; + l_uiMaxGroupWaitTime_sec = l_uiTotalWaitTime / 1000; + l_uiMaxGroupWaitTime_msec = l_uiTotalWaitTime % 1000; + } else { + // Other types of shutdown except fast shutdown always comes in seconds. + l_uiMaxGroupWaitTime_msec = 0; + } + + FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "StopTimer grp:%d time:%d.%d", + m_SystemStarter.get_id(), l_uiMaxGroupWaitTime_sec, + l_uiMaxGroupWaitTime_msec); + m_GroupLaunchTimer->StartTimerMulti( + m_aTimerIDs[eSM_TIMER_CLIENT_STOP_MONITOR], + l_uiMaxGroupWaitTime_sec, l_uiMaxGroupWaitTime_msec, 0, 0, + m_SystemStarter.get_id()); + } + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of VOID CSystemManager::stop_all_modules_of_group(HANDLE hApp) + +EFrameworkunifiedStatus CSystemManager::ValidateUserModeMessage(HANDLE hApp, EPWR_USER_MODE_TYPE &l_eUserModeState) { // LCOV_EXCL_START 6: Because the condition cannot be set // NOLINT(whitespace/line_length) + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus; + Pwr_ServiceSetInterface tServiceSetIf; + EPWR_USER_MODE_TYPE l_my_eUserModeState; + + // ReadMsg(): * + // Check hApp ptr, msg size, msg reception, read msg if all ok. * + if (eFrameworkunifiedStatusOK != (l_eStatus = ReadMsg < Pwr_ServiceSetInterface > (hApp, tServiceSetIf))) { + LOG_ERROR("ReadMsg()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + } else { + l_my_eUserModeState = tServiceSetIf.data.user_mode.mode; + switch (l_my_eUserModeState) { + case epsumINVALID: + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: l_eUserModeState == epsumINVALID"); + l_eStatus = eFrameworkunifiedStatusInvldParam; + break; + + case epsumOFF: + case epsumON: + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " Validated '%s'", + l_my_eUserModeState == epsumON ? "epsumON" : "epsumOFF"); + l_eUserModeState = l_my_eUserModeState; + l_eStatus = eFrameworkunifiedStatusOK; + break; + + // default: Don't code a 'default' here - let the compiler + // issue a warning ( set via -Wall or -Wswitch ) when the set of + // enumerations changes - then the maintainer will + // automagically know to update this switch statement. + } // End switch + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::ValidateUserModeMessage( HANDLE hApp, EPWR_USER_MODE_TYPE &l_eUserModeState ) +// LCOV_EXCL_STOP + +//***************************************************************************** +// Next Wakeup Type Set Protocol functions * +// * +EFrameworkunifiedStatus CSystemManager::OnSetNextWakeupTypeRequest(HANDLE hApp) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus; + ESMNextWakeupType l_wakeupType; + + INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp); // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "from %s", FrameworkunifiedGetMsgSrc(hApp)); + SetCmdHist("SS_SM_NEXT_WAKEUP_TYPE_SET_REQ", m_SMCmdHist, m_SMHistIter, FrameworkunifiedGetMsgSrc(hApp)); + + if (eFrameworkunifiedStatusOK != (l_eStatus = ReadMsg < ESMNextWakeupType > (hApp, l_wakeupType))) { + LOG_ERROR("ReadMsg()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + } else { + switch (l_wakeupType) { + case e_SS_SM_NEXT_WAKEUP_TYPE_NONE: + case e_SS_SM_NEXT_WAKEUP_TYPE_COLD: + case e_SS_SM_NEXT_WAKEUP_TYPE_HOT: + break; + default: + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "unknown type(%d)", l_wakeupType); + l_eStatus = eFrameworkunifiedStatusInvldParam; + } + } + l_eStatus = FrameworkunifiedSetSyncResponseData(hApp, &l_eStatus, sizeof(l_eStatus)); + LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedSetSyncResponseData()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::OnSetNextWakeupTypeRequest( HANDLE hApp ) + +// * +// End of Boot Mode Protocol functions * +//***************************************************************************** + + +//***************************************************************************** +// Data Reset Mode Protocol functions * +// * +EFrameworkunifiedStatus CSystemManager::OnSetDataResetModeRequest(HANDLE hApp) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus; + ESMDataResetModeInfo l_dataResetMode; + INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp); // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "from %s", FrameworkunifiedGetMsgSrc(hApp)); + + SetCmdHist("SS_SM_DATA_RESET_MODE_SET_REQ", m_SMCmdHist, m_SMHistIter, FrameworkunifiedGetMsgSrc(hApp)); + + if (eFrameworkunifiedStatusOK != (l_eStatus = ReadMsg < ESMDataResetModeInfo > (hApp, l_dataResetMode))) { + LOG_ERROR("ReadMsg()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + } else { + uint32_t tmp; + m_DataResetMode = l_dataResetMode; + tmp = static_cast<uint32_t>(m_DataResetMode); + if (PowerHalSetResetInfo(AGL_DATARESET_STATE, tmp)) { // LCOV_EXCL_BR_LINE 11:Gcov constraints (because exception-handling routes are automatically generated) + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Could not set AGL_DATARESET_STATE."); + // Return error to client of system_manager. + l_eStatus = eFrameworkunifiedStatusFail; + } + } + // + // Instead of sending Return Message, this function must call FrameworkunifiedSetSyncResponseData() + // because this request is sent by FrameworkunifiedInvokeSync() + // + l_eStatus = FrameworkunifiedSetSyncResponseData(hApp, &l_eStatus, sizeof(l_eStatus)); + LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedSetSyncResponseData()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::OnSetDataResetModeRequest( HANDLE hApp ) + +EFrameworkunifiedStatus CSystemManager::OnSetProgUpdateStateRequest(HANDLE hApp) { + EFrameworkunifiedStatus l_eStatus; + SMProgUpdateState l_progUpdateState; + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "from %s", FrameworkunifiedGetMsgSrc(hApp)); + + SetCmdHist("SS_SM_PROG_UPDATE_STATE_SET_REQ", m_SMCmdHist, m_SMHistIter, FrameworkunifiedGetMsgSrc(hApp)); + + if (eFrameworkunifiedStatusOK != (l_eStatus = ReadMsg < SMProgUpdateState > (hApp, l_progUpdateState))) { // LCOV_EXCL_BR_LINE 4: nsfw error + // LCOV_EXCL_START 4: nsfw error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + LOG_ERROR("ReadMsg()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + // LCOV_EXCL_STOP + } else { + m_ProgUpdateState |= l_progUpdateState; + if (PowerHalSetResetInfo(AGL_PROGUPDATE_STATE, m_ProgUpdateState)) { // LCOV_EXCL_BR_LINE 11:Gcov constraints (because exception-handling routes are automatically generated) + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Could not set AGL_PROGUPDATE_STATE."); + // return Error to client of system_manager. + l_eStatus = eFrameworkunifiedStatusFail; + } + } + // Instead of sending Return Message, this function must call FrameworkunifiedSetSyncResponseData() + // because this request is sent by FrameworkunifiedInvokeSync() + l_eStatus = FrameworkunifiedSetSyncResponseData(hApp, &l_eStatus, sizeof(l_eStatus)); + LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedSetSyncResponseData()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::OnSetProgUpdateStateRequest( HANDLE hApp ) + +EFrameworkunifiedStatus CSystemManager::CallStopCompleteHandler(HANDLE hApp, BOOL bIsDetectTimeout /* = FALSE */) { + FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; + + + if (bIsDetectTimeout) { + fprintf(stderr, "SS_SysManager/%s/State StopComplete(timeout)\n", __FUNCTION__); + } else { + fprintf(stderr, "SS_SysManager/%s/State StopComplete\n", __FUNCTION__); + } + + l_eStatus = SecureChipOff(); + if (eFrameworkunifiedStatusOK != l_eStatus) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error: SecureChipOff Failed"); + } + + l_eStatus = (*m_pfStopCompleteHandler)(hApp); + + FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::CallStopCompleteHandler( HANDLE hApp ) + + +//***************************************************************************** +// Soft Reset Protocol functions * +// * +static char *get_line(const char *filepath) { + char line[LINE_MAX]; + FILE *fp; + + if ((fp = fopen(filepath, "rb")) == NULL) + return NULL; + if (fgets(line, LINE_MAX, fp) == NULL) { // LCOV_EXCL_BR_LINE 5:fgets error + // LCOV_EXCL_START 5: fgets error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + fclose(fp); + return NULL; + // LCOV_EXCL_STOP + } + fclose(fp); + + return strdup(line); +} + +EFrameworkunifiedStatus CSystemManager::PerformCpuReset(HANDLE hApp, + ESMCpuResetReason f_eSmCpuResetReason, std::string f_messageStr) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; + if (FALSE == m_isRcvModeInfo) { + // If the condition for implementing the CpuReset request is not satisfied, keep the request. + FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "Cpu Reset Pending"); + m_isRstPending = TRUE; + m_rstPendingInfo.resetReason = f_eSmCpuResetReason; + snprintf(m_rstPendingInfo.messageStr, + sizeof(m_rstPendingInfo.messageStr), "%s", f_messageStr.c_str()); + } else { + switch (f_eSmCpuResetReason) { + case e_SS_SM_CPU_RESET_REASON_CRITICAL_ERR: + case e_SS_SM_CPU_RESET_REASON_GENERIC_ERR: + case e_SS_SM_CPU_RESET_REASON_DSP_ERR: + m_isImmResetReq = TRUE; + FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, " will reset immediately"); + // The break is omitted because the same process as for a normal reboot is performed. + case e_SS_SM_CPU_RESET_REASON_USER_FORCE_RESET: + m_pfStopCompleteHandler = (SysMgrCallback<CSystemManager, &CSystemManager::perform_force_reset>); + case e_SS_SM_CPU_RESET_REASON_NORMAL: { + TSystemManagerCpuResetInfo l_resetInfo; + + l_resetInfo.resetReason = f_eSmCpuResetReason; + snprintf(l_resetInfo.messageStr, SS_SM_RESET_MSG_STR_SIZE, "%s", f_messageStr.c_str()); + l_eStatus = FrameworkunifiedSendMsg(m_hPowerServiceSession, SS_SM_CPU_RESET_REQ, + sizeof(l_resetInfo), (PVOID) & l_resetInfo); + LOG_STATUS(l_eStatus, // LCOV_EXCL_BR_LINE 6: Because the condition cannot be set + "FrameworkunifiedSendMsg(m_hPowerServiceSession, SS_SM_CPU_RESET_REQ)"); + } + break; + case e_SS_SM_CPU_RESET_REASON_DATA_RESET: { + ESMDataResetType l_eSmDataResetType; + + switch (m_DataResetMode) { + case e_SS_SM_DATA_RESET_MODE_FACTORY: + l_eSmDataResetType = e_SS_SM_DATA_RESET_TYPE_FACTORY; + break; + case e_SS_SM_DATA_RESET_MODE_USER: + l_eSmDataResetType = e_SS_SM_DATA_RESET_TYPE_USER; + l_eStatus = FrameworkunifiedBroadcastEvent(hApp, SS_SM_EVENT_USER_DATA_RESET, NULL, 0); + LOG_STATUS(l_eStatus, "FrameworkunifiedBroadcastEvent(SS_SM_EVENT_USER_DATA_RESET)"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + break; + default: + SS_ASERT_LOG(0, "unexpected data reset mode : %d", m_DataResetMode); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + l_eStatus = eFrameworkunifiedStatusInvldParam; + break; + } + if (l_eStatus == eFrameworkunifiedStatusOK) { + l_eStatus = FrameworkunifiedSendMsg(m_hPowerServiceSession, + SS_SM_REMOTE_DATA_RESET_REQ, sizeof(l_eSmDataResetType), + (PVOID) & l_eSmDataResetType); + LOG_STATUS(l_eStatus, "FrameworkunifiedSendMsg(m_hPowerServiceSession, SS_SM_REMOTE_DATA_RESET_REQ)"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + } + } + break; + case e_SS_SM_CPU_RESET_REASON_INVALID: + default: + SS_ASERT_LOG(0, " Error: Unknown CPU reset request type: 0x%X/%d", // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + f_eSmCpuResetReason, f_eSmCpuResetReason); + l_eStatus = eFrameworkunifiedStatusInvldParam; + break; + } + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::PerformCpuReset( ESMCpuResetReason f_eSmCpuResetReason ) + +//***************************************************************************** +// CPU Reset Protocol functions * +// * +EFrameworkunifiedStatus CSystemManager::OnCpuResetRequest(HANDLE hApp) { // SS_SM_CPU_RESET_REQ + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail; + std::string l_moduleName = FrameworkunifiedGetMsgSrc(hApp); + INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp); // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "from %s", l_moduleName.c_str()); + + // If you implement FastSleep, + // ShutdownTrigger of FrameworkunifiedOnStop needs to be changed to FAST_SLEEP_MODE, + // and also MaxShutdownTime needs to be changed to CriticalAppsMaxShutdownTimeFastSleep + + try { + TSystemManagerCpuResetInfo l_resetInfo; + SetCmdHist("SS_SM_CPU_RESET_REQ", m_SMCmdHist, m_SMHistIter, // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length) + FrameworkunifiedGetMsgSrc(hApp)); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length) + if (eFrameworkunifiedStatusOK != (l_eStatus = ReadMsg < TSystemManagerCpuResetInfo > (hApp, l_resetInfo))) { + LOG_ERROR("ReadMsg()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + } else { + char l_cBuf[100]; + EErrorEventType l_errorEventType; + SMLoggingInfo l_loggingInfo; // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length) + + l_loggingInfo.messageStr = l_resetInfo.messageStr; + l_loggingInfo.suffixStr = l_resetInfo.suffixStr; + + FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, + " CPU Reset Reason: '%d'/'%s' from %s", + l_resetInfo.resetReason, + GetStr(l_resetInfo.resetReason).c_str(), + FrameworkunifiedGetMsgSrc(hApp)); + + if (e_SS_SM_CPU_RESET_REASON_IMMRESET_NORMAL == l_resetInfo.resetReason) { + m_isImmResetReq = TRUE; + l_resetInfo.resetReason = e_SS_SM_CPU_RESET_REASON_NORMAL; + } + switch (l_resetInfo.resetReason) { + case e_SS_SM_CPU_RESET_REASON_DATA_RESET: + switch (m_DataResetMode) { + case e_SS_SM_DATA_RESET_MODE_FACTORY: + case e_SS_SM_DATA_RESET_MODE_USER: + break; + case e_SS_SM_DATA_RESET_MODE_NONE: + default: + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "unexpected data reset mode : %d", m_DataResetMode); + throw eFrameworkunifiedStatusInvldParam; + } + case e_SS_SM_CPU_RESET_REASON_CRITICAL_ERR: + case e_SS_SM_CPU_RESET_REASON_GENERIC_ERR: + case e_SS_SM_CPU_RESET_REASON_DSP_ERR: + case e_SS_SM_CPU_RESET_REASON_NORMAL: + l_errorEventType = eErrorEventTypeModuleInvokedResetRequest; + l_loggingInfo.resetReason = l_resetInfo.resetReason; + break; + case e_SS_SM_CPU_RESET_REASON_USER_FORCE_RESET: + // Separate ErrorEventType only for USER_FORCE_RESET, because the logs to be saved differ. + l_errorEventType = eErrorEventTypeUserInvokedUserForceReset; + l_loggingInfo.resetReason = e_SS_SM_CPU_RESET_REASON_USER_FORCE_RESET; + break; + case e_SS_SM_CPU_RESET_REASON_INVALID: + default: + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + " Error: Unknown CPU reset request type: 0x%X/%d", + l_resetInfo.resetReason, l_resetInfo.resetReason); + throw eFrameworkunifiedStatusInvldParam; + } + + l_eStatus = ErrorEventEnqueue(hApp, l_errorEventType, l_moduleName, + eErrorEventResetTypeHard, l_loggingInfo); + + snprintf(l_cBuf, sizeof(l_cBuf), "ErrorEventEnqueue(%s)", + GetStr(l_errorEventType).c_str()); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length) + LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, l_cBuf); // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length) + } + } catch (EFrameworkunifiedStatus e) { + l_eStatus = e; + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} +// * +// End of CPU Reset Protocol functions * +//***************************************************************************** + +VOID CSystemManager::InitiateAllGroupsShutdown(HANDLE hApp) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus; + + // Prioritize safe termination sequence and do not save logs during termination + m_errorEventQueueLocked = TRUE; + + m_MaxShutdownTime = calculate_max_shutdown_time(); + + l_eStatus = FrameworkunifiedNPPublishNotification(hApp, NTFY_SSSystemMgrShutdownStarted, NULL, 0); + + SetCmdHist(NTFY_SSSystemMgrShutdownStarted, m_PubCmdHist, m_PubHistIter, ""); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length) + + LOG_ERROR_REC_HIST_IF_ERRORED(l_eStatus, // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length) + "FrameworkunifiedNPPublishNotification(" NTFY_SSSystemMgrShutdownStarted ")"); + + m_GroupLaunchTimer->StopTimer(m_aTimerIDs[eSM_TIMER_START_RESP_MONITOR_WAIT_TIMER]); + m_GroupLaunchTimer->StopTimer(m_aTimerIDs[eSM_TIMER_CLIENT_START_MONITOR]); + + // Stop Heartbeat thread activity + l_eStatus = SendRequestToHeartBeat(hApp, SS_HEARTBEAT_STOP, NULL, 0); + LOG_ERROR_REC_HIST_IF_ERRORED(l_eStatus, "SendRequestToHeartBeat(SS_HEARTBEAT_STOP)"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length) + + SMSetState(hApp, SS_SM_APPS_STOPPING_AT__CWORD56__REQ); + + FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "shutdownTrigger:%s, lastUserMode:%s", + GetStr(m_shutdownTrigger).c_str(), GetStr(m_lastUserMode).c_str()); + + fprintf(stderr, // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length) + "SS_SysManager/%s/State shutdownTrigger:%s, lastUserMode:%s\n", // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length) + __FUNCTION__, GetStr(m_shutdownTrigger).c_str(), // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length) + GetStr(m_lastUserMode).c_str()); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length) + + /// Send SS_SM_STOP to all modules, starting with the m_ActiveGroupId group + m_NPPStopSent = FALSE; + check_all_groups_have_stopped(hApp); + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return; +} // End of EFrameworkunifiedStatus CSystemManager::InitiateAllGroupsShutdown(HANDLE hApp) + +VOID CSystemManager::SendDeferMsg(HANDLE hApp) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (!m_dqDeferMsg.empty()) { + EFrameworkunifiedStatus l_eStatus; + SM_POWER_EVENT_INFO deferMsg; + + deferMsg = m_dqDeferMsg.front(); + m_dqDeferMsg.pop(); + + HANDLE hSender = McOpenSender(SERVICE_SYSMANAGER); + if (hSender == NULL) { // LCOV_EXCL_BR_LINE 4: nsfw error + // LCOV_EXCL_START 4: nsfw error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: McOpenSender(SERVICE_SYSMANAGER)"); + // LCOV_EXCL_STOP + } else { + CALL_AND_LOG_STATUS_IF_ERRORED( // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + McSend(hSender, SERVICE_POWER, deferMsg.first, + sizeof(Pwr_ServiceSetInterface), + (PVOID) & deferMsg.second)); + CALL_AND_LOG_STATUS_IF_ERRORED(McClose(hSender)); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + } + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + return; +} // End of VOID CSystemManager::SendDeferMsg(HANDLE hApp) + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup PublishPowerOnOffNotification +/// Power Off notification handler +/// +/// \param [in] +/// +/// \return EFrameworkunifiedStatus +/// Success ==> eFrameworkunifiedStatusOK +/// Failure ==> Other values +/////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CSystemManager::PublishPowerOnOffNotification(HANDLE hApp) { + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + l_eStatus = PerformPowerOnOffUserModePublication(hApp, NTFY_SSSystemMgrPowerOnOff); + + SetCmdHist(NTFY_SSSystemMgrPowerOnOff, m_PubCmdHist, m_PubHistIter, ""); + LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, "PerformPowerOnOffUserModePublication()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length) + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} + +EFrameworkunifiedStatus CSystemManager::PublishUserModeNotification(HANDLE hApp) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus; + + l_eStatus = PerformPowerOnOffUserModePublication(hApp, NTFY_SSSystemMgrUserMode); + + SetCmdHist(NTFY_SSSystemMgrUserMode, m_PubCmdHist, m_PubHistIter, ""); + LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, "PerformPowerOnOffUserModePublication()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length) + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::PublishUserModeNotification( + +EFrameworkunifiedStatus CSystemManager::PerformPowerOnOffUserModePublication(HANDLE hApp, const char * p_NotificationStr) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus; + char l_cBuf[500] = { 0 }; + + if (m_SMConfig.UMConfig.IsUserModeNotificationABOOL) { + BOOL l_bUuserMode(m_PowerType_to_SSBoolEnumMap[m_Wake.powerupType]); + + snprintf(l_cBuf, sizeof(l_cBuf), "FrameworkunifiedNPPublishNotification(%s, %s)", + p_NotificationStr, GetStr(l_bUuserMode).c_str()); + l_eStatus = FrameworkunifiedNPPublishNotification(hApp, p_NotificationStr, + &l_bUuserMode, sizeof(l_bUuserMode)); + } else { + T_SS_SM_UserModeOnOffNotification_Struct l_UserModeOnOffStruct( + m_PowerType_to_SSBoolEnumMap[m_Wake.powerupType], + m_StartUpReason, m_userModeChangeReason); + + snprintf(l_cBuf, sizeof(l_cBuf), + "FrameworkunifiedNPPublishNotification(%s, %s, %s, %s)", p_NotificationStr, + GetStr(l_UserModeOnOffStruct.isUserModeOn).c_str(), + GetStr(m_StartUpReason).c_str(), + GetStr(m_userModeChangeReason).c_str()); + l_eStatus = FrameworkunifiedNPPublishNotification(hApp, p_NotificationStr, + &l_UserModeOnOffStruct, sizeof(l_UserModeOnOffStruct)); + } + + SetCmdHist(p_NotificationStr, m_PubCmdHist, m_PubHistIter, ""); + LOG_STATUS(l_eStatus, l_cBuf); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::PerformPowerOnOffUserModePublication( + +EFrameworkunifiedStatus CSystemManager::ResetModulesStateToConnected(HANDLE hApp) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; + ModuleLaunchListIter l_moduleIter; + for (GroupLaunchMapIter l_GroupIter = m_MapProclaunchGrps.begin(); + l_GroupIter != m_MapProclaunchGrps.end(); l_GroupIter++) { + for (l_moduleIter = l_GroupIter->second.modules.begin(); + l_moduleIter != l_GroupIter->second.modules.end(); + l_moduleIter++) { + if (l_moduleIter->name == FRAMEWORKUNIFIED_NS_NPSERVICE) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " %s ( Group %d/%s ) is %s", + l_moduleIter->name.c_str(), l_GroupIter->second.id, + l_GroupIter->second.name.c_str(), + l_moduleIter->ModuleStateStr().c_str()); + l_moduleIter->SetModuleState(MODULE_STATE_STARTED); // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + // End else if ( FRAMEWORKUNIFIED_NS_NPSERVICE == l_ModuleListIter->name ) + } else { + switch (l_moduleIter->GetModuleState()) { + case MODULE_STATE_INVALID: + case MODULE_STATE_SKIPPED: + case MODULE_STATE_LAUNCHING: + case MODULE_STATE_LAUNCHED: + case MODULE_STATE_LAUNCH_FAILED: + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, + " %s ( Group %d/%s ) is %s, NOT setting to " + "MODULE_STATE_CONNECTED", + l_moduleIter->name.c_str(), l_GroupIter->second.id, + l_GroupIter->second.name.c_str(), + l_moduleIter->ModuleStateStr().c_str()); // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length) + break; + + case MODULE_STATE_STARTED: + case MODULE_STATE_START_SENT: + case MODULE_STATE_CONNECTED: + case MODULE_STATE_START_FAILED: + case MODULE_STATE_STOP_FAILED: + case MODULE_STATE_STOP_SENT: + case MODULE_STATE_STOPPED: + case MODULE_STATE_START_PRE_SENT: + case MODULE_STATE_START_PRE_FAILED: + case MODULE_STATE_STARTED_PRE: + case MODULE_STATE_STOP_PRE_SENT: + case MODULE_STATE_STOP_PRE_FAILED: + case MODULE_STATE_STOPPED_PRE: + case MODULE_STATE_START_BACKGROUND_SENT: + case MODULE_STATE_START_BACKGROUND_FAILED: + case MODULE_STATE_STARTED_BACKGROUND: + case MODULE_STATE_STOP_BACKGROUND_SENT: + case MODULE_STATE_STOP_BACKGROUND_FAILED: + case MODULE_STATE_STOPPED_BACKGROUND: + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " %s ( Group %d/%s ) is %s", + l_moduleIter->name.c_str(), l_GroupIter->second.id, + l_GroupIter->second.name.c_str(), + l_moduleIter->ModuleStateStr().c_str()); + l_moduleIter->SetModuleState(MODULE_STATE_CONNECTED); + break; + // default: Don't code a 'default' here - let the compiler + // issue a warning ( set via -Wall or -Wswitch ) when the set of + // enumerations changes - then the maintainer will + // automagically know to update this switch statement. + } + } + } + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus CSystemManager::ResetModulesStateToConnected(HANDLE hApp) + +EFrameworkunifiedStatus CSystemManager::On_CWORD56_HeartBeatRequest(HANDLE hApp) { + FRAMEWORKUNIFIEDLOG(ZONE_PERIODIC_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; + + PCSTR l_senderName = FrameworkunifiedGetMsgSrc(hApp); + + SetCmdHist("SS_SM__CWORD56__HEARTBEAT_REQ", m_SMCmdHist, m_SMHistIter, l_senderName); + + FRAMEWORKUNIFIEDLOG(ZONE_PERIODIC_INFO, __FUNCTION__, " Received from %s", l_senderName); + EPWR_HB_REQ_MSG_STRUCT l_hbReq; + + if (eFrameworkunifiedStatusOK != (l_eStatus = ReadMsg < EPWR_HB_REQ_MSG_STRUCT > (hApp, l_hbReq))) { + LOG_ERROR("ReadMsg()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + } else { + + m_GroupLaunchTimer->StopTimer(m_aTimerIDs[eSM_TIMER__CWORD56__HEARTBEAT_RESPONSE]); + + if (l_hbReq.IntervalSec > 0) { + m_GroupLaunchTimer->StartTimer( + m_aTimerIDs[eSM_TIMER__CWORD56__HEARTBEAT_RESPONSE], 0, 0, + l_hbReq.IntervalSec, 0); + } else if (l_hbReq.IntervalSec == 0) { // LCOV_EXCL_BR_LINE 8: As the condition is never false + l_eStatus = FrameworkunifiedSendMsg(m_hPowerServiceSession, SS_SM__CWORD56__HEARTBEAT_RSPN, 0, NULL); + + LOG_STATUS(l_eStatus, "FrameworkunifiedSendMsg(m_hPowerServiceSession, SS_SM__CWORD56__HEARTBEAT_RSPN)"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + } + } + FRAMEWORKUNIFIEDLOG(ZONE_PERIODIC_FUNC, __FUNCTION__, "-"); + return (l_eStatus); +} + +EFrameworkunifiedStatus CSystemManager::On_CWORD56_HeartBeatResponseIntervalTimerExpiry(HANDLE hApp) { + FRAMEWORKUNIFIEDLOG(ZONE_PERIODIC_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; + + SetCmdHist("SM_TIMER__CWORD56__HEARTBEAT_RESPONSE", m_TimerCmdHist, m_TimerHistIter, FrameworkunifiedGetMsgSrc(hApp)); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length) + + l_eStatus = FrameworkunifiedSendMsg(m_hPowerServiceSession, SS_SM__CWORD56__HEARTBEAT_RSPN, 0, NULL); + + LOG_STATUS(l_eStatus, "FrameworkunifiedSendMsg(m_hPowerServiceSession, SS_SM__CWORD56__HEARTBEAT_RSPN)"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length) + + FRAMEWORKUNIFIEDLOG(ZONE_PERIODIC_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} + +// EOF of /SS_SystemManager/src/ss_system_manager_callbacks.cpp + |