--- /dev/null
+/*
+ * @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 <native_service/cl_lock.h>
+#include <native_service/cl_process.h>
+#include <native_service/cl_monitor.h>
+
+#include <native_service/frameworkunified_application.h>
+#include <native_service/frameworkunified_framework_if.h>
+#include <native_service/frameworkunified_multithreading.h>
+#include <native_service/frameworkunified_thread_priority.h>
+
+#include <native_service/ns_np_service_nor_persistence.h>
+#include <native_service/ns_np_service_protocol.h>
+#include <native_service/ns_plogger_if.h>
+#include <native_service/ns_np_service_if.h>
+#include <native_service/ns_backup.h>
+
+#include <heartbeat/ss_hb_if.h>
+
+#include <processlauncher/ProcessLauncher_if.h>
+#include <processlauncher/ss_sm_process_launcher.h>
+#include <processlauncher/ss_sm_process_launcher_protocol.h>
+
+#include <system_service/ss_system_manager_conf.h>
+#include <stub/ss_diag.h>
+
+#include <system_service/ss_client_names.h>
+#include <system_service/ss_heartbeat_service_protocol.h>
+#include <system_service/ss_power_service_if.h>
+#include <system_service/ss_power_service_notifications.h>
+#include <system_service/ss_power_service_protocol.h>
+#include <system_service/ss_services.h>
+#include <system_service/ss_sm_thread_names.h>
+#include <system_service/ss_sm_thread_names_local.h>
+#include <system_service/ss_sm_client_if.h>
+#include <system_service/ss_string_maps.h>
+#include <system_service/ss_system_manager_notifications.h>
+#include <system_service/ss_system_manager_notifications_local.h>
+#include <system_service/ss_templates.h>
+#include <system_service/ss_sm_client_if_local.h>
+#include <system_service/ss_test_clients.h>
+#include <stub/Clock_API.h>
+#include <power_hal.h>
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/procfs.h>
+#include <sys/timeb.h>
+#include <sys/wait.h>
+#include <inttypes.h>
+#include <libgen.h>
+#include <spawn.h>
+#include <pthread.h>
+#include <linux/oom.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sched.h>
+#include <other_service/itoa.h>
+#include <iomanip>
+#include <fstream>
+#include <string>
+#include <map>
+#include <vector>
+#include "ss_sm_signals.h"
+#include "ss_sm_default_paths.h"
+#include "ss_sm_systemmanagerlog.h"
+#include "ss_sm_version.h"
+#include "ss_system_manager.h"
+using namespace std; // NOLINT
+
+static CSystemManager g_oSystemManger;
+
+#define SS_SM_TEMP_FILE_FOR_STORE_LOGS "/nv/BS/ss/system_manager/rwdata/sm_tempStoreLogs"
+#define TR_USB_PATH "/usr/agl/bin/realtimeUsbLog"
+
+// \brief: public structure that is used for logging by NSLogger.
+FRAMEWORKUNIFIEDLOGPARAM g_FrameworkunifiedLogParams = {
+ FRAMEWORKUNIFIEDLOGOPTIONS,
+ {
+ ZONE_TEXT_10, ZONE_TEXT_11, ZONE_TEXT_12,
+ ZONE_TEXT_13, ZONE_TEXT_14, ZONE_TEXT_15,
+ ZONE_TEXT_16, ZONE_TEXT_17, ZONE_TEXT_18,
+ ZONE_TEXT_19, ZONE_TEXT_20, ZONE_TEXT_21,
+ ZONE_TEXT_22, ZONE_TEXT_23, ZONE_TEXT_24,
+ ZONE_TEXT_25, ZONE_TEXT_26, ZONE_TEXT_27,
+ ZONE_TEXT_28, ZONE_TEXT_29, ZONE_TEXT_30,
+ ZONE_TEXT_31
+ },
+ FRAMEWORKUNIFIEDLOGZONES
+};
+
+std::string NumberToString(int Number) { // LCOV_EXCL_START 8: dead code
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ std::ostringstream ss;
+ ss << Number;
+ return ss.str();
+}
+// LCOV_EXCL_STOP
+
+/* Check if "Mount Point" exsists as Directory */
+/*****************************************************************************/
+/**
+ @ingroup: CSystemManager
+ @brief: No Argument Constructor.
+ @note: .
+ @param void
+ @return void
+ */
+/*****************************************************************************/
+template<typename C, eFrameworkunifiedStatus (C::*M)(HANDLE)> EFrameworkunifiedStatus SysMgrCallback(HANDLE hApp) {
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail;
+ C * pObj = static_cast<C *>(&g_oSystemManger);
+ if (pObj) {
+ l_eStatus = (pObj->*M)(hApp);
+ }
+ return l_eStatus;
+}
+
+//**************************************************************************
+// System Manager State String Map *
+// *
+void Init_SS_SMModuleState_StrMap(std::map<SS_SMModuleState, SS_String> & m_strMap) { // NOLINT
+ MAP_ENTRY(m_strMap, SS_SM_READY_TO_LAUNCH_APP);
+ MAP_ENTRY(m_strMap, SS_SM_APPS_LAUNCH_IN_PROGRESS);
+ MAP_ENTRY(m_strMap, SS_SM_APPS_LAUNCHED_READY_TO_START);
+ MAP_ENTRY(m_strMap, SS_SM_APPS_START_IN_PROGRESS);
+ MAP_ENTRY(m_strMap, SS_SM_APPS_START_COMPLETE);
+ MAP_ENTRY(m_strMap, SS_SM_APPS_STOPPING_AT__CWORD56__REQ);
+ MAP_ENTRY(m_strMap, SS_SM_APPS_STOPPING_AT_INTERNAL_REQ);
+ MAP_ENTRY(m_strMap, SS_SM_WAITING_FOR_CRITICAL_APPS_AT__CWORD56__REQ);
+ MAP_ENTRY(m_strMap, SS_SM_WAITING_FOR_CRITICAL_APPS_AT_INTERNAL_REQ);
+ MAP_ENTRY(m_strMap, SS_SM_APPS_PRE_START_IN_PROGRESS);
+ MAP_ENTRY(m_strMap, SS_SM_APPS_PRE_STOP_IN_PROGRESS);
+ MAP_ENTRY(m_strMap, SS_SM_APPS_PRE_RUN_COMPLETE);
+ MAP_ENTRY(m_strMap, SS_SM_APPS_BACKGROUND_START_IN_PROGRESS);
+ MAP_ENTRY(m_strMap, SS_SM_APPS_BACKGROUND_STOP_IN_PROGRESS);
+ MAP_ENTRY(m_strMap, SS_SM_APPS_BACKGROUND_RUN_COMPLETE);
+} // End of void Init_SS_SMModuleState_StrMap(std::map<SS_SMModuleState,
+
+class EnumStringMap<SS_SMModuleState, Init_SS_SMModuleState_StrMap>
+ m_oSS_SMModuleStateStrMap;
+SS_String GetStr(SS_SMModuleState f_enum) {
+ return m_oSS_SMModuleStateStrMap.GetStr(f_enum); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+} // End of SS_String :GetStr(SS_SMModuleState f_enum)
+// *
+// End of System Manager State String Map *
+//**************************************************************************
+
+std::string CSystemManager::m_bootOpt; // NOLINT
+
+/*****************************************************************************/
+/**
+ @ingroup: CSystemManager
+ @brief: No Argument Constructor.
+ @note: .
+ @param void
+ @return void
+ */
+/*****************************************************************************/
+CSystemManager & CSystemManager::GetInstance() {
+ return g_oSystemManger;
+}
+
+/*****************************************************************************/
+/**
+ @ingroup: CSystemManager
+ @brief: No Argument Constructor.
+ @note: .
+ @param void
+ @return void
+ */
+/*****************************************************************************/
+CSystemManager::CSystemManager() :
+ m_hHeartbeatThread(INVALID_HANDLE, eSM_ThreadNotExist),
+ m_hProcLauncherThread(INVALID_HANDLE, eSM_ThreadNotExist),
+ m_SystemLaunchProgress(SS_SM_INITIAL_GROUP),
+ m_GroupLaunchTimer(NULL),
+ m_GroupRelaunchCount(0),
+ m_GroupRelaunchLimit(0),
+ m_hPowerServiceSession(NULL),
+ m_ActiveGroupId(SS_SM_INITIAL_GROUP),
+ m_StartUpReason(epswfINVALID),
+ m_DataResetMode(e_SS_SM_DATA_RESET_MODE_NONE),
+ m_ProgUpdateState(SS_SM_PROG_UPDATE_STATE_NONE),
+ m_NextWakeupType(e_SS_SM_NEXT_WAKEUP_TYPE_NONE),
+ m_DramBackupStatus(e_SS_SM_DRAM_BACKUP_NG),
+ m_isIlgReset(FALSE),
+ m_ResetStatus(e_SS_SM_RESET_STATUS_NONE),
+ m_ResetCount(0),
+ m_SMCurrentState(SS_SM_READY_TO_LAUNCH_APP),
+
+ m_MaxShutdownTime(0),
+ m_NbrDebugDumpRspnRecv(0),
+ m_isRcvModeInfo(FALSE),
+ m_BinaryFilesPath(""),
+ m_ConfigFilesPath(""),
+ m_pfStopCompleteHandler(
+ SysMgrCallback<CSystemManager, &CSystemManager::send_shutdown_complete_response>),
+ m_VersionNumberStruct(0, eFrameworkunifiedStatusErrOther),
+ m_BuildInfoStr(""),
+ m_isRstPending(FALSE),
+ m_rstPendingInfo(),
+ m_UsingVMPlayer(FALSE),
+ NVM_VALID_SIGNATURE(0xBA5EBA11),
+ m_lastUserMode(epsumON),
+ m_shutdownTrigger(epssdmsdtINVALID),
+ m_isImmediateReset(FALSE),
+ m_isImmResetReq(FALSE),
+ m_needReNotifyStartPrm(FALSE),
+ m_pVarCodeStr(NULL),
+ m_SSLGroupLaunchMapIterator(NULL),
+ m_ModuleLaunchListIter(NULL),
+ m_bIsNPP_ServicesStarted(FALSE),
+ m_bIsBackupAvail(FALSE),
+ m_oSystemLauncher(),
+ m_SystemStarter(),
+ m_NPPStopSent(FALSE),
+ m_userModeChangeReason(epsumcrNOT_AVAILABLE),
+ m__CWORD56_CmdHist(SS_SM__CWORD56__CMD_HIST_SIZE),
+ m_SMCmdHist(SS_SM_CMD_HIST_SIZE),
+ m_TimerCmdHist(SS_SM_TIMER_CMD_HIST_SIZE),
+ m_PubCmdHist(SS_SM_PUB_CMD_HIST_SIZE),
+ m_ErrHist(SS_SM_ERR_HIST_SIZE),
+ m_ClProcessSigFd(-1),
+ m_SysMemMonitor(),
+ m_FreeMemAvailable(0),
+ m_coreFileSizeBytes(0),
+ m_BootMicroResetReason(SS_SM_BOOT_MICRO_RESET_REASON_SELF_RESET),
+ m_errorEventQueueLocked(FALSE),
+ m_isPrevErrEventCompleted(TRUE),
+ m_errorEventResult(eFrameworkunifiedStatusOK),
+ m_requestedArtifactId(eArtifactIdInterfaceunifiedDebugLog) { // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ m_InitialBoot = true;
+
+ m_ResetFactor = PSM_FACTOR_NONE;
+
+ m_Wake.powerupType = epswsPWRON;
+ m_Wake.up.level = epswlFULLRUN;
+
+ m_SystemModeInfo.lastUserMode = m_lastUserMode;
+ m_SystemModeInfo.limpHomeCutoff = epslhcINVALID;
+ m_SystemModeInfo.productionMode = epspmINVALID;
+ m_SystemModeInfo.transportMode = epstmINVALID;
+ m_SystemModeInfo.systemMode = epssinfINVALID;
+ m_SystemModeInfo.startupStage = epssusfINVALID;
+
+ bzero(&m_SMConfig, sizeof(m_SMConfig));
+ bzero(&m_startUpConfirmationMsg, sizeof(m_startUpConfirmationMsg));
+ bzero(&m_HBReport, sizeof(m_HBReport));
+
+ m__CWORD56_HistIter = m__CWORD56_CmdHist.begin();
+ m_TimerHistIter = m_TimerCmdHist.begin();
+ m_SMHistIter = m_SMCmdHist.begin();
+ m_PubHistIter = m_PubCmdHist.begin();
+ m_ErrHistIter = m_ErrHist.begin();
+
+ ////******************************************************************////
+ //// Initialization of enum<=>enum and enum=>string maps ////
+ //// ////
+
+ //
+ // **** Initialization of powerupType enum maps ****
+ // Map of System Services powerupType to BOOL enum values
+ m_PowerType_to_SSBoolEnumMap[epswsPWRON] = TRUE;
+ m_PowerType_to_SSBoolEnumMap[epswsPWROFF] = FALSE;
+ //
+ // Map of System Services powerupType to System Services User Mode enum values
+ m_PowerType_to_SSUserModeEnumMap[epswsPWRON] = epsumON;
+ m_PowerType_to_SSUserModeEnumMap[epswsPWROFF] = epsumOFF;
+ //
+ // Map of BOOL to System Services powerupType enum values
+ m_SSBool_to_PowerTypeEnumMap[TRUE] = epswsPWRON;
+ m_SSBool_to_PowerTypeEnumMap[FALSE] = epswsPWROFF;
+ //
+ // **** Initialization of User Mode ( aka Last User Mode ) maps ****
+ // Map of BOOL to System Services User Mode enum values
+ m_SSBool_to_SSUserModeEnumMap[FALSE] = epsumOFF;
+ m_SSBool_to_SSUserModeEnumMap[TRUE] = epsumON;
+ //
+ // Map of BOOL to System Services User Mode enum values
+ m_SSUserMode_to_SSBoolEnumMap[epsumOFF] = FALSE;
+ m_SSUserMode_to_SSBoolEnumMap[epsumON] = TRUE;
+
+ // LCOV_EXCL_BR_STOP
+ //// ////
+ //// End of Initialization of enum<=>enum and enum=>string maps ////
+ ////******************************************************************////
+
+ m_startUpConfirmationMsg.wakeupType = epsstINVALID;
+ m_startUpConfirmationMsg.coldStartRequest = epsscrtINVALID;
+ m_startUpConfirmationMsg.HWVersion = UINT32_MAX;
+ m_startUpConfirmationMsg.matchedHardwareType = UINT32_MAX;
+ m_startUpConfirmationMsg.softwareType = UINT32_MAX;
+ m_startUpConfirmationMsg.imageType = UINT32_MAX;
+ m_startUpConfirmationMsg.majorVersion = UINT32_MAX;
+ m_startUpConfirmationMsg.minorVersion = UINT32_MAX;
+
+ m_SystemManagerPriority = PR_SS_SYSMANAGER;
+}
+
+/*****************************************************************************/
+/**
+ @ingroup: CSystemManager
+ @brief: Destructor
+ @note: .
+ @param void
+ @return void
+ */
+/*****************************************************************************/
+CSystemManager::~CSystemManager() { // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ if (NULL != m_pVarCodeStr) {
+ delete[] m_pVarCodeStr; // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ }
+}
+
+/*****************************************************************************/
+/**
+ @ingroup: CSystemManager
+ @brief: Initialize_memory Memory initialization processing
+ @note: .
+ @param
+ @return void
+ */
+/*****************************************************************************/
+void CSystemManager::Initialize_memory(HANDLE hApp, bool* l_isInitFail, EFrameworkunifiedStatus* l_eStatus_work, BOOL isIllReset) {
+ int ret;
+ EFrameworkunifiedStatus l_eStatus;
+
+ /// Start Process for Realtime USB Logging
+ {
+ PreLaunchModuleParams l_rtuparam;
+ l_rtuparam.LaunchFunc = CreateRtUsb;
+ l_rtuparam.relaunchLimit = 1;
+ l_rtuparam.name = "realtimeUsbLog";
+ l_rtuparam.binaryFileName = TR_USB_PATH;
+/* l_rtuparam.pid = CreateRtUsb();
+ if (l_rtuparam.pid == 1) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: CreateRtUsb()");
+ } */
+ m_PreLaunchModuleList.push_back(l_rtuparam);
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+
+ int fd = open("/dev/urandom", O_RDONLY); // LCOV_EXCL_BR_LINE 5: standard lib error
+ if (fd == -1) { // LCOV_EXCL_BR_LINE 5: standard lib error
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ SS_ASERT_ERRNO(0); // LCOV_EXCL_LINE 5: standard lib error
+ } else {
+ char buf[4];
+ ret = static_cast<int>(read(fd, buf, 4)); // LCOV_EXCL_BR_LINE 5: standard lib error
+ if (-1 == ret) { // LCOV_EXCL_BR_LINE 5: standard lib error
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ SS_ASERT_ERRNO(0); // LCOV_EXCL_LINE 5: standard lib error
+ } else if (4 != ret) { // LCOV_EXCL_BR_LINE 5: standard lib error
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ SS_ASERT(0); // LCOV_EXCL_LINE 5: standard lib error
+ } else {
+ fprintf(stderr, "WakeupID:%X%X%X%X\n", buf[0], buf[1], buf[2], buf[3]);
+ FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "WakeupID:%X%X%X%X", buf[0], buf[1], buf[2], buf[3]);
+ }
+ close(fd);
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "bootOpt:%s", m_bootOpt.c_str());
+
+ *l_eStatus_work = FrameworkunifiedAttachCallbackToDispatcherWithFd(hApp, m_ClProcessSigFd, // LCOV_EXCL_BR_LINE 4: nsfw error
+ SysMgrCallback<CSystemManager, &CSystemManager::OnProcessTermDetected>);
+
+ if (eFrameworkunifiedStatusOK != *l_eStatus_work) { // 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("FrameworkunifiedAttachCallbackToDispatcherWithFd()");
+ *l_isInitFail = true;
+ // LCOV_EXCL_STOP
+ }
+
+ pthread_mutex_init(&sm_hist_mutex, NULL);
+
+ ReadPathFromEnvironmentVariables();
+ ReadUsingVMPlayerEnvironmentVariable();
+
+ // FIXME : Dump information from power_hal by using
+
+ if (eFrameworkunifiedStatusOK != (*l_eStatus_work = SetSystemModeInfoStruct())) {
+ LOG_ERROR("SetSystemModeInfoStruct()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ *l_isInitFail = true;
+ }
+
+ // Select configuration file for wakeup services
+ BOOL bIsVupMode = (m_SystemModeInfo.systemMode == epssinfPROGRAMMING) ? TRUE : FALSE; // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+
+ T_SS_SM_INIT_HOOK_IN_PARAM inPrm;
+
+ std::memset(&inPrm, 0, sizeof(inPrm));
+ inPrm.bIsVupMode = bIsVupMode;
+
+ if (eFrameworkunifiedStatusOK != (*l_eStatus_work = ss_sm_initHook(hApp, &inPrm, &m_productCustomPrm))) {
+ SS_ASERT_LOG(0, "ERROR: ss_sm_initHook()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ *l_isInitFail = true;
+ }
+
+ SetEnvVariableForVupMode(bIsVupMode);
+
+ // Get the Version Number
+ // GetVersionNumber() will report any errors
+ m_VersionNumberStruct.m_eSystemmanagerStatus = GetVersionNumber(m_VersionNumberStruct.m_VersionNumber);
+
+ *l_eStatus_work = GetBuildInfo(m_BuildInfoStr);
+ l_eStatus = *l_eStatus_work;
+
+ LOG_ERROR_REC_HIST_IF_ERRORED(l_eStatus, "GetBuildInfo()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length)
+
+ INTERFACEUNIFIEDLOG_WHEN_COMPILED; // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length)
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " %s priority is %d", SERVICE_SYSMANAGER, m_SystemManagerPriority);
+ FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, " %s was compiled at %s @ %s", __FILE__, __DATE__, __TIME__);
+
+ FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, " Host Processor Software Version is '0x%016llX'",
+ m_VersionNumberStruct.m_VersionNumber);
+
+ FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, " Host Processor Build Version is '%s'", m_BuildInfoStr.c_str());
+
+ LogESystemmanagerStatusEnums();
+ LogProtocolIDs();
+}
+
+/*****************************************************************************/
+/**
+ @ingroup: CSystemManager
+ @brief: Initialize_callbacks Callback enrollment process
+ @note: .
+ @param
+ @return void
+ */
+/*****************************************************************************/
+void CSystemManager::Initialize_callbacks(HANDLE hApp, bool *l_isInitFail, EFrameworkunifiedStatus *l_eStatus_work) {
+ EFrameworkunifiedStatus l_eStatus;
+
+ m_GroupLaunchTimer = new (std::nothrow) TimerCtrl(eSM_TIMERS_END); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ if (NULL == m_GroupLaunchTimer) { // LCOV_EXCL_BR_LINE 5: Because new doesn't pass the failure case
+ // LCOV_EXCL_START 5: Because new doesn't pass the failure case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ *l_eStatus_work = eFrameworkunifiedStatusNullPointer;
+ LOG_ERROR("new(std::nothrow)TimerCtrl(eSM_TIMERS_END)");
+ *l_isInitFail = true;
+ // LCOV_EXCL_STOP
+ }
+
+ // LCOV_EXCL_BR_START 11:unexpected branch // NOLINT(whitespace/line_length)
+ m_GroupLaunchTimer->Initialize(hApp);
+ m_aTimerIDs[eSM_TIMER_GROUP_MONITOR] =
+ m_GroupLaunchTimer->CreateTimer(SysMgrCallback<CSystemManager, &CSystemManager::OnGroupLaunchTimerExpiry>);
+ m_aTimerIDs[eSM_TIMER_PROCESS_LAUNCH_MONITOR] =
+ m_GroupLaunchTimer->CreateTimer(SysMgrCallback<CSystemManager, &CSystemManager::OnProcessLaunchTimerExpiry>);
+ m_aTimerIDs[eSM_TIMER_HEARTBEAT_MONITOR] =
+ m_GroupLaunchTimer->CreateTimer(SysMgrCallback<CSystemManager, &CSystemManager::OnHeartBeatMonitorTimerExpiry>);
+ m_aTimerIDs[eSM_TIMER_PROCESSLAUNCHER_MONITOR] =
+ m_GroupLaunchTimer->CreateTimer(SysMgrCallback<CSystemManager,
+ &CSystemManager::OnProcessLaunchMonitorTimerExpiry>);
+ m_aTimerIDs[eSM_TIMER_CLIENT_START_MONITOR] =
+ m_GroupLaunchTimer->CreateTimer(SysMgrCallback<CSystemManager,
+ &CSystemManager::OnClientStartMonitorTimerExpiry>);
+ m_aTimerIDs[eSM_TIMER_NPP_STATUS_CHECK_MONITOR] =
+ m_GroupLaunchTimer->CreateTimer(SysMgrCallback<CSystemManager,
+ &CSystemManager::OnNPPStatusCheckMonitorTimerExpiry>);
+ m_aTimerIDs[eSM_TIMER__CWORD56__HEARTBEAT_RESPONSE] =
+ m_GroupLaunchTimer->CreateTimer(SysMgrCallback<CSystemManager,
+ &CSystemManager::On_CWORD56_HeartBeatResponseIntervalTimerExpiry>);
+ m_aTimerIDs[eSM_TIMER_LAUNCH_GROUP_TRIGGER_PROC_RESP_TIMER] =
+ m_GroupLaunchTimer->CreateTimer(SysMgrCallback<CSystemManager,
+ &CSystemManager::OnLaunchGroupTriggerProcessResponseTimerExpiry>);
+ m_aTimerIDs[eSM_TIMER_GROUP_LAUNCH_WAIT_TIMER] =
+ m_GroupLaunchTimer->CreateTimer(SysMgrCallback<CSystemManager, &CSystemManager::OnGroupLaunchWaitTimeout>);
+ m_aTimerIDs[eSM_TIMER_MODULE_CONNECT_WAIT_TIMER] =
+ m_GroupLaunchTimer->CreateTimer(SysMgrCallback<CSystemManager, &CSystemManager::OnModuleConnectWaitTimeout>);
+ m_aTimerIDs[eSM_TIMER_START_RESP_MONITOR_WAIT_TIMER] =
+ m_GroupLaunchTimer->CreateTimer(SysMgrCallback<CSystemManager, &CSystemManager::OnStartRespMonitorTimeout>);
+ m_aTimerIDs[eSM_TIMER_SHUTDOWN_COMPLETE_MONITOR] =
+ m_GroupLaunchTimer->CreateTimer(SysMgrCallback<CSystemManager,
+ &CSystemManager::OnShutdownCompleteMonitorTimeout>);
+ m_aTimerIDs[eSM_TIMER_CLIENT_STOP_MONITOR] =
+ m_GroupLaunchTimer->CreateTimer(SysMgrCallback<CSystemManager, &CSystemManager::OnClientStopMonitorTimerExpiry>);
+
+ FrameworkunifiedProtocolCallbackHandler l_cbArrayAnySource[] = {
+ // Command ID, Call back functions
+ { SS_SM_PROTOCOL_OPEN_SESSION_REQ, SysMgrCallback<CSystemManager, &CSystemManager::OnOpenSession> },
+ { SS_SM_CPU_RESET_REQ, SysMgrCallback<CSystemManager, &CSystemManager::OnCpuResetRequest> }
+ };
+
+ FrameworkunifiedProtocolCallbackHandler l_cbArrayGroupLaunchService[] = {
+ // Command ID, Call back functions
+ { SS_SM_GROUP_LAUNCH_TRIGGER, SysMgrCallback<CSystemManager, &CSystemManager::OnLaunchGroupTriggerProcessResponse> }
+ };
+
+ FrameworkunifiedProtocolCallbackHandler l_cbArrayNPPService[] = {
+ // Command ID, Call back functions
+ { NPS_NPP_READY_EVENT, SysMgrCallback<CSystemManager, &CSystemManager::OnNPPReadyEventCallback> },
+ { NPS_GET_READYSTATUS_ACK, SysMgrCallback<CSystemManager, &CSystemManager::OnNPPReadyStatusCallback> },
+ { NPS_NPP_STOP_ACK, SysMgrCallback<CSystemManager, &CSystemManager::OnNppStopComplete> }
+ };
+
+ FrameworkunifiedProtocolCallbackHandler l_cbArrayPowerService[] = {
+ // Command ID, Call back functions
+ { SS_SM_POWER_REQUEST_MSG, SysMgrCallback<CSystemManager, &CSystemManager::OnPowerRequestCallback> },
+ { SS_SM_WAKEUP_MODULES, SysMgrCallback<CSystemManager, &CSystemManager::OnWakeupCallback> },
+ { SS_SM_SYSTEM_MODE_INFO_REQ, SysMgrCallback<CSystemManager, &CSystemManager::OnSystemModeInfoRequest> },
+ { SS_SM_INITCOMP_REP, SysMgrCallback<CSystemManager, &CSystemManager::OnInitCompReportCallback> },
+ { SS_SM_SHUTDOWN_MODULES, SysMgrCallback<CSystemManager, &CSystemManager::OnShutdownModulesRequest> },
+ { SS_SM_FWD_STARTUP_CONFIRMATION_MSG_REQ,
+ SysMgrCallback<CSystemManager, &CSystemManager::OnSetStartupConfirmationDataRequest> }
+ };
+
+ FrameworkunifiedProtocolCallbackHandler l_cbArraySystemManager[] = {
+ // Command ID, Call back functions
+ { SS_SM_SendTriggerToSelf, SysMgrCallback<CSystemManager, &CSystemManager::OnLaunchGroupSelfTrigger> },
+ { SS_SM_DEBUG_DUMP_RSPN, SysMgrCallback<CSystemManager, &CSystemManager::OnDebugDumpResponseReceived> }
+ };
+ // LCOV_EXCL_BR_STOP
+
+#define ATTACH_CBS_TO_DISPATCHER(L_ARRAY, CALLING_SERVICE_NAME) \
+ *l_eStatus_work = l_eStatus = FrameworkunifiedAttachCallbacksToDispatcher(hApp, \
+ CALLING_SERVICE_NAME, \
+ L_ARRAY, \
+ static_cast<UI_32>_countof(L_ARRAY)); \
+ if (eFrameworkunifiedStatusOK != l_eStatus) { \
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, \
+ " Error: FrameworkunifiedAttachCallbacksToDispatcher(%s) errored: %d/'%s'", \
+ #L_ARRAY, \
+ l_eStatus, \
+ GetStr(l_eStatus).c_str()); \
+ *l_isInitFail = true; \
+ }
+// End of #define ATTACH_CBS_TO_DISPATCHER( CALLING_SERVICE_NAME, L_ARRAY )
+
+ // LCOV_EXCL_BR_START 15: marco defined above
+ // Note: This macro will exit this function if the embedded fnc errors.
+ ATTACH_CBS_TO_DISPATCHER(l_cbArrayAnySource, FRAMEWORKUNIFIED_ANY_SOURCE);
+
+ // Note: This macro will exit this function if the embedded fnc errors.
+ ATTACH_CBS_TO_DISPATCHER(l_cbArrayGroupLaunchService, SS_GROUP_LAUNCH_TRIGGER);
+
+ // Note: This macro will exit this function if the embedded fnc errors.
+ ATTACH_CBS_TO_DISPATCHER(l_cbArrayNPPService, FRAMEWORKUNIFIED_NS_NPSERVICE);
+
+ // Note: This macro will exit this function if the embedded fnc errors.
+ ATTACH_CBS_TO_DISPATCHER(l_cbArrayPowerService, SERVICE_POWER);
+
+ // Note: This macro will exit this function if the embedded fnc errors.
+ ATTACH_CBS_TO_DISPATCHER(l_cbArraySystemManager, SERVICE_SYSMANAGER);
+ // LCOV_EXCL_BR_STOP
+
+ {
+ char pathBuf[128];
+ // LCOV_EXCL_BR_START 11:unexpected branch // NOLINT(whitespace/line_length)
+ snprintf(pathBuf, sizeof(pathBuf), "/proc/%d/oom_score_adj", getpid());
+ std::ofstream fo(pathBuf);
+ fo << OOM_SCORE_ADJ_MIN << endl;
+ fo.close();
+ // LCOV_EXCL_BR_STOP
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "set OOM_SCORE_ADJ_MIN(SS_SysManager/%d)", getpid());
+ }
+
+#undef ATTACH_CBS_TO_DISPATCHER
+
+ // LCOV_EXCL_BR_START 4: nsfw error
+ *l_eStatus_work = FrameworkunifiedSubscribeNotificationWithCallback(hApp, NTFY_BackupMgr_Availability,
+ SysMgrCallback<CSystemManager, &CSystemManager::OnBackupMgrAvailCallback>);
+ // LCOV_EXCL_BR_STOP
+ if (eFrameworkunifiedStatusOK != *l_eStatus_work) { // 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("FrameworkunifiedSubscribeNotificationWithCallback()");
+ *l_isInitFail = true;
+ // LCOV_EXCL_STOP
+ }
+
+ if (eFrameworkunifiedStatusOK != (*l_eStatus_work = ErrorEventInit(hApp))) { // LCOV_EXCL_BR_LINE 6: function do not return error
+ // LCOV_EXCL_START 6: function do not return error
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ LOG_ERROR("ErrorEventInit()");
+ *l_isInitFail = true;
+ // LCOV_EXCL_STOP
+ }
+
+#ifndef SS_SM_SKIP_HEARTBEAT_INIT
+ // LCOV_EXCL_BR_START 6: function do not return error, expect nsfw error
+ if (eFrameworkunifiedStatusOK != (*l_eStatus_work = init_Heartbeat(hApp))) {
+ // LCOV_EXCL_BR_STOP
+ // LCOV_EXCL_START 6: function do not return error, expect nsfw error
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ LOG_ERROR("init_HeartBeat()");
+ *l_isInitFail = true;
+ // LCOV_EXCL_STOP
+ }
+#else
+#warning Test code - NOT calling init_Heartbeat(hApp)
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: NOT calling init_Heartbeat(hApp)");
+#endif
+#undef SS_SM_SKIP_HEARTBEAT_INIT
+
+ // LCOV_EXCL_BR_START 6: function do not return error, expect nsfw error
+ if (eFrameworkunifiedStatusOK != (*l_eStatus_work = init_process_launcher(hApp))) {
+ // LCOV_EXCL_BR_STOP
+ // LCOV_EXCL_START 6: function do not return error, expect nsfw error
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ LOG_ERROR("init_process_launcher()");
+ *l_isInitFail = true;
+ // LCOV_EXCL_STOP
+ }
+
+ // LCOV_EXCL_BR_START 6: function do not return error, expect init error
+ if (eFrameworkunifiedStatusOK != (*l_eStatus_work = start_process_launching(hApp))) {
+ // LCOV_EXCL_BR_STOP
+ // LCOV_EXCL_START 6: function do not return error, expect init error
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ LOG_ERROR("start_process_launching()");
+ *l_isInitFail = true;
+ // LCOV_EXCL_STOP
+ }
+
+ // LCOV_EXCL_BR_START 6: function do not return error, expect nsfw error
+ if (eFrameworkunifiedStatusOK != (*l_eStatus_work = init_sysmem_monitor(hApp))) {
+ // LCOV_EXCL_BR_STOP
+ // LCOV_EXCL_START 6: function do not return error, expect nsfw error
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ LOG_ERROR("init_sysmem_monitor()");
+ *l_isInitFail = true;
+ // LCOV_EXCL_STOP
+ }
+
+ /// Internal thread monitoring start
+ // LCOV_EXCL_BR_START 11:unexpected branch // NOLINT(whitespace/line_length)
+ m_GroupLaunchTimer->StartTimer(m_aTimerIDs[eSM_TIMER_HEARTBEAT_MONITOR],
+ SS_HEARTBEAT_MONITOR_TIMER_CONFIG, 0,
+ SS_HEARTBEAT_MONITOR_TIMER_CONFIG, 0);
+
+ m_GroupLaunchTimer->StartTimer(
+ m_aTimerIDs[eSM_TIMER_PROCESSLAUNCHER_MONITOR],
+ SS_PROCESSLAUNCHER_MONITOR_TIMER_CONFIG, 0,
+ SS_PROCESSLAUNCHER_MONITOR_TIMER_CONFIG, 0);
+
+ m_GroupLaunchTimer->StartTimer(
+ m_aTimerIDs[eSM_TIMER_NPP_STATUS_CHECK_MONITOR],
+ SS_NPP_STATUS_CHECK_MONITOR_TIME_SEC, 0,
+ SS_NPP_STATUS_CHECK_MONITOR_TIME_SEC, 0);
+ // LCOV_EXCL_BR_STOP
+}
+
+
+/*****************************************************************************/
+/**
+ @ingroup: CSystemManager
+ @brief: Initialization
+ @note: .
+ @param HANDLE hApp
+ @return void
+ */
+/*****************************************************************************/
+EFrameworkunifiedStatus CSystemManager::Initialize(HANDLE hApp) {
+ bool l_isInitFail = false;
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ int ret;
+ PsmFactorT l_startup_factor;
+
+ // Need to call Lock System Initialize API once in the system
+ ret = CL_LockSystemInit();
+ if (ret != 0) {
+ fprintf(stderr, "SS_SysManager/%s/Error: CL_LockSystemInit() errored: %d\n", __FUNCTION__, ret);
+ }
+
+ ret = CL_LockProcessInit();
+ if (ret != 0) {
+ fprintf(stderr, "SS_SysManager/%s/Error: CL_LockProcessInit() errored: %d\n", __FUNCTION__, ret);
+ l_isInitFail = true;
+ }
+
+ ret = PsmGetStartupFactor(hApp, &l_startup_factor);
+ if (ret == 0) {
+ if ((static_cast<UI_32>(l_startup_factor) & PSM_RESET_HISTORY) == PSM_RESET_HISTORY) {
+ DGCODE_RET_API l_ret = DGCODE_RET_ERROR;
+ uint64_t l_SystemResetRobCode = 0;
+ DGCODE_ROB_SSR_INFO l_info;
+ if (l_startup_factor == PSM_FACTOR_AGL_WITH_HISTORY) {
+ l_SystemResetRobCode = 0x2219; // AGL cause
+ } else if (l_startup_factor == PSM_FACTOR_TIER1_WITH_HISTORY) {
+ l_SystemResetRobCode = 0x221A; // Tier1 cause
+ } else if (l_startup_factor == PSM_FACTOR_USER_WITH_HISTORY) {
+ l_SystemResetRobCode = 0x8027; // USER cause
+ } else {
+ // No processing
+ }
+
+ if (l_SystemResetRobCode != 0) {
+ memset(&l_info, 0x00, sizeof(DGCODE_ROB_SSR_INFO));
+
+ l_ret = Diag_PutRoBInfo(hApp, l_SystemResetRobCode, &l_info);
+ if (l_ret == DGCODE_RET_ERROR) {
+ LOG_ERROR("Diag_PutRoBInfo()");
+ }
+ }
+ }
+ } else {
+ (void)fprintf(stderr, "SS_SysManager/%s/ERROR:start-up factor not get\n", __FUNCTION__);
+ }
+
+ m_isIlgReset = (false == GetSyscomPowerStatusInfo(hApp)) ? TRUE : FALSE;
+ if (m_isIlgReset || ("elog" == m_bootOpt)) {
+ fprintf(stderr, "SS_SysManager/%s/Error: ILGRST LOG SAVE\n", __func__);
+ StoreDebugLogs(hApp, SS_STORELOGS_ILLEGAL);
+ } else {
+ StoreDebugLogs(hApp, SS_STORELOGS_ACCOFFON);
+ }
+
+ if (m_isIlgReset == TRUE) {
+ // overwrite AGL_ILLRESET_FLAG.
+ uint32_t tmp = static_cast<uint32_t>(m_isIlgReset);
+ if (PowerHalSetResetInfo(AGL_ILLRESET_FLAG, tmp)) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "Could not set AGL_ILLRESET_FLAG to power_hal");
+ }
+ } else {
+ // keep last value of AGL_ILLRESET_FLAG.
+ }
+
+ FRAMEWORKUNIFIED_SET_ZONES();
+ NsLogSetLogMethod(LPRINT | LMSGQ);
+ // FRAMEWORKUNIFIEDLOG can not be used until this line
+
+ m_ClProcessSigFd = CL_ProcessInit(); // LCOV_EXCL_BR_LINE 4: nsfw error
+ if (m_ClProcessSigFd == -1) { // 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: CL_ProcessInit()");
+ l_isInitFail = true;
+ // LCOV_EXCL_STOP
+ }
+
+ ret = CL_MonitorInit(CL_MONITOR_INIT_SYSTEM);
+ if(ret != 0) {
+ fprintf(stderr, "SS_SysManager/%s/Error: CL_MonitorInit() errored: %d\n", __FUNCTION__, ret);
+ l_isInitFail = true;
+ }
+
+ // Threads MUST NOT be started until this line
+// ===== Initialization No.1
+ Initialize_memory(hApp, &l_isInitFail, &l_eStatus, m_isIlgReset);
+
+// ===== Initialization No.2
+ Initialize_callbacks(hApp, &l_isInitFail, &l_eStatus);
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+
+ return l_eStatus;
+}
+
+EFrameworkunifiedStatus CSystemManager::SetEnvVariableForVupMode(BOOL bIsVupMode) {
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ const CHAR SmVupModeEnvVariable[] = "SM_VUP_MODE";
+ const CHAR *l_pValue = bIsVupMode ? "y" : "n"; // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+
+ if (0 != setenv(SmVupModeEnvVariable, l_pValue, 1)) { // LCOV_EXCL_BR_LINE 5: standard lib error
+ // LCOV_EXCL_START 5: standard lib error
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ SS_ASERT_ERRNO(0);
+ l_eStatus = eFrameworkunifiedStatusFail;
+ // LCOV_EXCL_STOP
+ }
+
+ return l_eStatus;
+}
+
+int CSystemManager::CreateRtUsb(void) {// LCOV_EXCL_START 8: dead code
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ int pid = -1;
+ int ret;
+
+ ret = mkdir("/var/run", 0775);
+ if ((ret < 0) && (errno != EEXIST)) {
+ return -1;
+ }
+ pid = fork();
+ switch (pid) {
+ case 0: /* child process */
+ {
+ struct sched_param param;
+ int policy;
+ const char *exec;
+ exec = const_cast<char *>(TR_USB_PATH);
+ param.sched_priority = 0;
+ policy = SCHED_OTHER;
+ if (sched_setscheduler(getpid(), policy, ¶m) < 0) {
+ SS_ASERT(0);
+ _exit(-1);
+ }
+ if (setpriority(PRIO_PROCESS, getpid(), 0) < 0) {
+ SS_ASERT(0);
+ _exit(-1);
+ }
+ // exec
+ if (execlp(exec, exec, NULL) < 0) {
+ SS_ASERT(0);
+ _exit(-1);
+ }
+ _exit(0);
+ }
+ break;
+
+ case -1: /* error */
+ SS_ASERT(0);
+ goto ERROR;
+
+ default: /* parent process */
+ break;
+ }
+
+ERROR:
+ return pid;
+}// LCOV_EXCL_STOP
+
+bool CSystemManager::StoreDebugLogs(const HANDLE h_app,
+ SS_STORELOGS_OPE_TYPE type) {
+ bool isMountRamd = false;
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ int pid;
+
+ if (!GetDramPowerStatusInfo(h_app)) {
+ goto ERROR;
+ } else if (access(SS_SM_TEMP_FILE_FOR_STORE_LOGS, F_OK) == 0) {
+ fprintf(stderr, "SS_SysManager/%s/Error: Skip StoreDebugLogs\n", __FUNCTION__);
+ goto ERROR;
+ }
+
+ isMountRamd = true;
+
+ if (type == SS_STORELOGS_ILLEGAL) {
+ UI_32 l_ErrLogCount = 0;
+ if (PowerHalGetResetInfo(AGL_ERRLOG_COUNTER, &l_ErrLogCount)) {
+ fprintf(stderr, "SS_SysManager/%s/Error: "
+ "Could not read AGL_ERRLOG_COUNTER from power_hal\n", __FUNCTION__);
+ goto ERROR;
+ }
+
+ if (l_ErrLogCount >= SS_SM_ERR_LOGGING_LIMIT) {
+ fprintf(stderr, "SS_SysManager/%s/Error: "
+ "Skip StoreDebugLogs by continuous error l_ErrLogCount=%lu\n",
+ __FUNCTION__, l_ErrLogCount);
+ goto ERROR;
+ }
+
+ l_ErrLogCount++;
+ if (PowerHalSetResetInfo(AGL_ERRLOG_COUNTER, l_ErrLogCount)) {
+ // Just logging, don't go to ERROR.
+ fprintf(stderr, "SS_SysManager/%s/Error: "
+ "Could not write AGL_ERRLOG_COUNTER to power_hal\n", __FUNCTION__);
+ }
+ } else if (type == SS_STORELOGS_ACCOFFON) {
+ if (0 != unlink(SS_LOGGER_SAVE_INTERFACEUNIFIEDLOG_FLAG)) {
+ fprintf(stderr, "SS_SysManager/%s/Error: ACCOFFON LOG SAVE\n", __FUNCTION__);
+ } else {
+ goto ERROR;
+ }
+ }
+
+ pid = fork();
+ if (pid == 0) {
+ int fd = open(SS_SM_TEMP_FILE_FOR_STORE_LOGS,
+ O_CREAT | O_TRUNC | O_RDWR, 00664);
+ if (-1 == fd) { // LCOV_EXCL_BR_LINE 5:fd must not be -1
+ fprintf(stderr, "SS_SysManager/%s/Error: Failed open %s errno: %d\n",
+ __FUNCTION__, SS_SM_TEMP_FILE_FOR_STORE_LOGS, errno);
+ } else {
+ fsync(fd);
+ close(fd);
+ }
+ FRAMEWORKUNIFIED_SET_ZONES(); // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length)
+ NsLogSetLogMethod(LPRINT | LMSGQ);
+
+ if (eFrameworkunifiedStatusOK != (l_eStatus = SS_LoggerStoreLogs(type))) { // LCOV_EXCL_BR_LINE 200: always return OK
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ fprintf(stderr, "SS_SysManager/%s/Error: SS_LoggerStoreDebugLogs() errored: %d\n", __FUNCTION__, l_eStatus); // LCOV_EXCL_LINE 200: always return OK // NOLINT(whitespace/line_length)
+ }
+ // Close accessing the RAMD by FRAMEWORKUNIFIEDLOG for RAMD initialization
+ NsForceClose();
+
+ if (0 != unlink(SS_SM_TEMP_FILE_FOR_STORE_LOGS)) {
+ SS_ASERT_ERRNO(0); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ }
+
+ exit(0);
+ } else if (pid == -1) { // LCOV_EXCL_BR_LINE 5:fork error case
+ // LCOV_EXCL_START 5:fork error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ fprintf(stderr, "SS_SysManager/%s/Error: ASSERT %d\n", __FUNCTION__, __LINE__);
+ // LCOV_EXCL_STOP
+ } else {
+ if (-1 == waitpid(pid, NULL, 0)) { // LCOV_EXCL_BR_LINE 5:waitpid error case
+ // LCOV_EXCL_START 5:waitpid error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ fprintf(stderr, "SS_SysManager/%s/Error: ASSERT %d\n", __FUNCTION__, __LINE__);
+ // LCOV_EXCL_STOP
+ }
+ }
+ ERROR:
+ return isMountRamd;
+}
+
+#define SS_SM_SCAC_DEVICE_NODE "/dev/scac_driver"
+#define SS_SM_SCAC_CMD_SHUTDOWN 0x3000
+
+EFrameworkunifiedStatus CSystemManager::SecureChipOff() {
+ static bool isOffDone = false;
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ int32_t fd;
+ int32_t res;
+
+ if (!isOffDone) {
+ fd = open(SS_SM_SCAC_DEVICE_NODE, O_RDWR);
+ if (fd < 0) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "open(%s) ERR", SS_SM_SCAC_DEVICE_NODE);
+ l_eStatus = eFrameworkunifiedStatusFail;
+ } else {
+ res = ioctl(fd, SS_SM_SCAC_CMD_SHUTDOWN);
+ if (res < 0) { // LCOV_EXCL_BR_LINE 5: standard lib error
+ // LCOV_EXCL_START 5: standard lib error
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "ioctl(SS_SM_SCAC_CMD_SHUTDOWN) ERR");
+ l_eStatus = eFrameworkunifiedStatusFail;
+ // LCOV_EXCL_STOP
+ }
+
+ close(fd);
+ }
+
+ isOffDone = true;
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "Skip Chip Off");
+ }
+
+ return l_eStatus;
+}
+
+UI_32 CSystemManager::InProgressStateToSendMsg() const {
+ UI_32 l_iCmd = SS_SYSTEM_MANAGER_PROTOCOL_ENDING_INDEX;
+ switch (m_SMCurrentState) {
+ case SS_SM_APPS_PRE_START_IN_PROGRESS:
+ l_iCmd = SS_SM_PRE_START;
+ break;
+ case SS_SM_APPS_PRE_STOP_IN_PROGRESS:
+ l_iCmd = SS_SM_PRE_STOP;
+ break;
+ case SS_SM_APPS_BACKGROUND_START_IN_PROGRESS:
+ l_iCmd = SS_SM_BACKGROUND_START;
+ break;
+ case SS_SM_APPS_BACKGROUND_STOP_IN_PROGRESS:
+ l_iCmd = SS_SM_BACKGROUND_STOP;
+ break;
+ case SS_SM_APPS_START_IN_PROGRESS:
+ l_iCmd = SS_SM_START;
+ break;
+ default:
+ break;
+ }
+ return l_iCmd;
+}
+
+SMModuleState CSystemManager::InProgressStateToState() const {
+ SMModuleState l_state = MODULE_STATE_INVALID;
+ switch (m_SMCurrentState) {
+ case SS_SM_APPS_PRE_START_IN_PROGRESS:
+ l_state = MODULE_STATE_STARTED_PRE;
+ break;
+ case SS_SM_APPS_PRE_STOP_IN_PROGRESS:
+ l_state = MODULE_STATE_STOPPED_PRE;
+ break;
+ case SS_SM_APPS_BACKGROUND_START_IN_PROGRESS:
+ l_state = MODULE_STATE_STARTED_BACKGROUND;
+ break;
+ case SS_SM_APPS_BACKGROUND_STOP_IN_PROGRESS:
+ l_state = MODULE_STATE_STOPPED_BACKGROUND;
+ break;
+ case SS_SM_APPS_START_IN_PROGRESS:
+ l_state = MODULE_STATE_STARTED;
+ break;
+ default:
+ break;
+ }
+ return l_state;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup SetSystemModeInfoStruct
+/// Read ( or initialize ) NVM and set the SystemModeInfo structure
+///
+/// \return EFrameworkunifiedStatus
+/// Success ==> eFrameworkunifiedStatusOK
+/// Failure ==> Other values
+///////////////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::SetSystemModeInfoStruct() {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+
+ if (m_UsingVMPlayer) {
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " 'm_UsingVMPlayer' is True,"
+ " using default SystemModeInfo values");
+ m_SystemModeInfo.limpHomeCutoff = epslhcDISABLED;
+ m_SystemModeInfo.productionMode = epspmDISABLED;
+ m_SystemModeInfo.transportMode = epstmDISABLED;
+ m_SystemModeInfo.systemMode = epssinfNORMAL;
+ m_DataResetMode = e_SS_SM_DATA_RESET_MODE_NONE;
+ m_ResetCount = 0;
+ m_ProgUpdateState = SS_SM_PROG_UPDATE_STATE_NONE;
+ // Don't change the m_SystemModeInfo.startupStage.
+ // It is set dynamically as System Manager initializes the _CWORD102_.
+ } else {
+ uint32_t tmp = 0;
+ if (PowerHalGetResetInfo(AGL_RESET_COUNTER, &m_ResetCount)) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "Could not read AGLRESET_COUNTER from power_hal, assume to 0");
+ m_ResetCount = 0;
+ }
+
+ if (PowerHalGetResetInfo(AGL_PROGUPDATE_STATE, &m_ProgUpdateState)) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "Could not read AGL_PROGUPDATE_STATE from power_hal, "
+ "assume to SS_SM_PROG_UPDATE_STATE_NONE");
+ m_ProgUpdateState = SS_SM_PROG_UPDATE_STATE_NONE;
+ }
+
+ if (PowerHalGetResetInfo(AGL_DATARESET_STATE, &tmp)) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "Could not read AGL_DATARESET_STATE from power_hal, "
+ "assume to e_SS_SM_DATA_REESET_MODE_NONE");
+ m_DataResetMode = e_SS_SM_DATA_RESET_MODE_NONE;
+ } else {
+ m_DataResetMode = static_cast<ESMDataResetModeInfo>(tmp);
+ }
+ m_SystemModeInfo.systemMode = epssinfNORMAL;
+ } // End else ! m_UsingVMPlayer
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+} // End of EFrameworkunifiedStatus CSystemManager::SetSystemModeInfoStruct()
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup ClearDramBackupInfo
+///
+/// \param [in]
+///
+///
+/// \return EFrameworkunifiedStatus
+/// Success ==> eFrameworkunifiedStatusOK
+/// Failure ==> Other values
+///////////////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::ClearDramBackupInfo(HANDLE hApp) {
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ int ret;
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+
+ FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "PsmClrRamJudgeFlgPower()");
+ ret = PsmClrRamJudgeFlgPower(hApp);
+ if (ret != 0) { // LCOV_EXCL_BR_LINE 11: Excluded due to gcov constraints (others)
+ SS_ASERT_ERRNO(0); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ l_eStatus = eFrameworkunifiedStatusFail;
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup CloseApplication
+/// Process request to close Application
+///
+/// \param [in]
+///
+///
+/// \return EFrameworkunifiedStatus
+/// Success ==> eFrameworkunifiedStatusOK
+/// Failure ==> Other values
+///////////////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::CloseApplication(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__, "+");
+
+ if (eFrameworkunifiedStatusOK
+ != (l_eStatus = FrameworkunifiedPublishServiceAvailability(hApp, FALSE))) {
+ LOG_ERROR("FrameworkunifiedPublishServiceAvailability(hApp,FALSE)");
+ } else if (eFrameworkunifiedStatusOK != (l_eStatus =
+ FrameworkunifiedUnRegisterServiceAvailabilityNotification(hApp))) {
+ LOG_ERROR("FrameworkunifiedUnRegisterServiceAvailabilityNotification(hApp)");
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " Successful");
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+} // End of EFrameworkunifiedStatus CSystemManager::CloseApplication(HANDLE hApp)
+// LCOV_EXCL_STOP
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup SMStateStartCompleteEntry
+/// entry for SM module state(SS_SM_APPS_START_COMPLETE)
+///
+/// \param
+///
+/// \return EFrameworkunifiedStatus
+///////////////////////////////////////////////////////////////////////////////
+VOID CSystemManager::SMStateStartCompleteEntry(HANDLE hApp) {
+ EFrameworkunifiedStatus l_eStatus;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
+ "All %d groups have been sent system_manager protocol message, sending Start Complete to _CWORD56_",
+ m_SystemStarter.get_id());
+ CALL_AND_LOG_STATUS_IF_ERRORED( // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ send_power_request_complete_response(hApp, "Startup")); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+
+ CALL_AND_LOG_STATUS(PublishPowerOnOffNotification(hApp)); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+
+ if (m_InitialBoot == true) {
+ m_InitialBoot = false;
+
+ const ESMServiceWakeupStatus l_svcWupStatus = e_SS_SM_SVC_WAKEUP_STATUS_COMPLETE;
+
+ CALL_AND_LOG_STATUS( // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ FrameworkunifiedNPPublishNotification(hApp, NTFY_SSServiceWakeupStatus, // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ &l_svcWupStatus, sizeof(ESMServiceWakeupStatus))); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+
+ // If all modules are restarted, a passive warning will be issued
+ // indicating that Heartbeat is already running.
+
+ UI_32 l_list_num = static_cast<UI_32>(m_HBList.size());
+ if (SS_MAX_NUM_MODULES < l_list_num) {
+ l_list_num = SS_MAX_NUM_MODULES;
+ FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__,
+ " Warn: SS_MAX_NUM_MODULES '%d' < m_HBList.size '%d'",
+ SS_MAX_NUM_MODULES, l_list_num);
+ }
+
+ CHAR send_data[sizeof(l_list_num)
+ + (l_list_num * SS_SM_HB_MAX_PROC_NAME_SIZE)
+ + sizeof(m_SMConfig.HBConfig)];
+ CHAR* p_prm = &send_data[0];
+
+ memcpy(p_prm, reinterpret_cast<char *>(&m_SMConfig.HBConfig), sizeof(m_SMConfig.HBConfig));
+ p_prm = p_prm + sizeof(m_SMConfig.HBConfig);
+ memcpy(p_prm, reinterpret_cast<char *>(&l_list_num), sizeof(l_list_num));
+ p_prm = p_prm + sizeof(l_list_num);
+
+ for (UI_32 i = 0; i < l_list_num; i++) {
+ snprintf(p_prm, SS_SM_HB_MAX_PROC_NAME_SIZE, "%s", m_HBList[i].c_str());
+ p_prm = p_prm + SS_SM_HB_MAX_PROC_NAME_SIZE;
+ }
+ l_eStatus = SendRequestToHeartBeat(hApp, SS_HEARTBEAT_START, &send_data, static_cast<UI_32>(sizeof(send_data))); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ LOG_ERROR_REC_HIST_IF_ERRORED(l_eStatus, "SendRequestToHeartBeat()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+
+ m_DataResetMode = e_SS_SM_DATA_RESET_MODE_NONE;
+ {
+ uint32_t tmp = static_cast<uint32_t>(m_DataResetMode);
+ if (PowerHalSetResetInfo(AGL_DATARESET_STATE, tmp)) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "Could not set AGL_DATARESET_STATE to power_hal");
+ }
+ }
+
+ m_ProgUpdateState = SS_SM_PROG_UPDATE_STATE_NONE;
+ if (PowerHalSetResetInfo(AGL_PROGUPDATE_STATE, m_ProgUpdateState)) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "Could not set AGL_PROGUPDATE_STATE to power_hal");
+ }
+
+ m_isIlgReset = FALSE;
+ {
+ uint32_t tmp = static_cast<uint32_t>(m_isIlgReset);
+ if (PowerHalSetResetInfo(AGL_ILLRESET_FLAG, tmp)) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "Could not set AGL_ILLRESET_FLAG to power_hal");
+ }
+ }
+
+ if (access(SS_SM_TEMP_FILE_FOR_STORE_LOGS, F_OK) == 0) {
+ SS_ASERT_ERRNO(0 == unlink(SS_SM_TEMP_FILE_FOR_STORE_LOGS)); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ }
+ }
+
+ for (vector<std::string>::iterator protectedSvc =
+ m_productCustomPrm.protectedSvcs.begin();
+ protectedSvc != m_productCustomPrm.protectedSvcs.end();
+ protectedSvc++) {
+ ModuleLaunchListIter l_ModuleListIter;
+ l_eStatus = GetModuleIterator(protectedSvc->c_str(), l_ModuleListIter);
+ if (eFrameworkunifiedStatusOK == l_eStatus) {
+ if ((l_ModuleListIter->IsModuleState(MODULE_STATE_STARTED))
+ || (l_ModuleListIter->IsModuleState(MODULE_STATE_LAUNCHED)
+ && !l_ModuleListIter->is_start_required)) {
+ char pathBuf[128];
+
+ snprintf(pathBuf, 128, "/proc/%d/oom_score_adj", l_ModuleListIter->pid); // NOLINT
+ std::ofstream fo(pathBuf); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ fo << OOM_SCORE_ADJ_MIN << endl; // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ fo.close(); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "set OOM_SCORE_ADJ_MIN(%s/%d)",
+ l_ModuleListIter->name.c_str(), l_ModuleListIter->pid);
+ } else {
+ SS_ASERT(0); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ }
+ }
+ }
+
+ for (vector<std::string>::iterator groupRelaunchSvc =
+ m_productCustomPrm.groupRelaunchSvcs.begin();
+ groupRelaunchSvc != m_productCustomPrm.groupRelaunchSvcs.end();
+ groupRelaunchSvc++) {
+ ModuleLaunchListIter l_ModuleListIter;
+ l_eStatus = GetModuleIterator(groupRelaunchSvc->c_str(), l_ModuleListIter);
+ if (eFrameworkunifiedStatusOK == l_eStatus) {
+ if ((l_ModuleListIter->IsModuleState(MODULE_STATE_STARTED))
+ || (l_ModuleListIter->IsModuleState(MODULE_STATE_LAUNCHED)
+ && !l_ModuleListIter->is_start_required)) {
+ GroupRelaunchModuleParams l_param; // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ l_param.name = l_ModuleListIter->name.c_str();
+ m_GroupRelaunchModuleList.push_back(l_param);
+
+ if (l_ModuleListIter->retry_cnt > m_GroupRelaunchLimit) {
+ m_GroupRelaunchLimit = l_ModuleListIter->retry_cnt;
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "GroupRelaunchSvcs:%s(%d)",
+ l_ModuleListIter->name.c_str(), l_ModuleListIter->pid);
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "%s is not Launched", groupRelaunchSvc->c_str());
+ }
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "%s is not exist", groupRelaunchSvc->c_str());
+ }
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "GroupRelaunchLimit:%d", m_GroupRelaunchLimit);
+
+ SendDeferMsg(hApp); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+} // End of VOID CSystemManager::SMStateStartCompleteEntry()
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup SMStateEntry
+/// entry for SM module state
+///
+/// \param
+///
+/// \return EFrameworkunifiedStatus
+///////////////////////////////////////////////////////////////////////////////
+VOID CSystemManager::SMStateEntry(HANDLE hApp, SS_SMModuleState l_SMState) {
+ switch (l_SMState) {
+ case SS_SM_APPS_START_COMPLETE:
+ case SS_SM_APPS_PRE_RUN_COMPLETE:
+ case SS_SM_APPS_BACKGROUND_RUN_COMPLETE:
+ SMStateStartCompleteEntry(hApp);
+ break;
+ default:
+ break;
+ }
+} // End of VOID CSystemManager::SMStateEntry(SS_SMModuleState l_SMState)
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup SMStateExit
+/// exit for SM module state
+///
+/// \param
+///
+/// \return EFrameworkunifiedStatus
+///////////////////////////////////////////////////////////////////////////////
+VOID CSystemManager::SMStateExit(HANDLE hApp, SS_SMModuleState l_SMState) {
+ switch (l_SMState) {
+ case SS_SM_APPS_START_COMPLETE:
+ break;
+ default:
+ break;
+ }
+} // End of VOID CSystemManager::SMStateExit(SS_SMModuleState l_SMState)
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup SMSetState
+/// set module state
+///
+/// \param
+///
+/// \return EFrameworkunifiedStatus
+///////////////////////////////////////////////////////////////////////////////
+VOID CSystemManager::SMSetState(HANDLE hApp, SS_SMModuleState l_SMNewState) {
+ // FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "%s -> %s",
+ GetStr(m_SMCurrentState).c_str(), GetStr(l_SMNewState).c_str());
+
+ if (l_SMNewState != m_SMCurrentState) {
+ SMStateExit(hApp, m_SMCurrentState);
+
+ m_SMCurrentState = l_SMNewState;
+
+ SMStateEntry(hApp, m_SMCurrentState);
+ }
+ // FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup register_all_notification_callbacks
+/// register all notifications and callbacks with NP_NPS
+/// this function gets called when NP_NPS reply launch complete
+///
+/// \param
+///
+/// \return EFrameworkunifiedStatus
+///////////////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::register_all_notification_callbacks(HANDLE hApp) {
+ EFrameworkunifiedStatus l_eStatus;
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+
+ FrameworkunifiedNotificationsList userModeNotificationsBOOL[] = { {
+ NTFY_SSSystemMgrPowerOnOff, sizeof(BOOL), eFrameworkunifiedStateVar }, {
+ NTFY_SSSystemMgrUserMode, sizeof(BOOL), eFrameworkunifiedStateVar } };
+
+ FrameworkunifiedNotificationsList userModeNotificationsStruct[] = { {
+ NTFY_SSSystemMgrPowerOnOff,
+ sizeof(T_SS_SM_UserModeOnOffNotification_Struct), eFrameworkunifiedStateVar }, {
+ NTFY_SSSystemMgrUserMode,
+ sizeof(T_SS_SM_UserModeOnOffNotification_Struct), eFrameworkunifiedStateVar } };
+
+ FrameworkunifiedNotificationsList sm_notifications[] = {
+ { NTFY_SSSystemMgrStartUpType, sizeof(EPWR_SC_WAKEUP_TYPE), eFrameworkunifiedStateVar },
+ { NTFY_SSSystemMgrDataReset, sizeof(ESMDataResetType), eFrameworkunifiedStateVar },
+ { NTFY_SSSystemMgrShutdownStarted, 0, eFrameworkunifiedStateVar },
+ { NTFY_SSServiceWakeupStatus, sizeof(ESMServiceWakeupStatus), eFrameworkunifiedStateVar },
+ { NTFY_SSNeedAplRestart, 0, eFrameworkunifiedStateVar } };
+
+ if (m_SMConfig.UMConfig.IsUserModeNotificationABOOL) {
+ l_eStatus = FrameworkunifiedNPRegisterNotifications(hApp, userModeNotificationsBOOL,
+ static_cast<UI_32>(_countof(userModeNotificationsBOOL)));
+ } else {
+ l_eStatus = FrameworkunifiedNPRegisterNotifications(hApp,
+ userModeNotificationsStruct,
+ static_cast<UI_32>(_countof(userModeNotificationsStruct)));
+ }
+
+ if (eFrameworkunifiedStatusOK != l_eStatus) {
+ LOG_ERROR("FrameworkunifiedNPRegisterNotifications(userModeNotifications)"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ } else if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedNPRegisterNotifications(hApp, sm_notifications, static_cast<UI_32>(_countof(sm_notifications))))) { // 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("FrameworkunifiedNPRegisterNotifications(sm_notifications)"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ // LCOV_EXCL_STOP
+ } else if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedRegisterServiceAvailabilityNotification(hApp, NTFY_SSSystemMgrAvailability))) { // 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("FrameworkunifiedRegisterServiceAvailabilityNotification(" // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ NTFY_SSSystemMgrAvailability ")"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ // LCOV_EXCL_STOP
+ } else if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedPublishServiceAvailability(hApp, TRUE))) { // 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("FrameworkunifiedPublishServiceAvailability('NTFY_SSSystemMgrAvailability ', TRUE)"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ // LCOV_EXCL_STOP
+ } else {
+ LOG_SUCCESS("FrameworkunifiedPublishServiceAvailability('NTFY_SSSystemMgrAvailability ', TRUE)"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+
+ REC_HIST_IF_SUCCESSFUL(NTFY_SSSystemMgrAvailability, m_PubCmdHist, // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ m_PubHistIter, "", l_eStatus); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup
+///
+/// \param
+///
+/// \return
+///////////////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::init_Heartbeat(HANDLE hApp) {
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+
+ FrameworkunifiedProtocolCallbackHandler hb_protocol_callbacks[] = { {
+ SS_HEARTBEAT_PERIODIC_RESP, SysMgrCallback<CSystemManager,
+ &CSystemManager::OnHeartBeatThreadHeartbeatResponse> }, {
+ SS_HEARTBEAT_ERROR_DETECTED, SysMgrCallback<CSystemManager,
+ &CSystemManager::OnHeartBeatErrorDetected> }, {
+ SS_HEARTBEAT_AVAIL_CHECK_RESP, SysMgrCallback<CSystemManager,
+ &CSystemManager::OnCheckAvailResponse> } }; // LCOV_EXCL_BR_LINE 11:unexpected branch
+
+ // Subscribe to Notifications (All required notifications)
+ if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedAttachCallbacksToDispatcher(hApp, SS_SMHeartbeat, hb_protocol_callbacks, static_cast<UI_32>(_countof(hb_protocol_callbacks))))) { // 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("FrameworkunifiedAttachCallbacksToDispatcher(hb_notification_handlers)");
+ // LCOV_EXCL_STOP
+ } else if (NULL == (m_hHeartbeatThread.m_ThreadHdl = FrameworkunifiedCreateChildThreadWithPriority(hApp, SS_SMHeartbeat, HBThreadStart, HBThreadStop, PR_SMHEARTBEAT))) { // 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
+ l_eStatus = eFrameworkunifiedStatusThreadNotExist;
+ m_hHeartbeatThread.m_ThreadState = eSM_ThreadNotExist;
+ LOG_ERROR("FrameworkunifiedCreateChildThreadWithPriority(hApp, SS_SMHeartbeat)");
+ // LCOV_EXCL_STOP
+ } else if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedStartChildThread(hApp, m_hHeartbeatThread.m_ThreadHdl, 0, NULL))) { // 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
+ m_hHeartbeatThread.m_ThreadState = eSM_ThreadNotExist;
+ LOG_ERROR("FrameworkunifiedStartChildThread(SS_SMHeartbeat)");
+ // LCOV_EXCL_STOP
+ } else {
+ m_hHeartbeatThread.m_ThreadState = eSMThreadIsFine;
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
+
+EFrameworkunifiedStatus CSystemManager::init_sysmem_monitor(HANDLE hApp) {
+ EFrameworkunifiedStatus l_eStatus;
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+
+ FrameworkunifiedProtocolCallbackHandler sysmem_protocol_callbacks[] = { {
+ eSysMemThrdCmd_SYS_LOW_MEMORY, SysMgrCallback<CSystemManager,
+ &CSystemManager::OnLowSystemMemory> } }; // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ // LCOV_EXCL_BR_START 4: For setting the initialization conditions at SystemManager startup
+ if (eFrameworkunifiedStatusOK
+ != (l_eStatus = FrameworkunifiedAttachCallbacksToDispatcher(
+ hApp,
+ m_SysMemMonitor.GetThreadName().c_str(), sysmem_protocol_callbacks,
+ static_cast<UI_32>(_countof(sysmem_protocol_callbacks))))) {
+ // LCOV_EXCL_BR_STOP
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ LOG_ERROR("FrameworkunifiedAttachCallbacksToDispatcher()"); // LCOV_EXCL_LINE 4: For setting the initialization conditions at SystemManager startup
+ } else {
+ m_SysMemMonitor.SetSLMConfigData(m_SMConfig.SLMConfig); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ l_eStatus = m_SysMemMonitor.Initialize(hApp); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ LOG_ERROR_REC_HIST_IF_ERRORED // LCOV_EXCL_BR_LINE 6: For setting the initialization conditions at SystemManager startup
+ (l_eStatus, "m_SysMemMonitor.Initialize(hApp);"); // LCOV_EXCL_BR_LINE 6: For setting the initialization conditions at SystemManager startup
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup
+///
+/// \param
+///
+/// \return
+///////////////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::OnGroupLaunchTimerExpiry(HANDLE hThread) { // 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__, "+");
+ UI_32 l_launchID = m_oSystemLauncher.get_id();
+
+ FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, " Received from group %d", l_launchID);
+ REC_HIST_IF_SUCCESSFUL("SM_TIMER_GROUP_MONITOR", m_TimerCmdHist,
+ m_TimerHistIter, "TIMER", l_eStatus);
+
+ LogGroupModulesState(l_launchID,
+ " Group launch timer expired, processing next group.");
+
+ if (NULL == hThread) {
+ l_eStatus = eFrameworkunifiedStatusInvldParam;
+ LOG_ERROR("NULL == hThread");
+ } else {
+ // FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "Timer expired for group id,%d",m_oSystemLauncher.get_id());
+ if (!m_oSystemLauncher.is_end()) {
+ l_launchID = m_oSystemLauncher.advance_id();
+ if (eFrameworkunifiedStatusOK != (l_eStatus = OnLaunchGroup(hThread))) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error: OnLaunchGroup(%d) errored: %d/'%s'", l_launchID,
+ l_eStatus, GetStr(l_eStatus).c_str());
+ }
+ }
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+} // End of EFrameworkunifiedStatus CSystemManager::OnGroupLaunchTimerExpiry( HANDLE hThread )
+// LCOV_EXCL_STOP
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup
+///
+/// \param
+///
+/// \return
+///////////////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::FindNameOfTerminatedProcess(SI_32 f_pid, SS_String &f_ModuleName) {
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusDbRecNotFound;
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+
+ GroupLaunchMapIter l_GroupIterator = m_MapProclaunchGrps.begin();
+ if (l_GroupIterator == m_MapProclaunchGrps.end()) { // LCOV_EXCL_BR_LINE 200: Group Map cannot be empty
+ // LCOV_EXCL_START 200: Group Map cannot be empty
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error : Group Map empty"); // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length)
+ l_eStatus = eFrameworkunifiedStatusInvldParam;
+ // LCOV_EXCL_STOP
+ } else {
+ BOOL l_bModuleFound = FALSE;
+ for (; (FALSE == l_bModuleFound)
+ && (l_GroupIterator != m_MapProclaunchGrps.end());
+ l_GroupIterator++) {
+ ModuleLaunchListIter l_ModuleListIterator =
+ l_GroupIterator->second.modules.begin();
+ for (; (FALSE == l_bModuleFound)
+ && (l_ModuleListIterator
+ != l_GroupIterator->second.modules.end());
+ l_ModuleListIterator++) {
+ if (l_ModuleListIterator->pid == f_pid) {
+ l_bModuleFound = TRUE;
+ f_ModuleName = l_ModuleListIterator->name;
+ l_eStatus = eFrameworkunifiedStatusOK;
+ }
+ }
+ }
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup
+///
+/// \param
+///
+/// \return
+///////////////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::GetBinaryNameOfProcess(SS_String f_ModuleQueueName,
+ SS_String &f_ModuleBinaryName) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail;
+ ModuleLaunchListIter l_moduleIter;
+
+ f_ModuleBinaryName = "";
+ l_eStatus = GetModuleIterator(f_ModuleQueueName.c_str(), l_moduleIter);
+ if (eFrameworkunifiedStatusOK != l_eStatus) {
+ LOG_ERROR("GetModuleIterator()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ } else {
+ size_t l_pos = l_moduleIter->path.find_last_of("\\/");
+ if (std::string::npos == l_pos) { // LCOV_EXCL_BR_LINE 5: stdlib error case.
+ // LCOV_EXCL_START 5: stdlib error case.
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error. Unable to parse binary name from path %s.",
+ l_moduleIter->path.c_str());
+ // LCOV_EXCL_STOP
+ } else {
+ f_ModuleBinaryName = l_moduleIter->path.substr(l_pos + 1);
+ l_eStatus = eFrameworkunifiedStatusOK;
+ }
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup
+///
+/// \param
+///
+/// \return
+///////////////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::init_process_launcher(HANDLE hApp) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eStatus;
+ UI_32 TODO = 0;
+
+ FrameworkunifiedProtocolCallbackHandler process_launcher_protocol_callbacks[] = {
+ // Command ID, Call back functions
+ { ePLThrdCmd_LAUNCH_MODULE_RESP, SysMgrCallback<CSystemManager,
+ &CSystemManager::OnModuleLaunchResponse> },
+ { ePLThrdCmd_TERMINATE_MODULE_RESP, SysMgrCallback<CSystemManager,
+ &CSystemManager::OnTerminateModuleResponse> },
+ { ePLThrdCmd_RELAUNCH_MODULE_RESP, SysMgrCallback<CSystemManager,
+ &CSystemManager::OnReLaunchModuleResponse> },
+ { ePLThrdCmd_THREAD_STATUS_RESP, SysMgrCallback<CSystemManager,
+ &CSystemManager::OnProcessLauncherThreadHeartbeatResponse> } }; // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+
+ // setup call backs for my children
+ if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedAttachCallbacksToDispatcher(hApp, SS_SMLauncher, process_launcher_protocol_callbacks, static_cast<UI_32>(_countof(process_launcher_protocol_callbacks))))) { // LCOV_EXCL_BR_LINE 4:NSFW error case //NOLINT (whitespace/line_length)
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ LOG_ERROR("FrameworkunifiedAttachCallbacksToDispatcher()"); // LCOV_EXCL_LINE 4: For setting the initialization conditions at SystemManager startup
+ //////// Create Writer Child Threads handles the writing of data
+ } else if (NULL == (m_hProcLauncherThread.m_ThreadHdl = FrameworkunifiedCreateChildThreadWithPriority(hApp, SS_SMLauncher, ProcessLauncherOnStart, ProcessLauncherOnStop, PR_SMPROCLAUNCH))) { // LCOV_EXCL_BR_LINE 4:NSFW error case //NOLINT (whitespace/line_length)
+ // LCOV_EXCL_START 4: For setting the initialization conditions at SystemManager startup
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ l_eStatus = eFrameworkunifiedStatusNullPointer;
+ m_hProcLauncherThread.m_ThreadState = eSM_ThreadNotExist;
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error: FrameworkunifiedCreateChildThreadWithPriority(%s) errored: %d/'%s'",
+ SS_SMLauncher, l_eStatus, GetStr(l_eStatus).c_str());
+ // LCOV_EXCL_STOP
+ } else if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedStartChildThread(hApp, m_hProcLauncherThread.m_ThreadHdl, sizeof(UI_32), &TODO))) { // LCOV_EXCL_BR_LINE 4:NSFW error case //NOLINT (whitespace/line_length)
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ m_hProcLauncherThread.m_ThreadState = // LCOV_EXCL_LINE 4: For setting the initialization conditions at SystemManager startup
+ eSM_ThreadNotExist; // LCOV_EXCL_LINE 4: For setting the initialization conditions at SystemManager startup
+ LOG_ERROR("FrameworkunifiedStartChildThread()"); // LCOV_EXCL_LINE 4: For setting the initialization conditions at SystemManager startup
+ } else {
+ m_hProcLauncherThread.m_ThreadState = eSMThreadIsFine;
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
+
+EFrameworkunifiedStatus CSystemManager::OnGroupLaunchWaitTimeout(HANDLE hApp) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eStatus;
+ SetCmdHist("SM_TIMER_GROUP_LAUNCH_WAIT_TIMER", m_TimerCmdHist, m_TimerHistIter, FrameworkunifiedGetMsgSrc(hApp)); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ CALL_AND_LOG_STATUS(OnLaunchGroup(hApp)); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup
+///
+/// \param
+///
+/// \return
+///////////////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::OnModuleLaunchResponse(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_INFO, __FUNCTION__, "from %s", FrameworkunifiedGetMsgSrc(hApp));
+
+ GroupLaunchMapIter l_GroupIter;
+ ModuleLaunchListIter l_ModuleIter;
+ UI_32 l_launchID = m_oSystemLauncher.get_id();
+
+ l_eStatus = PerformModuleLaunchRespProcessing(hApp, l_GroupIter, l_ModuleIter, "ML");
+ if (eFrameworkunifiedStatusOK != l_eStatus) {
+ LOG_ERROR("PerformModuleLaunchRespProcessing()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ } else if (l_GroupIter->second.id == l_launchID) {
+ BOOL IsGroupLaunchComplete = TRUE;
+ // Search the group for any module that has not completed launching.
+ for (l_ModuleIter = l_GroupIter->second.modules.begin();
+ IsGroupLaunchComplete && (l_ModuleIter != l_GroupIter->second.modules.end());
+ l_ModuleIter++) {
+ IsGroupLaunchComplete = !l_ModuleIter->IsModuleState(MODULE_STATE_LAUNCHING);
+ }
+
+ if (IsGroupLaunchComplete) {
+ m_GroupLaunchTimer->StopTimer(m_aTimerIDs[eSM_TIMER_GROUP_MONITOR]);
+ l_GroupIter->second.launch_complete = TRUE;
+ FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "Group%d LaunchComp", l_GroupIter->second.id);
+
+ if (!m_oSystemLauncher.is_end()) {
+ l_launchID = m_oSystemLauncher.advance_id();
+ FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "Next group:%d", l_launchID);
+ if (FALSE == l_GroupIter->second.grp_wait_for_trigger) {
+ UI_32 l_Sec = (l_GroupIter->second.grp_launch_wait) / (1000 * 1000);
+ UI_32 l_mSec = 0;
+ if (l_Sec > 0) {
+ l_mSec = ((l_GroupIter->second.grp_launch_wait) % (1000 * 1000)) / 1000;
+ } else {
+ l_mSec = (l_GroupIter->second.grp_launch_wait) / 1000;
+ }
+ m_GroupLaunchTimer->StartTimer(
+ m_aTimerIDs[eSM_TIMER_GROUP_LAUNCH_WAIT_TIMER], l_Sec, l_mSec, 0, 0);
+ } else {
+ // Start the timer for group trigger... added for optimization
+ m_GroupLaunchTimer->StartTimer(
+ m_aTimerIDs[eSM_TIMER_LAUNCH_GROUP_TRIGGER_PROC_RESP_TIMER],
+ SS_LAUNCH_GROUP_TRIGGER_TIMER_CONFIG, 0, 0, 0);
+ }
+ }
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " Group %d/%s LaunchIncomp", l_launchID,
+ l_GroupIter->second.name.c_str());
+ }
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
+ " '%s' ( Group %d/%s ) Launch Response received late - "
+ "group id is now %d", l_ModuleIter->name.c_str(),
+ l_GroupIter->second.id, l_GroupIter->second.name.c_str()
+ , l_launchID);
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
+
+EFrameworkunifiedStatus CSystemManager::OnReLaunchModuleResponse(HANDLE hApp) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eStatus;
+ INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "from %s", FrameworkunifiedGetMsgSrc(hApp));
+
+ GroupLaunchMapIter l_GroupIter;
+ ModuleLaunchListIter l_ModuleIter;
+
+ l_eStatus = PerformModuleLaunchRespProcessing(hApp, l_GroupIter, l_ModuleIter, "RL");
+ LOG_ERROR_REC_HIST_IF_ERRORED(l_eStatus, "PerformModuleLaunchRespProcessing()"); // 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::OnReLaunchModuleResponse( HANDLE hApp )
+
+
+EFrameworkunifiedStatus CSystemManager::PerformModuleLaunchRespProcessing(HANDLE hApp,
+ GroupLaunchMapIter & f_GroupIter, ModuleLaunchListIter & f_ModuleIter,
+ PCSTR p_sPPD_tag) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eStatus;
+ T_ProcessLaunchResp l_LaunchRespData;
+
+ // ReadMsg(): *
+ // Check hApp ptr, msg size, msg reception, read msg if all ok. *
+ // Report any errors found. *
+ // *
+ if (eFrameworkunifiedStatusOK != (l_eStatus = ReadMsg < T_ProcessLaunchResp > (hApp, l_LaunchRespData))) { // LCOV_EXCL_BR_LINE 4: nsfw error // NOLINT(whitespace/line_length)
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ LOG_ERROR("ReadMsg()"); // LCOV_EXCL_LINE 4: nsfw error
+ } else {
+ BOOL b_DidModuleLaunch = FALSE;
+ f_GroupIter = l_LaunchRespData.groupIterator;
+ f_ModuleIter = l_LaunchRespData.moduleIterator;
+ SS_String l_ModulePath = l_LaunchRespData.path;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "%s(%d)", l_LaunchRespData.name, l_LaunchRespData.pid);
+
+ if (l_LaunchRespData.pid == -1) {
+ f_ModuleIter->pid = -1;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: Process launch failed: %s, %s",
+ f_ModuleIter->name.c_str(), l_ModulePath.c_str());
+
+ /// TODO
+ /// If PID is -1, launch had failed. Add logic to do necessary action.
+
+ f_ModuleIter->SetModuleState(MODULE_STATE_LAUNCH_FAILED);
+ } else if (l_LaunchRespData.pid == 0x7FFFFFFF) {
+ FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, " Warning: '%s', '%s' already launched",
+ f_ModuleIter->name.c_str(), l_ModulePath.c_str());
+
+ b_DidModuleLaunch = TRUE;
+ } else {
+ f_ModuleIter->pid = l_LaunchRespData.pid;
+ b_DidModuleLaunch = TRUE;
+ }
+
+ if (b_DidModuleLaunch) {
+ //
+ // Module state could already be MODULE_STATE_CONNECTED if
+ // module process ran before process launcher thread completed;
+ // don't overwrite/reset the MODULE_STATE_CONNECTED state.
+ if (f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCHING)) {
+ f_ModuleIter->SetModuleState(MODULE_STATE_LAUNCHED);
+ }
+
+ l_eStatus = f_ModuleIter->GetPriority(f_ModuleIter->current_priority);
+ if (eFrameworkunifiedStatusOK != l_eStatus) {
+ FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, " Warning: f_ModuleIter->GetPriority( "
+ "f_ModuleIter->current_priority ) returned %d/'%s'. "
+ "Setting 'current_priority' = 'configuration_priority' %d.",
+ l_eStatus, GetStr(l_eStatus).c_str(),
+ f_ModuleIter->configuration_priority);
+ f_ModuleIter->current_priority = f_ModuleIter->configuration_priority;
+ l_eStatus = eFrameworkunifiedStatusOK;
+ }
+ }
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+} // End of EFrameworkunifiedStatus CSystemManager::PerformModuleLaunchRespProcessing(
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup OnTerminateModuleResponse
+///
+/// \param HANDLE hApp
+///
+/// \return EFrameworkunifiedStatus
+///////////////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::OnTerminateModuleResponse(HANDLE hApp) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eStatus;
+ T_ProcessLauncherTerminationResp l_TerminateRespData;
+ INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, " from %s", FrameworkunifiedGetMsgSrc(hApp));
+
+ // ReadMsg(): *
+ // Check hApp ptr, msg size, msg reception, read msg if all ok. *
+ // Report any errors found. *
+ // *
+ if (eFrameworkunifiedStatusOK != (l_eStatus = ReadMsg < T_ProcessLauncherTerminationResp
+ > (hApp, l_TerminateRespData))) {
+ LOG_ERROR("ReadMsg()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ } else {
+ ModuleLaunchListIter l_ModuleIter = l_TerminateRespData.moduleIterator;
+
+ SS_String l_ModulePath = m_BinaryFilesPath + l_ModuleIter->path;
+
+ if ((0 == strcmp(l_ModulePath.c_str(), l_TerminateRespData.path))
+ && (0 == strcmp(l_ModuleIter->arguments.c_str(),
+ l_TerminateRespData.args))) {
+ l_ModuleIter->pid = 0;
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " %s Termination successful",
+ l_ModuleIter->name.c_str());
+ } else {
+ if (0 != strcmp(l_ModulePath.c_str(), l_TerminateRespData.path)) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error: ModuleIter->path != l_TerminateRespData.path"
+ " \" '%s' != '%s' \"", l_ModuleIter->path.c_str(),
+ l_TerminateRespData.path);
+ }
+ if (0 != strcmp(l_ModuleIter->arguments.c_str(),
+ l_TerminateRespData.args)) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: ModuleIter->arguments != "
+ "l_TerminateRespData.args, \" '%s' != '%s' \"",
+ l_ModuleIter->arguments.c_str(), l_TerminateRespData.args);
+ }
+ }
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+} // End of EFrameworkunifiedStatus CSystemManager::OnTerminateModuleResponse( HANDLE hApp )
+
+///////////////////////////////////////////////////////////////////////
+/// \ingroup ReadPathAndFileNameEnvironmentVariables
+///
+/// \param
+///
+/// \return VOID
+///////////////////////////////////////////////////////////////////////////////
+VOID CSystemManager::ReadPathFromEnvironmentVariables() {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length)
+ CHAR *l_pEnvVariable = NULL;
+
+ // read Path from environment variable
+ if (NULL == (l_pEnvVariable = std::getenv(BaseDirPathEnvVariable))) {
+ // Environment variable not set, set it to default path
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Using Default path for Binary Files : %s", DefaultBasePath);
+ m_BinaryFilesPath = DefaultBasePath;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Using Default path for Config Files : %s%s",
+ DefaultBasePath, DefaultConfigFilesPath);
+ m_ConfigFilesPath = DefaultBasePath;
+ } else {
+ // set path of binary files
+ m_BinaryFilesPath = l_pEnvVariable;
+
+ // set path of configuration files
+ m_ConfigFilesPath = l_pEnvVariable;
+ }
+ // set path of configuration files
+ m_ConfigFilesPath += DefaultConfigFilesPath;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return;
+}
+
+///////////////////////////////////////////////////////////////////////
+/// \ingroup GetConfigDataFileNameFromEnvironmentVariable
+///
+/// \param
+///
+/// \return SS_String
+///////////////////////////////////////////////////////////////////////////////
+SS_String CSystemManager::ReadLaunchConfigFileNameFromEnvironmentVariable() {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ CHAR *l_pEnvVariable = NULL;
+ SS_String l_FileName;
+
+ // read Launch Config File Name from environment variable
+ // LCOV_EXCL_BR_START 5: standard lib error
+ if (NULL == (l_pEnvVariable = std::getenv(LaunchConfigFileNameEnvVariable))) {
+ // LCOV_EXCL_BR_STOP
+ // Environment variable not set, set it to default file name
+ // LCOV_EXCL_START 5: standard lib error
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " Using Default Launch Configuration file : %s",
+ DefaultLaunchConfigFileName);
+ l_FileName = DefaultLaunchConfigFileName;
+ // LCOV_EXCL_STOP
+ } else {
+ l_FileName = l_pEnvVariable;
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " Using Launch Configuration file: %s", l_FileName.c_str());
+
+ SS_String retStr = m_ConfigFilesPath + l_FileName; // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ if (access(retStr.c_str(), F_OK) != 0) { // LCOV_EXCL_BR_LINE 5: standard lib error
+ // LCOV_EXCL_START 5: standard lib error
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "no found %s", retStr.c_str());
+ SS_ASERT(0);
+ // LCOV_EXCL_STOP
+ }
+ return retStr;
+}
+
+///////////////////////////////////////////////////////////////////////
+/// \ingroup GetConfigDataFileNameFromEnvironmentVariable
+///
+/// \param
+///
+/// \return SS_String
+///////////////////////////////////////////////////////////////////////////////
+SS_String CSystemManager::ReadConfigDataFileNameFromEnvironmentVariable() {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ CHAR *l_pEnvVariable = NULL;
+ SS_String l_FileName = "";
+
+ // read SM Config Data File Name from environment variable
+ // LCOV_EXCL_BR_START 5: standard lib error
+ if (NULL == (l_pEnvVariable = std::getenv(SMConfigDataFileNameEnvVariable))) {
+ // LCOV_EXCL_BR_STOP 5: standard lib error
+ // LCOV_EXCL_START 5: standard lib error
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ // Environment variable not set, set it to default file name
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Using Default Configuration Data file : %s", DefaultSMConfigFileName);
+ l_FileName = DefaultSMConfigFileName;
+ // LCOV_EXCL_STOP
+ } else {
+ l_FileName = l_pEnvVariable;
+ }
+
+ SS_String retStr = m_ConfigFilesPath + l_FileName; // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ if (access(retStr.c_str(), F_OK) != 0) { // LCOV_EXCL_BR_LINE 5: standard lib error
+ // LCOV_EXCL_START 5: standard lib error
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "no found %s", retStr.c_str());
+ SS_ASERT(0);
+ // LCOV_EXCL_STOP
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return retStr;
+}
+
+///////////////////////////////////////////////////////////////////////
+/// \ingroup ReadUsingVMPlayerEnvironmentVariable
+///
+/// \param
+///
+/// \return VOID
+///////////////////////////////////////////////////////////////////////////////
+VOID CSystemManager::ReadUsingVMPlayerEnvironmentVariable() {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ CHAR *l_pEnvVariable = std::getenv(UsingVMPlayerVariable);
+ m_UsingVMPlayer = (NULL != l_pEnvVariable);
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " %sunning on a VMPlayer",
+ m_UsingVMPlayer ? "R" : "Not r");
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return;
+} // End of VOID CSystemManager::ReadUsingVMPlayerEnvironmentVariable()
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup
+///
+/// \param
+///
+/// \return
+///////////////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::start_process_launching(HANDLE hApp) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ BOOL l_bIsGoodRc;
+ SS_String l_SMConfigFile(ReadConfigDataFileNameFromEnvironmentVariable());
+ SMConfigParams SMConfigData;
+ SS_String l_LaunchConfigFile(ReadLaunchConfigFileNameFromEnvironmentVariable()); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ SysMgrConfiguration l_launchConfig;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " Reading %s Configuration Data from %s",
+ SERVICE_SYSMANAGER, l_SMConfigFile.c_str());
+
+ l_bIsGoodRc = SMConfigData.LoadSMConfigParameters(m_SMConfig, l_SMConfigFile);
+
+ if (!l_bIsGoodRc) { // LCOV_EXCL_BR_LINE 6: For setting the initialization conditions at SystemManager startup
+ // LCOV_EXCL_START 6: For setting the initialization conditions at SystemManager startup
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error: SMConfigData.LoadSMConfigParameters(m_SMConfig, "
+ " %s) returned FALSE", l_SMConfigFile.c_str());
+ l_eStatus = eFrameworkunifiedStatusFileLoadError;
+ // LCOV_EXCL_STOP
+ } else {
+ SMSetState(hApp, SS_SM_APPS_LAUNCH_IN_PROGRESS); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " Reading Launch Configuration Data from %s",
+ l_LaunchConfigFile.c_str());
+
+ SS_String l_launchOrderName = "DEFAULT"; // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ LaunchOrderedVector l_OrderList;
+
+ l_bIsGoodRc = l_launchConfig.LoadParametersCfg(m_MapProclaunchGrps,
+ m_MapProcNames, l_OrderList, l_launchOrderName, l_LaunchConfigFile);
+
+ if (l_OrderList.size() != 0) { // LCOV_EXCL_BR_LINE 6: For setting the initialization conditions at SystemManager startup
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "wakeup order:%s",
+ l_launchOrderName.c_str());
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "wakeup order:DEFAULT");
+ }
+
+ if (!l_bIsGoodRc) { // LCOV_EXCL_BR_LINE 6: For setting the initialization conditions at SystemManager startup
+ // LCOV_EXCL_START 6: For setting the initialization conditions at SystemManager startup
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: l_launchConfig.LoadParametersCfg( "
+ "m_MapProclaunchGrps, m_MapProcNames, %s ) returned FALSE",
+ l_LaunchConfigFile.c_str());
+ l_eStatus = eFrameworkunifiedStatusFileLoadError;
+ // LCOV_EXCL_STOP
+ } else {
+ m_SystemLaunchProgress = SS_SM_INITIAL_GROUP;
+ // l_launchConfig.PrintAllInfo( m_MapProclaunchGrps );
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " System Launch Started");
+ // Don't use DynamicLaunch because its dependency on the services table is complex
+ SS_SOURCE source_type = SS_SOURCE_FM;
+
+ m_oSystemLauncher.configure_dynamic_launch(source_type, m_MapProclaunchGrps, l_OrderList);
+ m_oSystemLauncher.copyDynOrderedVector(m_SystemStarter);
+ // m_SystemStarter.print_info();
+
+ // start the timer upon successful launching of first process
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
+ "Starting Module Connection Timeout timer with %d sec period",
+ m_SMConfig.MCConfig.ModuleConnectionTimeOutSec);
+ m_GroupLaunchTimer->StartTimer(
+ m_aTimerIDs[eSM_TIMER_MODULE_CONNECT_WAIT_TIMER],
+ m_SMConfig.MCConfig.ModuleConnectionTimeOutSec, 0,
+ m_SMConfig.MCConfig.ModuleConnectionTimeOutSec, 0); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ CALL_AND_LOG_STATUS(OnLaunchGroup(hApp)); // LCOV_EXCL_BR_LINE 6: For setting the initialization conditions at SystemManager startup
+ }
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
+
+
+EFrameworkunifiedStatus CSystemManager::GetLastSourceInfo(SS_SOURCE &source_type) { // LCOV_EXCL_START 8: Because the condition cannot be set
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eStatus;
+
+ CHAR LastSource[64 + 1] = { '\0' };
+ l_eStatus = NPSynchronousReadPersistentData(SERVICE_AS_MODE,
+ NTFY_SSLastSourceType, LastSource, static_cast<UI_32>(sizeof(LastSource) - 1));
+ if (eFrameworkunifiedStatusOK != l_eStatus) {
+ LOG_ERROR("NPSynchronousReadPersistentData("
+ SERVICE_AS_MODE "," NTFY_SSLastSourceType);
+ } else {
+ std::string tempstr(LastSource);
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " String got from persistence %s", LastSource);
+ UI_32 pos = static_cast<UI_32>(tempstr.find("_"));
+ std::string tempstr2 = tempstr.substr(0, pos);
+ UI_64 value = strtoull(tempstr2.c_str(), 0, 10);
+ source_type = static_cast<SS_SOURCE>((UI_32)(value >> 32) & 0x0000FFFF);
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
+
+EFrameworkunifiedStatus CSystemManager::OnLaunchGroupTriggerProcessResponse(HANDLE hApp) {
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp);
+ UI_32 l_groupID;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "from %s", FrameworkunifiedGetMsgSrc(hApp));
+ SetCmdHist("SS_SM_GROUP_LAUNCH_TRIGGER", m_SMCmdHist, m_SMHistIter, FrameworkunifiedGetMsgSrc(hApp));
+ // stop group launch trigger process response timer
+ m_GroupLaunchTimer->StopTimer(m_aTimerIDs[eSM_TIMER_LAUNCH_GROUP_TRIGGER_PROC_RESP_TIMER]);
+
+ if (eFrameworkunifiedStatusOK != (l_eStatus = ReadMsg < UI_32 > (hApp, l_groupID))) {
+ LOG_ERROR("ReadMsg()");
+ } else {
+ SS_SOURCE source_type = SS_SOURCE_NA;
+ l_eStatus = GetLastSourceInfo(source_type);
+
+ if ((SS_SOURCE_AM == source_type) || (SS_SOURCE_FM == source_type)
+ || (SS_SOURCE_FM_DAB == source_type) || (SS_SOURCE_SDARS == source_type)) {
+ if (l_groupID == m_oSystemLauncher.get_id()) {
+ CALL_AND_LOG_STATUS(OnLaunchGroup(hApp));
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error: Received Group ID %d != Sys Mgr Group ID %d", l_groupID,
+ m_oSystemLauncher.get_id());
+ l_eStatus = eFrameworkunifiedStatusInvldParam;
+ }
+ } else { // media is last source
+ CALL_AND_LOG_STATUS(OnLaunchGroup(hApp));
+ }
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
+
+EFrameworkunifiedStatus CSystemManager::OnLaunchGroupTriggerProcessResponseTimerExpiry(HANDLE hApp) {
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp);
+ REC_HIST_IF_SUCCESSFUL("SM_TIMER_LAUNCH_GROUP_TRIGGER", m_TimerCmdHist,
+ m_TimerHistIter, FrameworkunifiedGetMsgSrc(hApp), l_eStatus);
+ CALL_AND_LOG_STATUS(OnLaunchGroup(hApp));
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup
+///
+/// \param
+///
+/// \return
+///////////////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::OnLaunchGroupSelfTrigger(HANDLE hApp) {
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "from %s", FrameworkunifiedGetMsgSrc(hApp));
+
+ REC_HIST_IF_SUCCESSFUL("SS_SM_SendTriggerToSelf", m_SMCmdHist, m_SMHistIter,
+ FrameworkunifiedGetMsgSrc(hApp), l_eStatus);
+
+ CALL_AND_LOG_STATUS(OnLaunchGroup(hApp));
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
+// LCOV_EXCL_STOP
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup
+///
+/// \param
+///
+/// \return
+///////////////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::OnLaunchGroup(HANDLE hApp) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ GroupLaunchMapIter l_GroupIter;
+ UI_32 l_launch_ID = m_oSystemLauncher.get_id();
+
+ // FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " Launching group %d", l_launch_ID );
+
+ l_GroupIter = m_MapProclaunchGrps.find(l_launch_ID);
+
+ if (l_GroupIter->second.launch_complete == FALSE) { // LCOV_EXCL_BR_LINE 6: Because it is not called for a condition that results in "TRUE"
+ // FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__
+ // , " m_bIsNPP_ServicesStarted ? %s, group.id: %d, Launch_Group: %d"
+ // , m_bIsNPP_ServicesStarted ? "Yes" : "No"
+ // , l_GroupIter->second.id
+ // , m_SystemLaunchProgress );
+
+ if ((m_bIsNPP_ServicesStarted && m_bIsBackupAvail) || (l_GroupIter->second.id <= 2)) { // LCOV_EXCL_BR_LINE 6: Because it is not called for the condition that results in "FALSE" // NOLINT(whitespace/line_length)
+ ModuleLaunchListIter l_ModuleListIterator = l_GroupIter->second.modules.begin();
+ if (l_ModuleListIterator != l_GroupIter->second.modules.end()) { // LCOV_EXCL_BR_LINE 6: For setting the initialization conditions at SystemManager startup // NOLINT(whitespace/line_length)
+ // FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "GRPLCH,(start),%d,%s",
+ // l_GroupIter->second.id,l_GroupIter->second.name.c_str());
+
+ FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "Launching Group%d/%s",
+ l_GroupIter->second.id, l_GroupIter->second.name.c_str());
+ SS_String l_ModulePath;
+ for (; l_ModuleListIterator != l_GroupIter->second.modules.end(); l_ModuleListIterator++) {
+ if (l_ModuleListIterator->IsModuleState(MODULE_STATE_INVALID)) {
+ char l_cFormat[] = "SendRequestToLauncher(%s, "
+ "ePLThrdCmd_LAUNCH_MODULE_REQST)";
+ char l_cBuf[sizeof(l_cFormat) + MAX_NAME_SIZE_APP];
+ snprintf(l_cBuf, sizeof(l_cBuf), l_cFormat,
+ l_ModuleListIterator->name.c_str());
+
+ l_eStatus = SendRequestToLauncher(hApp, l_ModuleListIterator, // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ ePLThrdCmd_LAUNCH_MODULE_REQST, // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ "ePLThrdCmd_LAUNCH_MODULE_REQST"); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+
+ if (eFrameworkunifiedStatusOK != l_eStatus) { // LCOV_EXCL_BR_LINE 6: For setting the initialization conditions at SystemManager startup // NOLINT(whitespace/line_length)
+ // LCOV_EXCL_START 6: For setting the initialization conditions at SystemManager startup // NOLINT(whitespace/line_length)
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ l_ModuleListIterator->SetModuleState(
+ MODULE_STATE_LAUNCH_FAILED);
+ SetCmdHist(l_cBuf, m_ErrHist, m_ErrHistIter,
+ GetStr(l_eStatus).c_str());
+ // LCOV_EXCL_STOP
+ } else {
+ l_ModuleListIterator->SetModuleState(MODULE_STATE_LAUNCHING);
+ }
+ } else {
+ l_ModulePath = (m_BinaryFilesPath + l_ModuleListIterator->path); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
+ " Not launching %s: module state is %s",
+ l_ModulePath.c_str(),
+ l_ModuleListIterator->ModuleStateStr().c_str());
+ }
+ }
+
+ // LCOV_EXCL_BR_START 6: For setting the initialization conditions at SystemManager startup // NOLINT(whitespace/line_length)
+ if (FALSE ==
+ l_GroupIter->second.grp_wait_for_trigger) {
+ // LCOV_EXCL_BR_STOP
+ m_GroupLaunchTimer->StartTimer(m_aTimerIDs[eSM_TIMER_GROUP_MONITOR],
+ SS_GROUP_LAUNCH_TIMER_CONFIG, 0, 0, 0); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ }
+ }
+ }
+
+ if (m_oSystemLauncher.is_end()) { // LCOV_EXCL_BR_LINE 6: For setting the initialization conditions at SystemManager startup // NOLINT(whitespace/line_length)
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "System Launch Completed");
+
+ if (epssusSYSTEM_SERVICES_STARTED == m_SystemModeInfo.startupStage) {
+ // If startupStage == SYSTEM_SERVICES_STARTED, a notification is requested because there are SVCs required for notification to the _CWORD56_.
+ l_eStatus = SendSystemModeInfoResponse(hApp, epssusALL_SERVICES_LAUNCHED);
+ LOG_ERROR_REC_HIST_IF_ERRORED(l_eStatus, // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length)
+ "UpdateStartupStageState_SendSystemModeInfoResponse" // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length)
+ "( epssusALL_SERVICES_LAUNCHED )"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length)
+ }
+
+ m_SystemModeInfo.startupStage = epssusALL_SERVICES_LAUNCHED;
+
+ if (is_current_state(SS_SM_APPS_LAUNCH_IN_PROGRESS)) {
+ SMSetState(hApp, SS_SM_APPS_LAUNCHED_READY_TO_START);
+ }
+ // SysMgrConfiguration config;
+ // config.PrintAllInfo( m_MapProclaunchGrps );
+ }
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+} // End of EFrameworkunifiedStatus CSystemManager::OnLaunchGroup(HANDLE hApp)
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup OnProcessLaunchTimerExpiry
+///
+/// \param HANDLE hApp
+///
+/// \return EFrameworkunifiedStatus
+///////////////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::OnProcessLaunchTimerExpiry(HANDLE hApp) { // LCOV_EXCL_START 8: Because the condition cannot be set
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ // ToDo 2013_05_17 Jay When used ? Dead code ? Don't see a StartTimer call.
+ REC_HIST_IF_SUCCESSFUL("SM_TIMER_PROCESS_LAUNCH_MONITOR", m_TimerCmdHist,
+ m_TimerHistIter, FrameworkunifiedGetMsgSrc(hApp), l_eStatus);
+ m_GroupLaunchTimer->StopTimer(m_aTimerIDs[eSM_TIMER_PROCESS_LAUNCH_MONITOR]);
+ return eFrameworkunifiedStatusOK;
+}
+// LCOV_EXCL_STOP
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup OnHeartBeatMonitorTimerExpiry
+///
+/// \param HANDLE hApp
+///
+/// \return EFrameworkunifiedStatus
+///////////////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::OnHeartBeatMonitorTimerExpiry(HANDLE hApp) {
+ FRAMEWORKUNIFIEDLOG(ZONE_PERIODIC_FUNC, __FUNCTION__, "+");
+ FRAMEWORKUNIFIEDLOG(ZONE_PERIODIC_INFO, __FUNCTION__, " Received from %s", FrameworkunifiedGetMsgSrc(hApp));
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length)
+ REC_HIST_IF_SUCCESSFUL("SM_TIMER_HEARTBEAT_MONITOR", m_TimerCmdHist, // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length)
+ m_TimerHistIter, FrameworkunifiedGetMsgSrc(hApp), l_eStatus); // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length)
+
+ // LCOV_EXCL_BR_START 4: nsfw error
+ if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedSendChild(hApp, m_hHeartbeatThread.m_ThreadHdl,
+ SS_HEARTBEAT_PERIODIC_STATUS_REQ, 0, NULL))) {
+ // LCOV_EXCL_BR_STOP 4: nsfw error
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ LOG_ERROR("FrameworkunifiedSendChild(m_hHeartbeatThread.m_ThreadHdl, " // LCOV_EXCL_LINE 4: nsfw error
+ "SS_HEARTBEAT_PERIODIC_STATUS_REQ)"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ } else {
+ m_hHeartbeatThread.m_ThreadState = eSMWaitForHeartbeat;
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_PERIODIC_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup SystemManagerDebugDump
+/// implement post mortem function
+///
+/// \param
+///
+/// \return void
+///////////////////////////////////////////////////////////////////////////////
+
+VOID CSystemManager::SystemManagerDebugDump(HANDLE hApp) {
+ std::stringstream l_debugDumpBuf;
+ cmdHistIter i;
+
+ // LCOV_EXCL_BR_START 11:unexpected branch // NOLINT(whitespace/line_length)
+ l_debugDumpBuf << FrameworkunifiedGetAppName(hApp) << "/" << endl
+ << " <SYSTEM MANAGER DUMP DATA> " << endl << endl << " ***internals*** " << endl
+ << endl << " SM state: "
+ << GetStr(m_SMCurrentState).c_str() << endl << " SM startup reason: "
+ << GetStr(m_StartUpReason).c_str() << endl << " SM shutdown reason: "
+ << GetStr(m_shutdownTrigger).c_str() << endl << " LUM: "
+ << GetStr(m_lastUserMode).c_str() << endl << " TPM: "
+ << GetStr(m_SystemModeInfo.transportMode).c_str() << endl << " LPH: "
+ << GetStr(m_SystemModeInfo.limpHomeCutoff).c_str() << endl << " PMode: "
+ << GetStr(m_SystemModeInfo.productionMode).c_str() << endl << " ActiveGroup: "
+ << m_ActiveGroupId << endl << " m_MaxShutdownTime: " << m_MaxShutdownTime
+ << endl << " NPP: " << (m_bIsNPP_ServicesStarted ? "Started" : "notStarted")
+ << endl
+ << endl << " ***Error history***" << endl;
+ // LCOV_EXCL_BR_STOP
+
+ for (i = m_ErrHist.begin(); i != m_ErrHist.end(); ++i) {
+ l_debugDumpBuf << endl << " " << i->m_cmd.c_str() << " @ " << i->m_time // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ << "ms EC:" << i->m_sender.c_str() << endl; // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ }
+
+ l_debugDumpBuf << endl << " ***_CWORD56_ command history***" << endl;
+
+ for (i = m__CWORD56_CmdHist.begin(); i != m__CWORD56_CmdHist.end(); ++i) {
+ l_debugDumpBuf << endl << " " << i->m_cmd.c_str() << " @ " << i->m_time << "ms" << endl; // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ }
+
+ l_debugDumpBuf << endl << " ***Timer history***" << endl;
+
+ for (i = m_TimerCmdHist.begin(); i != m_TimerCmdHist.end(); ++i) {
+ l_debugDumpBuf << endl << " " << i->m_cmd.c_str() << " @ " << i->m_time << "ms" << endl; // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ }
+
+ l_debugDumpBuf << endl << " ***SM message history***" << endl;
+
+ for (i = m_SMCmdHist.begin(); i != m_SMCmdHist.end(); ++i) {
+ l_debugDumpBuf << endl << " " << i->m_cmd.c_str() << " @ " << i->m_time << "ms " // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ << i->m_sender.c_str() << endl; // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ }
+
+ l_debugDumpBuf << endl << " ***Publishshing history***" << endl;
+
+ for (i = m_PubCmdHist.begin(); i != m_PubCmdHist.end(); ++i) {
+ l_debugDumpBuf << endl << " " << i->m_cmd.c_str() << " @ " << i->m_time << "ms " // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ << i->m_sender.c_str() << endl; // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ }
+
+ l_debugDumpBuf << endl << " ***SM start table***" << endl; // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+
+ // LCOV_EXCL_BR_START 11:unexpected branch // NOLINT(whitespace/line_length)
+ l_debugDumpBuf << endl
+ << " index | name | start required? | isOKFlag | Module state | start sent "
+ "| start resposne received |start delta | stop sent | reply received | stop delta | PID"
+ << endl;
+ // LCOV_EXCL_BR_STOP
+
+ for (UI_32 k = 1u; (k <= m_MapProclaunchGrps.size()); k++) {
+ GroupLaunchMapIter l_GroupIterator = m_MapProclaunchGrps.find(k);
+
+ if (l_GroupIterator != m_MapProclaunchGrps.end()) {
+ ModuleLaunchListIter l_ModuleListIterator = l_GroupIterator->second.modules.begin();
+
+ for (int i = 1u; l_ModuleListIterator != l_GroupIterator->second.modules.end();
+ l_ModuleListIterator++, i++) {
+ // LCOV_EXCL_BR_START 11:unexpected branch // NOLINT(whitespace/line_length)
+ std::string sIsOKFlag = GetModuleCondition(l_ModuleListIterator) ? " " : // 'blank' means OK
+ "X"; // 'X' means state mismatch
+
+ l_debugDumpBuf << " " << std::setw(2) << std::right << i << " | "
+ << std::setw(24) << std::left << l_ModuleListIterator->name.c_str()
+ << " | " << std::setw(5) << std::left
+ << (l_ModuleListIterator->is_start_required ? "TRUE" : "FALSE")
+
+ << " | " << sIsOKFlag.c_str() << " | " << std::setw(24) << std::left
+ << l_ModuleListIterator->ModuleStateStr().c_str() << " | "
+ << l_ModuleListIterator->m_startReason.GetInitial() << " | "
+ << l_ModuleListIterator->m_startReason.GetFinal() << " | "
+ << std::setw(3) << std::right
+ << static_cast<SI_16>(l_ModuleListIterator->m_startReason.GetDelta())
+ << "ms" << " | " << l_ModuleListIterator->m_stopReason.GetInitial()
+ << " | " << l_ModuleListIterator->m_stopReason.GetFinal() << " | "
+ << std::setw(3)
+ << static_cast<SI_16>(l_ModuleListIterator->m_stopReason.GetDelta())
+ << "ms" << " | " << l_ModuleListIterator->pid << endl;
+ // LCOV_EXCL_BR_STOP
+ }
+ }
+ }
+
+ l_debugDumpBuf << endl << " ***Heartbeat information***" << endl;
+
+ l_debugDumpBuf << endl << " Entire State:" << m_HBReport.eEntireState << endl; // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+
+ l_debugDumpBuf << endl << " Number of Modules:" << m_HBReport.nNumOfModules << endl;
+
+ for (UI_32 j = 0; j < m_HBReport.nNumOfModules; j++) { // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ // 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
+ if (0 != m_HBReport.tModuleList[j].HeartBeatRetryCount) {
+ l_debugDumpBuf << endl << " " << m_HBReport.tModuleList[j].ProcQueueName << ","
+ << m_HBReport.tModuleList[j].ProcHBState << ", "
+ << m_HBReport.tModuleList[j].HeartBeatRetryCount << endl;
+ }
+ // LCOV_EXCL_STOP
+ }
+
+ std::string l_debugDumpStr = l_debugDumpBuf.str();
+
+ SendDebugDumpResponseToSystemManager(l_debugDumpStr); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup OnProcessLaunchMonitorTimerExpiry
+/// This sends request to launcher thread to confirm that it
+/// is still responsive.
+///
+/// \param [in] hApp
+/// HANDLE - Handle of the Client Application
+///
+/// \return Status
+/// EFrameworkunifiedStatus - success or error
+///////////////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::OnProcessLaunchMonitorTimerExpiry(HANDLE hApp) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " Received from %s", FrameworkunifiedGetMsgSrc(hApp));
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+
+ REC_HIST_IF_SUCCESSFUL("TIMER_PROCESSLAUNCHER_MONITOR", m_TimerCmdHist, // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length)
+ m_TimerHistIter, FrameworkunifiedGetMsgSrc(hApp), l_eStatus); // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length)
+
+ // LCOV_EXCL_BR_START 4: nsfw error
+ if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedSendChild(hApp, m_hProcLauncherThread.m_ThreadHdl,
+ ePLThrdCmd_THREAD_STATUS_REQST, 0, NULL))) {
+ // LCOV_EXCL_BR_STOP 4: nsfw error
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ LOG_ERROR("FrameworkunifiedSendChild(m_hProcLauncherThread.m_ThreadHdl," // LCOV_EXCL_LINE 4: nsfw error
+ "ePLThrdCmd_THREAD_STATUS_REQST)"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ } else {
+ m_hProcLauncherThread.m_ThreadState = eSMWaitForHeartbeat;
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup SendRequestToLauncher
+/// This function is used for sending request to launcher thread from
+/// System Manager.
+///
+/// \param HANDLE hApp
+/// ModuleLaunchListIter f_ModuleListIterator => iterator node from map for the module
+/// ESMPLThreadCommandIds f_CommandId => command id to send
+/// SS_String f_ModulePath => Path of the Module
+///
+/// \return Status
+/// EFrameworkunifiedStatus - success or error
+///////////////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::PerformLaunchProcedure(HANDLE hApp,
+ ModuleLaunchListIter f_ModuleIterator, SS_String & f_stopCompName) {
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+
+ SS_String s_ModuleStatus2;
+
+ // Register for Stop Complete notification
+ if (!f_ModuleIterator->shutdown_critical) {
+ s_ModuleStatus2 = "is not shutdown_critical";
+ // LCOV_EXCL_BR_START 6: For setting the initialization conditions at SystemManager startup
+
+ } else if (eFrameworkunifiedStatusOK != (l_eStatus =
+ FrameworkunifiedSubscribeNotificationWithCallback(
+ hApp,
+ f_stopCompName.c_str(),
+ SysMgrCallback<CSystemManager, &CSystemManager::OnModuleStopCompleteNotification>))) {
+ // LCOV_EXCL_BR_STOP
+ // LCOV_EXCL_START 6: For setting the initialization conditions at SystemManager startup
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error: FrameworkunifiedSubscribeNotificationWithCallback(hApp, %s) errored: %d/'%s'",
+ f_stopCompName.c_str(), l_eStatus, GetStr(l_eStatus).c_str());
+
+ s_ModuleStatus2 = "is shutdown_critical but errored";
+ // LCOV_EXCL_STOP
+ } else {
+ s_ModuleStatus2 = f_stopCompName + " is now registered"; // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "%s", s_ModuleStatus2.c_str());
+
+ return l_eStatus;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup PerformTerminateProcedure
+/// Perform Procedure for Service Terminate.
+///
+/// \param HANDLE hApp
+/// ModuleLaunchListIter f_ModuleListIterator => iterator node from map for the module
+/// SS_String & f_availabilityName => Availability Name
+/// SS_String & f_stopCompName => Stop Complete Notification Name
+///
+/// \return Status
+/// EFrameworkunifiedStatus - success or error
+///////////////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::PerformTerminateProcedure(HANDLE hApp,
+ ModuleLaunchListIter f_ModuleIterator, SS_String & f_availabilityName,
+ SS_String & f_stopCompName) {
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+
+ // close session
+ f_ModuleIterator->SetModuleState(MODULE_STATE_INVALID);
+ f_ModuleIterator->pid = 0;
+ if (NULL != f_ModuleIterator->hsession) { // LCOV_EXCL_BR_LINE 200:hsession must not be NULL.
+ l_eStatus = FrameworkunifiedMcClose(f_ModuleIterator->hsession); // LCOV_EXCL_BR_LINE 4: nsfw error
+ if (eFrameworkunifiedStatusOK != l_eStatus) { // 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: FrameworkunifiedMcClose(%s) errored: %d/'%s'",
+ f_ModuleIterator->name.c_str(), l_eStatus, GetStr(l_eStatus).c_str());
+ // LCOV_EXCL_STOP
+ }
+ f_ModuleIterator->hsession = NULL;
+ }
+
+ // Availability
+ if (f_ModuleIterator->is_start_required) {
+ // Initialize Availability
+ HANDLE pPublishMq = McOpenSender(FRAMEWORKUNIFIED_NS_NPSERVICE); // LCOV_EXCL_BR_LINE 4: nsfw error
+ if (NULL == pPublishMq) { // LCOV_EXCL_BR_LINE 4: nsfw error
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ SS_ASERT(0); // LCOV_EXCL_LINE 4: nsfw error
+ } else {
+ ServiceAvailability tServiceAvailability;
+
+ snprintf(tServiceAvailability.cServiceName, MAX_NAME_SIZE_APP, "%s",
+ f_ModuleIterator->name.c_str());
+ tServiceAvailability.eServiceAvailability = eFrameworkunifiedServiceNotAvailable;
+
+ l_eStatus = NPPublishNotification(pPublishMq, f_ModuleIterator->name.c_str(), // LCOV_EXCL_BR_LINE 4: nsfw error
+ f_availabilityName.c_str(), &tServiceAvailability, // LCOV_EXCL_BR_LINE 4: nsfw error
+ sizeof(tServiceAvailability)); // LCOV_EXCL_BR_LINE 4: nsfw error
+ if (eFrameworkunifiedStatusOK != l_eStatus) { // 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: NPPublishNotification(%s)",
+ f_availabilityName.c_str());
+ // LCOV_EXCL_STOP
+ }
+
+ l_eStatus = McClose(pPublishMq); // LCOV_EXCL_BR_LINE 4: nsfw error
+ if (eFrameworkunifiedStatusOK != l_eStatus) {
+ // 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
+ }
+ }
+ }
+
+ if (f_ModuleIterator->shutdown_critical) {
+ // Unregister Stop Complete notification
+ if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedUnsubscribeNotificationWithCallback(hApp, f_stopCompName.c_str()))) { // LCOV_EXCL_BR_LINE 4: nsfw error // NOLINT(whitespace/line_length)
+ // LCOV_EXCL_START 4: nsfw error
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error: FrameworkunifiedUnsubscribeNotificationWithCallback(hApp, %s) errored: %d/'%s'",
+ f_stopCompName.c_str(), l_eStatus, GetStr(l_eStatus).c_str());
+ // LCOV_EXCL_STOP
+ } else {
+ SS_String s_ModuleStatus2 = f_stopCompName + " is now unregistered ";
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "%s", s_ModuleStatus2.c_str());
+ }
+ }
+
+ return l_eStatus;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup SendRequestToLauncher
+/// This function is used for sending request to launcher thread from
+/// System Manager.
+///
+/// \param HANDLE hApp
+/// ModuleLaunchListIter f_ModuleListIterator => iterator node from map for the module
+/// ESMPLThreadCommandIds f_CommandId => command id to send
+/// SS_String f_ModulePath => Path of the Module
+///
+/// \return Status
+/// EFrameworkunifiedStatus - success or error
+///////////////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::SendRequestToLauncher(HANDLE hApp,
+ ModuleLaunchListIter f_ModuleIterator, ESMPLThreadCommandIds f_CommandId,
+ SS_String f_CommandIdStr) {
+ EFrameworkunifiedStatus l_eStatus;
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ SS_String l_ModulePath = m_BinaryFilesPath + f_ModuleIterator->path;
+
+ T_ProcessLauncherLaunchReq l_ModuleLaunchReq = { };
+ strcpy(l_ModuleLaunchReq.name, f_ModuleIterator->name.c_str()); // NOLINT
+ strcpy(l_ModuleLaunchReq.path, l_ModulePath.c_str()); // NOLINT
+ strncpy(l_ModuleLaunchReq.args, f_ModuleIterator->arguments.c_str(), // NOLINT
+ sizeof(l_ModuleLaunchReq.args) - 1);
+ strcpy(l_ModuleLaunchReq.logging_mask, // NOLINT
+ f_ModuleIterator->logging_msk_str.c_str());
+ l_ModuleLaunchReq.priority = f_ModuleIterator->configuration_priority;
+ l_ModuleLaunchReq.cpu_assign = f_ModuleIterator->cpu_assign;
+ l_ModuleLaunchReq.groupIterator = m_MapProclaunchGrps.find(
+ f_ModuleIterator->group_id);
+ l_ModuleLaunchReq.moduleIterator = f_ModuleIterator;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
+ "Queue:%s, path:%s, args:%s, lmsk:%s, prio:%d, cmd:%s", l_ModuleLaunchReq.name,
+ l_ModuleLaunchReq.path, l_ModuleLaunchReq.args, l_ModuleLaunchReq.logging_mask,
+ l_ModuleLaunchReq.priority, f_CommandIdStr.c_str());
+
+ if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedSendChild(hApp, m_hProcLauncherThread.m_ThreadHdl, f_CommandId, sizeof(l_ModuleLaunchReq), reinterpret_cast<void *>(&l_ModuleLaunchReq)))) { // LCOV_EXCL_BR_LINE 4: Because an initialization condition is set at SystemManager startup and the branching condition cannot be satisfied // NOLINT(whitespace/line_length)
+ // LCOV_EXCL_START 4: Because an initialization condition is set at SystemManager startup and the branching condition cannot be satisfied
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error: FrameworkunifiedSendChild( %s, %s ) errored: %d/'%s'", l_ModulePath.c_str(),
+ f_CommandIdStr.c_str(), l_eStatus, GetStr(l_eStatus).c_str());
+ // LCOV_EXCL_STOP
+ } else {
+ SS_String l_availabilityName = f_ModuleIterator->name + "/Availability"; // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ SS_String l_stopCompName = f_ModuleIterator->name + "/StopComp"; // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ // Perform command-specific processing
+ switch (f_CommandId) { // LCOV_EXCL_BR_LINE 6: Because the case is fixed on the call from the SystemManager::Initialize
+ // LCOV_EXCL_START 6: Because the case is fixed on the call from the SystemManager::Initialize
+ case ePLThrdCmd_RELAUNCH_MODULE_REQST:
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ l_eStatus = PerformTerminateProcedure(hApp, f_ModuleIterator,
+ l_availabilityName, l_stopCompName);
+ if (eFrameworkunifiedStatusOK != l_eStatus) {
+ SS_ASERT(0);
+ }
+
+ l_eStatus = PerformLaunchProcedure(hApp, f_ModuleIterator, l_stopCompName);
+ if (eFrameworkunifiedStatusOK != l_eStatus) {
+ SS_ASERT(0);
+ }
+ break;
+ // LCOV_EXCL_STOP
+
+ case ePLThrdCmd_LAUNCH_MODULE_REQST:
+ l_eStatus = PerformLaunchProcedure(hApp, f_ModuleIterator, l_stopCompName);
+ if (eFrameworkunifiedStatusOK != l_eStatus) { // LCOV_EXCL_BR_LINE 6: For setting the initialization conditions at SystemManager startup
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ SS_ASERT(0); // LCOV_EXCL_LINE 6: For setting the initialization conditions at SystemManager startup
+ }
+ break;
+
+ case ePLThrdCmd_TERMINATE_MODULE_REQST:
+ l_eStatus = PerformTerminateProcedure(hApp, f_ModuleIterator,
+ l_availabilityName, l_stopCompName); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ if (eFrameworkunifiedStatusOK != l_eStatus) {
+ SS_ASERT(0); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ }
+ break;
+
+ // LCOV_EXCL_START 6: Because the case is fixed on the call from the SystemManager::Initialize
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ case ePLThrdCmd_LAUNCH_MODULE_RESP:
+ case ePLThrdCmd_MODULE_STATUS_REQST:
+ case ePLThrdCmd_RELAUNCH_MODULE_RESP:
+ case ePLThrdCmd_TERMINATE_MODULE_RESP:
+ case ePLThrdCmd_THREAD_STATUS_REQST:
+ case ePLThrdCmd_THREAD_STATUS_RESP:
+ case ePLThrdCmd_NONE:
+ 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.
+ // LCOV_EXCL_STOP
+ }
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+} // End of EFrameworkunifiedStatus CSystemManager::SendRequestToLauncher(
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup RemoveModuleEntryFromHB
+/// This function is called to send module information to heart beat thread
+/// which is to be removed from its list of services to be monitored.
+///
+/// \param HANDLE hApp,
+/// const CHAR *f_ModuleName => Module Name
+///
+/// \return Status
+/// EFrameworkunifiedStatus - success or error
+///////////////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::RemoveModuleEntryFromHB(HANDLE hApp, const CHAR *f_ModuleName) {
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+
+ HBListIter l_HBIter = std::find(m_HBList.begin(), m_HBList.end(), f_ModuleName);
+ if (l_HBIter != m_HBList.end()) {
+ m_HBList.erase(l_HBIter);
+ }
+
+ TSMRequestMessage l_ModuleDetails;
+ strncpy(l_ModuleDetails.pstModuleName, f_ModuleName,
+ sizeof(l_ModuleDetails.pstModuleName) - 1);
+ l_ModuleDetails.pstModuleName[sizeof(l_ModuleDetails.pstModuleName) - 1] = '\0';
+ l_eStatus = SendRequestToHeartBeat(hApp, SS_HEARTBEAT_DELETE_MODULE_ENTRY,
+ &l_ModuleDetails, sizeof(TSMRequestMessage));
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup OnHeartBeatThreadHeartbeatResponse
+/// This function gets called when heart beat thread replies the
+/// heart beat query sent by the System Manager.
+/// \param [in] hApp
+/// HANDLE - Handle of the Client Application
+///
+/// \return Status
+/// EFrameworkunifiedStatus - success or error
+///////////////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::OnHeartBeatThreadHeartbeatResponse(HANDLE hApp) {
+ FRAMEWORKUNIFIEDLOG(ZONE_PERIODIC_INFO, __FUNCTION__, "HeartBeat HeartBeat Received");
+ m_hHeartbeatThread.m_ThreadState = eSMThreadIsFine;
+ return eFrameworkunifiedStatusOK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup OnCheckAvailResponse
+/// This function gets service's availability status from HBThread
+/// \param [in] hApp
+/// HANDLE - Handle of the Client Application
+///
+/// \return Status
+/// EFrameworkunifiedStatus - success or error
+///////////////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::OnCheckAvailResponse(HANDLE hApp) {
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ THbAvailCheck result;
+
+ if (eFrameworkunifiedStatusOK != (l_eStatus = ReadMsg < THbAvailCheck > (hApp, result))) {
+ LOG_ERROR("ReadMsg()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_tempaltes.h // NOLINT(whitespace/line_length)
+ } else if (result.isOk == FALSE) {
+ }
+ return eFrameworkunifiedStatusOK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup OnProcessLauncherThreadHeartbeatResponse
+/// This function gets called when launcher thread replies the
+/// heart beat query sent by the System Manager.
+/// \param [in] hApp
+/// HANDLE - Handle of the Client Application
+///
+/// \return Status
+/// EFrameworkunifiedStatus - success or error
+///////////////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::OnProcessLauncherThreadHeartbeatResponse(HANDLE hApp) {
+ FRAMEWORKUNIFIEDLOG(ZONE_PERIODIC_INFO, __FUNCTION__, "ProcessLaunch HeartBeat Received");
+ m_hProcLauncherThread.m_ThreadState = eSMThreadIsFine;
+ return eFrameworkunifiedStatusOK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup RegisterCallbacksForRequester
+/// Register callbacks for External Protocol commands
+///
+/// \param [in]
+///
+///
+/// \return EFrameworkunifiedStatus
+/// Success ==> eFrameworkunifiedStatusOK
+/// Failure ==> Other values
+///////////////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::RegisterCallbacksForRequester(HANDLE hApp, PCSTR f_pRequester) {
+ EFrameworkunifiedStatus l_eStatus;
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+
+ // Attach Session Protocol messages.
+ FrameworkunifiedProtocolCallbackHandler l_sm_protocol_handlers[] = {
+ // Command ID, Call back functions
+ { SS_SM_START_COMPL_RSPN,
+ SysMgrCallback<CSystemManager, &CSystemManager::OnModuleStartCompleteResponse> },
+ { SS_SM_STOP_COMPL_RSPN,
+ SysMgrCallback<CSystemManager, &CSystemManager::OnModuleStopCompleteResponse> },
+ { SS_SM_PRE_START_COMPL_RSPN,
+ SysMgrCallback<CSystemManager, &CSystemManager::OnModuleStartCompleteResponse> },
+ { SS_SM_PRE_STOP_COMPL_RSPN,
+ SysMgrCallback<CSystemManager, &CSystemManager::OnModuleStartCompleteResponse> },
+ { SS_SM_BACKGROUND_START_COMPL_RSPN,
+ SysMgrCallback<CSystemManager, &CSystemManager::OnModuleStartCompleteResponse> },
+ { SS_SM_BACKGROUND_STOP_COMPL_RSPN,
+ SysMgrCallback<CSystemManager, &CSystemManager::OnModuleStartCompleteResponse> },
+ { SS_SM_GET_START_EXT_INFO, SysMgrCallback<CSystemManager,
+ &CSystemManager::OnGetStartExtInfo> },
+ { SS_SM_GET_STOP_EXT_INFO, SysMgrCallback<CSystemManager,
+ &CSystemManager::OnGetStopExtInfo> },
+ { SS_SM_CRNT_STATE_QUERY, SysMgrCallback<CSystemManager,
+ &CSystemManager::OnCurrentSMStateQuery> },
+ { SS_SM_DATA_RESET_MODE_SET_REQ, SysMgrCallback<CSystemManager,
+ &CSystemManager::OnSetDataResetModeRequest> },
+ { SS_SM_PROG_UPDATE_STATE_SET_REQ, SysMgrCallback<CSystemManager,
+ &CSystemManager::OnSetProgUpdateStateRequest> },
+
+ { SS_SM__CWORD56__HEARTBEAT_REQ, SysMgrCallback<CSystemManager,
+ &CSystemManager::On_CWORD56_HeartBeatRequest> },
+ { SS_SM_NEXT_WAKEUP_TYPE_SET_REQ, SysMgrCallback<CSystemManager,
+ &CSystemManager::OnSetNextWakeupTypeRequest> },
+ // Error Event Logging
+ { SS_SM_ERROR_EVENT_LOGGING_START_REQ, SysMgrCallback<CSystemManager,
+ &CSystemManager::OnLoggingStartRequest> },
+ { SS_SM_ERROR_EVENT_ARTIFACT_REQ, SysMgrCallback<CSystemManager,
+ &CSystemManager::OnErrorEventArtifactRequest> },
+ { SS_SM_ERROR_EVENT_LOGGING_COMPLETE, SysMgrCallback<CSystemManager,
+ &CSystemManager::OnErrorEventLoggingComplete> },
+ { SS_SM_DEBUG_DUMP_RSPN, SysMgrCallback<CSystemManager,
+ &CSystemManager::OnDebugDumpResponseReceived> },
+ { SS_SM_PROPAGATE_SYSTEM_ERROR, SysMgrCallback<CSystemManager,
+ &CSystemManager::OnPropagateSystemError> },
+ { SS_SM_BOOT_MICRO_RESET_NTF, SysMgrCallback<CSystemManager,
+ &CSystemManager::OnBootMicroResetNotification> },
+ { SS_SM_BOOT_MICRO_LOG_RSP, SysMgrCallback<CSystemManager,
+ &CSystemManager::OnBootMicroLogResponse> },
+ { SS_SM_USER_INVOKED_LOG_REQ, SysMgrCallback<CSystemManager,
+ &CSystemManager::OnUserInvokedLoggingRequest> },
+ { SS_SM_ERROR_EVENT_EEL_EXPORT_REQ, SysMgrCallback<CSystemManager,
+ &CSystemManager::OnEelExportRequest> },
+ { SS_SM_ERROR_EVENT_INTERFACEUNIFIED_EMMC_LOGS_REQ, SysMgrCallback<CSystemManager,
+ &CSystemManager::OnSystemmanagerEmmcLogsRequest> },
+ { SS_SM_ERROR_EVENT_CLR_LOGS_REQ, SysMgrCallback<CSystemManager,
+ &CSystemManager::OnSystemmanagerClearLogsRequest> },
+ { SS_SM_ERROR_EVENT_DIAG_LOG_REQ, SysMgrCallback<CSystemManager,
+ &CSystemManager::OnDiagLoggingRequest> },
+ { SS_SM_ERROR_EVENT_CAN_LOG_REQ, SysMgrCallback<CSystemManager,
+ &CSystemManager::OnCANLoggingRequest> } }; // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+
+ l_eStatus = FrameworkunifiedAttachCallbacksToDispatcher(hApp, f_pRequester,
+ l_sm_protocol_handlers, static_cast<UI_32>(_countof(l_sm_protocol_handlers))); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+
+ if (eFrameworkunifiedStatusOK != l_eStatus) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error: FrameworkunifiedAttachCallbacksToDispatcher(%s) errored: %d/'%s'", f_pRequester,
+ l_eStatus, GetStr(l_eStatus).c_str());
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+} // End of EFrameworkunifiedStatus CSystemManager::RegisterCallbacksForRequester( HANDLE hApp, PCSTR f_pRequester)
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup open_session_with_sm_test_client
+/// Process request to open session with sm test client
+///
+/// \param [in]
+///
+///
+/// \return EFrameworkunifiedStatus
+/// Success ==> eFrameworkunifiedStatusOK
+/// Failure ==> Other values
+///////////////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::open_session_with_sm_test_client(HANDLE hApp, PCSTR pRequester) {
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail;
+ UI_32 const l_ui32DefaultSessionID = 0;
+ OpenSessionAck tOpenAck = { };
+
+/*
+ * Here pRequester is SMTesteClient with whom session is opened and its handle is stored in m_hPowerServiceSession handle.
+ * This case comes only while testing SystemManager through SMTestClient (PowerService should not be running).
+ */
+ // Validate session handle
+ if (NULL == m_hPowerServiceSession) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error: Session Handle NULL, calling FrameworkunifiedMcOpenSender for %s", pRequester);
+
+ m_hPowerServiceSession = FrameworkunifiedMcOpenSender(hApp, pRequester);
+ //
+ // Set the Session Handle for Framework so FrameworkunifiedSendResponse won't error due to a null
+ // session handle.
+ //
+ // LCOV_EXCL_BR_START 4:NSFW's error
+ if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedSetSessionHandle(hApp,
+ pRequester, // [in] PCSTR - Name of the associated service name
+ m_hPowerServiceSession))) { // [in] HANDLE - Session handle
+ // LCOV_EXCL_BR_STOP
+ // LCOV_EXCL_START 4:NSFW's error
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error: FrameworkunifiedSetSessionHandle(%s) errored: %d/'%s'", pRequester,
+ l_eStatus, GetStr(l_eStatus).c_str());
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+ // LCOV_EXCL_STOP
+ }
+ }
+
+ if (m_hPowerServiceSession == NULL) { // LCOV_EXCL_BR_LINE 200:m_hPowerServiceSession must not be NULL
+ // LCOV_EXCL_START 200:m_hPowerServiceSession must not be NULL
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error: Invalid Session Handle to service (%s) ", pRequester);
+ // LCOV_EXCL_STOP
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Session opened with %s", pRequester);
+
+ // Copy session name to data structure
+ strncpy(tOpenAck.cSessionName, FrameworkunifiedGetAppName(hApp),
+ sizeof(tOpenAck.cSessionName) - 1);
+ tOpenAck.eStatus = eFrameworkunifiedStatusOK;
+ tOpenAck.sessionId = l_ui32DefaultSessionID;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "About to send Open Session ACK");
+ // send OpenSession ACK
+ // LCOV_EXCL_BR_START 4:NSFW's error
+ if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedSendMsg(m_hPowerServiceSession,
+ PROTOCOL_OPEN_SESSION_ACK, sizeof(OpenSessionAck),
+ (PVOID) & tOpenAck))) {
+ // LCOV_EXCL_BR_STOP
+ // LCOV_EXCL_START 4:NSFW's error
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ LOG_ERROR("FrameworkunifiedSendMsg(PROTOCOL_OPEN_SESSION_ACK)");
+
+ // Close the message queue handle
+ if (NULL != m_hPowerServiceSession) {
+ CALL_AND_LOG_STATUS_IF_ERRORED(FrameworkunifiedMcClose(m_hPowerServiceSession));
+ m_hPowerServiceSession = NULL;
+ }
+ // LCOV_EXCL_STOP
+ } else {
+ CALL_AND_LOG_STATUS_IF_ERRORED(RegisterCallbacksForRequester(hApp, pRequester));
+ }
+ } // end of else block of if(l_ModuleListIterator->hsession == NULL)
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup OnOpenSession
+/// Process request to open session
+///
+/// \param [in]
+///
+///
+/// \return EFrameworkunifiedStatus
+/// Success ==> eFrameworkunifiedStatusOK
+/// Failure ==> Other values
+///////////////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::OnOpenSession(HANDLE hApp) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ UI_32 const l_ui32DefaultSessionID = 0;
+ UI_32 const l_ui32DefaultSessionType = 0;
+ OpenSessionAck tOpenAck = { };
+ PCSTR pRequester = FrameworkunifiedGetMsgSrc(hApp);
+ FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "%s", pRequester);
+
+ ModuleLaunchListIter l_ModuleListIter;
+
+ REC_HIST_IF_SUCCESSFUL("PROTOCOL_OPEN_SESSION_REQ", m_SMCmdHist, m_SMHistIter, // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length)
+ FrameworkunifiedGetMsgSrc(hApp), l_eStatus); // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length)
+
+ l_eStatus = GetModuleIterator(pRequester, l_ModuleListIter);
+
+ if (eFrameworkunifiedStatusOK != l_eStatus) {
+ // Special handling for open session request from SMTestClient.
+ if ((0 == strcmp(TC_SysManager, pRequester))) {
+ open_session_with_sm_test_client(hApp, pRequester);
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: %s not found in Group Launch Map",
+ pRequester);
+ }
+ } else {
+ /**********************************************************************/
+ if (0 != l_ModuleListIter->pid) {
+ UI_32 l_ClientPriority;
+ l_eStatus = l_ModuleListIter->GetPriority(l_ClientPriority);
+
+ if (eFrameworkunifiedStatusOK != l_eStatus) {
+ LOG_ERROR("l_ModuleListIter->GetPriority( l_ClientPriority )"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ } else if (l_ClientPriority != l_ModuleListIter->configuration_priority) {
+ FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, " Changing %s's priority from %d to %d",
+ pRequester, l_ClientPriority,
+ l_ModuleListIter->configuration_priority);
+ CALL_AND_LOG_STATUS_IF_ERRORED( // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ l_ModuleListIter->SetPriority( // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ l_ModuleListIter->configuration_priority)); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ }
+ }
+ /**********************************************************************/
+
+ // ToDo Jay 2013 Jan 09 REPLACE WITH CORRECT SERVICE / SESSION HANDLE
+ // LOGIC
+ // validate session handle
+ if (NULL == l_ModuleListIter->hsession) {
+ // LCOV_EXCL_BR_START 4: nsfw error
+ if (NULL == (l_ModuleListIter->hsession = FrameworkunifiedMcOpenSender(hApp, pRequester))) {
+ // LCOV_EXCL_BR_STOP 4: nsfw error
+ // LCOV_EXCL_START 4: nsfw error
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error: FrameworkunifiedMcOpenSender(App %s, %s) returned NULL",
+ FrameworkunifiedGetAppName(hApp), pRequester);
+ return eFrameworkunifiedStatusInvldHandle;
+ // LCOV_EXCL_STOP
+ }
+ } else {
+ /*
+ * Currently System Manager does not support multiple sessions from same client.
+ * When a client gets restarted after Crash or after missing HeartBeat, System Manager
+ * would receive OpenSession request from that client even when System Manager already
+ * has a open session with that client.
+ */
+ FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__,
+ " Warning: Repeated Session Opening Request from %s", pRequester);
+ }
+ if (eFrameworkunifiedStatusOK != (l_eStatus = RegisterCallbacksForRequester(hApp, pRequester))) {
+ // Close the message queue handle
+ if (NULL != l_ModuleListIter->hsession) { // LCOV_EXCL_BR_LINE 6: Due to NULL checking
+ if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedMcClose(l_ModuleListIter->hsession))) {
+ LOG_ERROR("FrameworkunifiedMcClose()"); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ }
+ l_ModuleListIter->hsession = NULL;
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+ }
+
+ // Copy session name to data structure
+ strncpy(tOpenAck.cSessionName, FrameworkunifiedGetAppName(hApp), sizeof(tOpenAck.cSessionName) - 1);
+ tOpenAck.eStatus = eFrameworkunifiedStatusOK;
+ tOpenAck.sessionId = l_ui32DefaultSessionID;
+ tOpenAck.sessionType = l_ui32DefaultSessionType;
+
+ // send OpenSession ACK
+ // LCOV_EXCL_BR_START 4: nsfw error
+ if (eFrameworkunifiedStatusOK
+ != (l_eStatus = FrameworkunifiedSendMsg(l_ModuleListIter->hsession,
+ SS_SM_PROTOCOL_OPEN_SESSION_ACK, sizeof(OpenSessionAck),
+ (PVOID) & tOpenAck))) { // LCOV_EXCL_BR_STOP
+ // LCOV_EXCL_START 4: nsfw error
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error: FrameworkunifiedSendMsg( %s, SS_SM_PROTOCOL_OPEN_SESSION_ACK)"
+ " errored: %d/'%s'", l_ModuleListIter->name.c_str(), l_eStatus,
+ GetStr(l_eStatus).c_str());
+
+ if (NULL != l_ModuleListIter->hsession) {
+ // Close the message queue handle
+ if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedMcClose(l_ModuleListIter->hsession))) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error: FrameworkunifiedMcClose(%s) errored: %d/'%s'",
+ l_ModuleListIter->name.c_str(), l_eStatus,
+ GetStr(l_eStatus).c_str());
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ }
+ l_ModuleListIter->hsession = NULL;
+ }
+ // LCOV_EXCL_STOP
+ } else {
+ // Store PowerService session handle in class so it can be accessed faster
+ // to use opened session while replying to PowerService.
+ if ((0 == strcmp(SERVICE_POWER, pRequester))) {
+ m_hPowerServiceSession = l_ModuleListIter->hsession;
+ }
+
+ l_ModuleListIter->SetModuleState(MODULE_STATE_CONNECTED);
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " SM State: %s, %s.is_start_required: %s",
+ GetStr(m_SMCurrentState).c_str(), l_ModuleListIter->name.c_str(),
+ GetStr(l_ModuleListIter->is_start_required).c_str());
+
+ if (l_ModuleListIter->is_start_required
+ && ((SS_SM_APPS_START_IN_PROGRESS == m_SMCurrentState)
+ || (SS_SM_APPS_START_COMPLETE == m_SMCurrentState))) {
+ 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);
+ const UI_32 l_iCmd = InProgressStateToSendMsg();
+ if (l_iCmd != SS_SYSTEM_MANAGER_PROTOCOL_ENDING_INDEX) {
+ CALL_AND_LOG_STATUS_IF_ERRORED(l_ModuleListIter->SendMsgAndUpdateState(l_iCmd, &f_startupData)); // LCOV_EXCL_BR_LINE 11: Gcov constraints (because exception-handling routes are automatically generated) // NOLINT(whitespace/line_length)
+ }
+ }
+ }
+ }
+
+ if (eFrameworkunifiedStatusOK == l_eStatus) {
+ std::string l_Subscriber;
+ l_Subscriber = FrameworkunifiedGetMsgSrc(hApp);
+
+ // check if the heart beat subscriber is already in list
+ HBListIter l_HBIter = std::find(m_HBList.begin(), m_HBList.end(), l_Subscriber);
+ if (l_HBIter == m_HBList.end()) {
+ m_HBList.push_back(l_Subscriber);
+ }
+ if (m_SMCurrentState == SS_SM_APPS_START_COMPLETE) {
+ TSMRequestMessage l_ModuleDetails;
+ snprintf(l_ModuleDetails.pstModuleName, sizeof(l_ModuleDetails.pstModuleName),
+ "%s", l_Subscriber.c_str());
+ l_eStatus = SendRequestToHeartBeat(hApp, SS_HEARTBEAT_APPEND_MODULE_ENTRY,
+ &l_ModuleDetails, sizeof(TSMRequestMessage));
+ LOG_ERROR_REC_HIST_IF_ERRORED(l_eStatus, "SendRequestToHeartBeat()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ }
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
+
+///////////////////////////////////////////////////////////////////////
+/// ConstructGetResultResponse
+///
+///
+//////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::add_state_information_to_response(CHAR *f_MessageResponse) const {
+ const CHAR ReadyToLaunchAppDescription[] = "_READY_TO_LAUNCH:";
+ const CHAR StartInProgressDescription[] = "_START_IN_PROGRESS:";
+ const CHAR LaunchInProgressDescription[] = "_LAUNCH_IN_PROGRESS:";
+ const CHAR LaunchedReadyToStartDescription[] = "_READY_TO_START:";
+ const CHAR StopInProgressDescription[] = "_STOP_IN_PROGRESS:";
+ const CHAR StartCompleteDescription[] = "_START_COMPLETED:";
+ const CHAR WaitingForCriticalAppsToStopDescription[] = "_WAITING_FOR_CRITICAL_APPS_TO_STOP:";
+ const CHAR PreStartInProgressDescription[] = "_PRE_START_IN_PROGRESS:";
+ const CHAR PreStopInProgressDescription[] = "_PRE_STOP_IN_PROGRESS:";
+ const CHAR PreRunCompleteDescription[] = "_PRE_RUN_COMPLETE:";
+ const CHAR BackgroundStartInProgressDescription[] = "_BACKGROUND_START_IN_PROGRESS:";
+ const CHAR BackgroundStopInProgressDescription[] = "_BACKGROUND_STOP_IN_PROGRESS:";
+ const CHAR BackgroundRunCompleteDescription[] = "_BACKGROUND_RUN_COMPLETE:";
+ EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusOK;
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ CHAR l_Buffer[5];
+ UI_32 l_Index = 0;
+
+ std::map<SS_SMModuleState, std::string> StateMap; // State Map
+ StateMap[SS_SM_READY_TO_LAUNCH_APP] = ReadyToLaunchAppDescription;
+ StateMap[SS_SM_APPS_LAUNCH_IN_PROGRESS] = LaunchInProgressDescription;
+ StateMap[SS_SM_APPS_LAUNCHED_READY_TO_START] = LaunchedReadyToStartDescription;
+ StateMap[SS_SM_APPS_START_IN_PROGRESS] = StartInProgressDescription;
+ StateMap[SS_SM_APPS_START_COMPLETE] = StartCompleteDescription;
+ StateMap[SS_SM_APPS_STOPPING_AT__CWORD56__REQ] = StopInProgressDescription;
+ StateMap[SS_SM_APPS_STOPPING_AT_INTERNAL_REQ] = StopInProgressDescription;
+ StateMap[SS_SM_WAITING_FOR_CRITICAL_APPS_AT_INTERNAL_REQ] =
+ WaitingForCriticalAppsToStopDescription;
+ StateMap[SS_SM_WAITING_FOR_CRITICAL_APPS_AT__CWORD56__REQ] =
+ WaitingForCriticalAppsToStopDescription;
+ StateMap[SS_SM_APPS_PRE_START_IN_PROGRESS] = PreStartInProgressDescription;
+ StateMap[SS_SM_APPS_PRE_STOP_IN_PROGRESS] = PreStopInProgressDescription;
+ StateMap[SS_SM_APPS_PRE_RUN_COMPLETE] = PreRunCompleteDescription;
+ StateMap[SS_SM_APPS_BACKGROUND_START_IN_PROGRESS] = BackgroundStartInProgressDescription;
+ StateMap[SS_SM_APPS_BACKGROUND_STOP_IN_PROGRESS] = BackgroundStopInProgressDescription;
+ StateMap[SS_SM_APPS_BACKGROUND_RUN_COMPLETE] = BackgroundRunCompleteDescription;
+
+ itoa(m_SMCurrentState, l_Buffer, 16);
+ while (l_Buffer[l_Index]) {
+ l_Buffer[l_Index] = toupper(l_Buffer[l_Index]);
+ l_Index++;
+ }
+
+ if (SS_SM_MAX_RESP_MSG_SIZE > (strlen(f_MessageResponse) + sizeof(l_Buffer)
+ + StateMap[m_SMCurrentState].length() + 1)) {
+ strncat(f_MessageResponse, l_Buffer, sizeof(l_Buffer));
+ strncat(f_MessageResponse, StateMap[m_SMCurrentState].c_str(),
+ StateMap[m_SMCurrentState].length());
+ } else {
+ eStatus = eFrameworkunifiedStatusFail;
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return eStatus;
+}
+
+///////////////////////////////////////////////////////////////////////
+/// ConstructGetResultResponse
+///
+///
+//////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::construct_get_result_response(CHAR *f_MessageResponse) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ const EFrameworkunifiedStatus eStatus = add_state_information_to_response(f_MessageResponse);
+ if (eFrameworkunifiedStatusOK == eStatus) {
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Response Constructed");
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return eStatus;
+}
+
+///////////////////////////////////////////////////////////////////////
+/// REC_HIST_IF_SUCCESSFUL / SetCmdHist
+///
+///
+//////////////////////////////////////////////////////////////////////
+void CSystemManager::SetCmdHist(std::string cmd, cmdHist &hist, cmdHistIter &it, std::string sender) {
+ UI_64 l_time = 0XDEAD;
+ CTimeSpan* timerClass = new (std::nothrow) CTimeSpan(); // LCOV_EXCL_BR_LINE 5: Because new cannot fail
+ if (NULL == timerClass) { // LCOV_EXCL_BR_LINE 5: Because new cannot fail
+ // LCOV_EXCL_START 5: Because new cannot fail
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " 'new (std::nothrow) CTimeSpan()' returned NULL, "
+ "'it->m_time' being set to 0xDEAD");
+ // LCOV_EXCL_STOP
+ } else {
+ l_time = timerClass->GetTimeMilliseconds();
+ }
+
+ pthread_mutex_lock(&sm_hist_mutex);
+
+ it->m_time = l_time;
+ it->m_cmd = cmd;
+ it->m_sender = sender;
+ it++;
+
+ if (it != hist.end()) { // LCOV_EXCL_BR_LINE 5: std: because it is a member of a vector and it is difficult to create a failing condition
+ it = hist.begin();
+ }
+
+ pthread_mutex_unlock(&sm_hist_mutex);
+
+ delete timerClass; // LCOV_EXCL_BR_LINE 5: Because the delete cannot fail
+}
+
+///////////////////////////////////////////////////////////////////////
+/// OnCurrentPowerStateQuery
+///
+///
+//////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::OnCurrentSMStateQuery(HANDLE hApp) {
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp);
+ FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "Received from %s", FrameworkunifiedGetMsgSrc(hApp));
+
+ SS_SMCurrentState l_CurrentState;
+
+ REC_HIST_IF_SUCCESSFUL("SS_SM_CRNT_STATE_QUERY", m_SMCmdHist, m_SMHistIter,
+ FrameworkunifiedGetMsgSrc(hApp), l_eStatus);
+ if (eFrameworkunifiedStatusOK != (l_eStatus = ReadMsg < SS_SMCurrentState > (hApp, l_CurrentState))) {
+ LOG_ERROR("ReadMsg()"); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ } else {
+ construct_get_result_response(l_CurrentState.respMsgString);
+
+ ModuleLaunchListIter l_ModuleListIter;
+ PCSTR l_moduleName = FrameworkunifiedGetMsgSrc(hApp);
+ if (eFrameworkunifiedStatusOK != (l_eStatus = GetModuleIterator(l_moduleName, l_ModuleListIter))) { // LCOV_EXCL_BR_LINE 200: can not be other value // NOLINT (whitespace/line_length)
+ // LCOV_EXCL_START 200: can not be other value
+ 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);
+ // LCOV_EXCL_STOP
+ } else if (l_ModuleListIter->hsession != NULL) { // LCOV_EXCL_BR_LINE 200: can not be NULL // NOLINT (whitespace/line_length)
+ if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedSendMsg(l_ModuleListIter->hsession, // LCOV_EXCL_BR_LINE 4: nsfw error
+ SS_SM_CRNT_STATE_QUERY_RSPN, sizeof(SS_SMCurrentState),
+ (PVOID) & l_CurrentState))) {
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ LOG_ERROR("FrameworkunifiedSendMsg(SS_SM_CRNT_STATE_QUERY_RSPN)"); // LCOV_EXCL_LINE 4: nsfw error
+ }
+ } else {
+ // LCOV_EXCL_START 200: can not be NUL
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " NULL == hsession; %s not connected yet",
+ l_ModuleListIter->name.c_str());
+ // LCOV_EXCL_STOP
+ }
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
+
+EFrameworkunifiedStatus CSystemManager::GetVersionNumber(SS_VersionNumberType & f_VersionNumber) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eStatus;
+
+ CSMVersion cVersion;
+ if (eFrameworkunifiedStatusOK != (l_eStatus = cVersion.get_version(f_VersionNumber))) { // LCOV_EXCL_BR_LINE 6: For setting the initialization conditions at SystemManager startup // NOLINT(whitespace/line_length)
+ LOG_ERROR("cVersion.get_version()"); // LCOV_EXCL_BR_LINE 6: For setting the initialization conditions at SystemManager startup // NOLINT(whitespace/line_length)
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+} // End of EFrameworkunifiedStatus CSystemManager::GetVersionNumber( SS_VersionNumberType
+
+EFrameworkunifiedStatus CSystemManager::GetBuildInfo(std::string &f_BuildInfoStr) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eStatus;
+
+ CSMVersion cVersion;
+ if (eFrameworkunifiedStatusOK != (l_eStatus = cVersion.get_build_info(f_BuildInfoStr))) { // LCOV_EXCL_BR_LINE 6: For setting the initialization conditions at SystemManager startup // NOLINT(whitespace/line_length)
+ LOG_ERROR("cVersion.get_build_info()"); // LCOV_EXCL_BR_LINE 6:For setting the initialization conditions at SystemManager startup // NOLINT(whitespace/line_length)
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+} // End of EFrameworkunifiedStatus CSystemManager::GetBuildInfo(std::string)
+
+bool CSystemManager::GetDramPowerStatusInfo(const HANDLE h_app) {
+ PsmDramStsT l_dram_sts = PSM_DRAM_STS_NORMAL;
+ bool ret = false;
+
+ // Checking dram power status.
+ if (PsmGetDramPowerSupplyAbnormalityCheckResultPower(h_app, &l_dram_sts))
+ return ret;
+
+ if (l_dram_sts == PSM_DRAM_STS_NORMAL)
+ ret = true;
+
+ return ret;
+}
+
+bool CSystemManager::GetDramStoreStatusInfo(const HANDLE h_app) {
+ PsmSysupDramT l_dram1 = PSM_SYSUP_DRAM_NORMAL;
+ PsmSysupDramT l_dram2 = PSM_SYSUP_DRAM_NORMAL;
+ PsmSysupDramT l_dram3 = PSM_SYSUP_DRAM_NORMAL;
+ PsmStartStatusT l_sts = PSM_START_STATUS_FACTRESET;
+
+ bool ret = false;
+
+ // Checking factory shipment status
+ if (PsmGetStartStatusPower(h_app, &l_sts))
+ return ret;
+
+ if (l_sts == PSM_START_STATUS_FACTRESET) {
+ ret = true;
+ goto finish;
+ }
+
+ // Checking dram power
+ if (!GetDramPowerStatusInfo(h_app))
+ goto finish;
+
+ // Checking dram status.
+ if (PsmGetDramBackupStatusPower(h_app, &l_dram1, &l_dram2, &l_dram3))
+ goto finish;
+
+ // l_dram2 and l_dram3 would be ignored.
+ if (l_dram1 == PSM_SYSUP_DRAM_NORMAL)
+ ret = true;
+
+ if (l_dram2 == PSM_SYSUP_DRAM_SFTERRSR)
+ ret = true;
+
+finish:
+ return ret;
+}
+
+bool CSystemManager::GetSyscomPowerStatusInfo(const HANDLE h_app) {
+ PsmComStsT l_syscom_sts = PSM_COM_STS_NORMAL;
+ bool ret = false;
+
+ if (PsmGetSyscomStatusPower(h_app, &l_syscom_sts))
+ return ret;
+
+ if (l_syscom_sts == PSM_COM_STS_NORMAL)
+ ret = true;
+
+ return ret;
+}
+
+EFrameworkunifiedStatus CSystemManager::OnSetStartupConfirmationDataRequest(HANDLE hApp) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "from %s", FrameworkunifiedGetMsgSrc(hApp));
+ EFrameworkunifiedStatus l_eStatus;
+ Pwr_ServiceSetInterface tServiceSetIf;
+ // 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, tServiceSetIf))) { // LCOV_EXCL_BR_LINE 4:NSFW's error
+ // LCOV_EXCL_START 4:NSFW's 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_startUpConfirmationMsg = tServiceSetIf.data.startupConfirmationMsg;
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " %s Startup Confirmation data:", FrameworkunifiedGetMsgSrc(hApp));
+ SYSTEMMANAGERLOG_StartupConfirmationMsg(m_startUpConfirmationMsg); // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length)
+ DGCODE_RET_API l_ret = DGCODE_RET_ERROR;
+
+ l_ret = Diag_StartupAllStatusOfDTC();
+ if (l_ret == DGCODE_RET_ERROR) {
+ LOG_ERROR("Diag_StartupAllStatusOfDTC()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ }
+
+ if ((e_SS_SM_NEXT_WAKEUP_TYPE_COLD == m_NextWakeupType) && (epsstCOLDSTART != m_startUpConfirmationMsg.wakeupType)) { // LCOV_EXCL_BR_LINE 6: Because the above formula cannot be set to true // NOLINT(whitespace/line_length)
+ // LCOV_EXCL_START 6: Because the condition cannot be set
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "WakeupType Change to Cold by Svc Request");
+ m_startUpConfirmationMsg.wakeupType = epsstCOLDSTART;
+ // LCOV_EXCL_STOP
+ }
+
+ m_ResetStatus = ((m_isIlgReset == TRUE) ?
+ e_SS_SM_RESET_STATUS_NG :
+ ((m_isImmediateReset == TRUE) ?
+ e_SS_SM_RESET_STATUS_IMMEDIATE : e_SS_SM_RESET_STATUS_NONE));
+ if (e_SS_SM_RESET_STATUS_NG == m_ResetStatus) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __PRETTY_FUNCTION__,
+ "ResetStatus NG illRst:%s lastErr:Not Support",
+ m_isIlgReset ? "TRUE" : "FALSE");
+ m_ResetCount++;
+ if (PowerHalSetResetInfo(AGL_RESET_COUNTER, m_ResetCount)) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "Could not back up m_ResetCount(%lu) to power_hal", m_ResetCount);
+ }
+ }
+
+ m_DramBackupStatus =
+ ((epsstWARMSTART != m_startUpConfirmationMsg.wakeupType)
+ || (e_SS_SM_DATA_RESET_MODE_FACTORY == m_DataResetMode)
+ || (GetDramStoreStatusInfo(hApp) == false)) ?
+ e_SS_SM_DRAM_BACKUP_NG : e_SS_SM_DRAM_BACKUP_OK;
+
+ if (e_SS_SM_DRAM_BACKUP_NG == m_DramBackupStatus) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __PRETTY_FUNCTION__,
+ "DramBackup NG wakeupType:%s dataResetMode:%s",
+ (epsstWARMSTART == m_startUpConfirmationMsg.wakeupType) ?
+ "WARM" : "COLD",
+ (e_SS_SM_DATA_RESET_MODE_FACTORY == m_DataResetMode) ?
+ "FACTORY" : "NotFactory");
+ }
+
+ if (m_needReNotifyStartPrm) { // LCOV_EXCL_BR_LINE 6: Because the condition cannot be satisfied from the external API
+ // LCOV_EXCL_BR_START 6: Because both sides are not FALSE
+ if (e_SS_SM_DRAM_BACKUP_NG == m_DramBackupStatus) {
+ // LCOV_EXCL_BR_STOP
+ m_DramBackupStatus = e_SS_SM_DRAM_BACKUP_NG;
+ }
+ }
+
+ if (m_needReNotifyStartPrm) { // LCOV_EXCL_BR_LINE 6: Because the condition cannot be satisfied from the external API
+ if (e_SS_SM_RESET_STATUS_NG == m_ResetStatus) {
+ // do nothing, keep m_ResetStatus.
+ } else if (e_SS_SM_RESET_STATUS_IMMEDIATE == m_ResetStatus) {
+ // do nothing, keep m_ResetStatus.
+ } else {
+ m_ResetStatus = e_SS_SM_RESET_STATUS_NONE;
+ }
+
+ if (epsstWARMSTART != m_startUpConfirmationMsg.wakeupType) { // LCOV_EXCL_BR_LINE 6: Because the above condition cannot be satisfied // NOLINT(whitespace/line_length)
+ m_startUpConfirmationMsg.wakeupType = epsstCOLDSTART;
+ }
+ }
+
+ CALL_AND_LOG_STATUS(ClearDramBackupInfo(hApp)); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+
+ FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "\n"
+ "start prm\n"
+ "dramBackupStatus = %s\n"
+ "wakeupType = %s\n"
+ "dataResetMode = %s\n"
+ "resetStatus = %s\n"
+ "resetCount = %d\n"
+ "progUpdateState = %d",
+ (m_DramBackupStatus == e_SS_SM_DRAM_BACKUP_OK) ? "OK" : "NG",
+ (m_startUpConfirmationMsg.wakeupType == epsstWARMSTART) ? "WARM" : "COLD",
+ (m_DataResetMode == e_SS_SM_DATA_RESET_MODE_FACTORY) ? "FACT" :
+ (m_DataResetMode == e_SS_SM_DATA_RESET_MODE_USER) ? "USER" :
+ (m_DataResetMode == e_SS_SM_DATA_RESET_MODE_PROGUPDATE) ? "PROG" : "NONE",
+ (m_ResetStatus == e_SS_SM_RESET_STATUS_IMMEDIATE) ? "IMM" :
+ (m_ResetStatus == e_SS_SM_RESET_STATUS_NONE) ? "NONE" : "NG", m_ResetCount,
+ m_ProgUpdateState);
+
+ if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedNPPublishNotification(hApp, NTFY_SSSystemMgrStartUpType, &m_startUpConfirmationMsg.wakeupType, sizeof(EPWR_SC_WAKEUP_TYPE)))) { // 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
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error: FrameworkunifiedNPPublishNotification(%s, %s) errored: %d/'%s'",
+ NTFY_SSSystemMgrStartUpType,
+ GetStr(m_startUpConfirmationMsg.wakeupType).c_str(), l_eStatus,
+ GetStr(l_eStatus).c_str());
+ // LCOV_EXCL_STOP
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " FrameworkunifiedNPPublishNotification(%s, %s) successful",
+ NTFY_SSSystemMgrStartUpType,
+ GetStr(m_startUpConfirmationMsg.wakeupType).c_str());
+
+ // LCOV_EXCL_BR_START 200: As there are no cases other than eFrameworkunifiedStatusOK
+ REC_HIST_IF_SUCCESSFUL("SM/StartUpType",
+ m_PubCmdHist, m_PubHistIter, "", l_eStatus);
+ // LCOV_EXCL_BR_STOP
+ }
+ }
+
+ EFrameworkunifiedStatus l_responseStatus = l_eStatus;
+
+ ModuleLaunchListIter l_ModuleListIter;
+ PCSTR l_moduleName = FrameworkunifiedGetMsgSrc(hApp);
+ if (eFrameworkunifiedStatusOK != (l_eStatus = GetModuleIterator(l_moduleName, l_ModuleListIter))) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error: Module %s not found in Group Launch Map", l_moduleName);
+ } else if (l_ModuleListIter->hsession != NULL) {
+ if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedSendMsg(l_ModuleListIter->hsession, // LCOV_EXCL_BR_LINE 4:NSFW's error
+ SS_SM_FWD_START_CONFIRMATION_MSG_RESP, sizeof(EFrameworkunifiedStatus),
+ (PVOID) & l_responseStatus))) {
+ // LCOV_EXCL_START 4:NSFW's error
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ LOG_ERROR("FrameworkunifiedSendMsg(SS_SM_FWD_START_CONFIRMATION_MSG_RESP)"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ // LCOV_EXCL_STOP
+ }
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " NULL == hsession; %s not connected yet", l_ModuleListIter->name.c_str());
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+} // End of EFrameworkunifiedStatus CSystemManager::OnSetStartupConfirmationDataRequest( HANDLE hApp )
+
+EFrameworkunifiedStatus CSystemManager::GetTimeStamp(std::string& TimeStamp) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+
+ CHAR format[256] = { '\0' };
+ CHAR l_format[256] = { '\0' };
+ struct timeb timebuf;
+ uint32_t time;
+ uint8_t status;
+ struct tm theTime;
+ ftime(&timebuf);
+ Clock_getSystemTimeY2K38(&time, &status);
+ CLOCK_RETURN clock_ret = Clock_CnvSecToDateY2K38(&time, &theTime);
+
+ if (CLOCK_OK != clock_ret) {
+ return eFrameworkunifiedStatusNullPointer;
+ }
+
+ sprintf(l_format, "GMT Time,%04d-%02d-%02d %02d:%02d:%02d.%hu\n", // NOLINT
+ theTime.tm_year + 1900, theTime.tm_mon + 1, theTime.tm_mday,
+ theTime.tm_hour, theTime.tm_min, theTime.tm_sec, timebuf.millitm);
+
+ struct timespec timeSpec;
+
+ if (0 != clock_gettime(CLOCK_MONOTONIC, &timeSpec)) {
+ SS_ASERT_ERRNO(0); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ } else {
+ time_t timeInSecs = timeSpec.tv_sec;
+ sprintf(format, "Elaps Time,%ld:%02ld:%02ld\n", (timeInSecs / 3600), // NOLINT
+ ((timeInSecs % 3600) / 60), (timeInSecs % 60));
+ }
+
+ TimeStamp.clear();
+ TimeStamp.assign(format);
+ TimeStamp.append(l_format);
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
+
+VOID CSystemManager::SYSTEMMANAGERLOG_StartupConfirmationMsg(EPWR_SC_MSG_STRUCT & f_scMsg) {
+ std::stringstream l_enumStr;
+ l_enumStr << endl;
+ l_enumStr << " HostProcSoftVer:" << hex << std::setw(16) << std::setfill('0')
+ << m_VersionNumberStruct.m_VersionNumber << endl;
+ l_enumStr << " _CWORD56_ Boot Mode:" << GetStr(f_scMsg._CWORD56_BootMode) << endl; // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ l_enumStr << " wakeupType :" << GetStr(f_scMsg.wakeupType); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+
+ FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "%s", l_enumStr.str().c_str());
+} // End of VOID CSystemManager::SYSTEMMANAGERLOG_StartupConfirmationMsg( EPWR_SC_MSG_STRUCT & f_scMsg )
+
+VOID CSystemManager::LogESystemmanagerStatusEnums() {
+ #define INITIAL_INDEX eFrameworkunifiedStatusEmptyMediaList
+ #define FINAL_INDEX eFrameworkunifiedStatusErrNoEINTR
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ std::stringstream l_enumStr;
+ for (int i = INITIAL_INDEX; i <= FINAL_INDEX; i++) {
+ // LCOV_EXCL_BR_START 11:unexpected branch // NOLINT(whitespace/line_length)
+ l_enumStr << "\n" << "0x" << std::setfill('0') << std::setw(8) << hex << i
+ << "/" << std::setfill(' ') << std::setw(2) << dec << i << ": "
+ << GetStr(static_cast<EFrameworkunifiedStatus>(i));
+ // LCOV_EXCL_BR_STOP
+ }
+
+ std::string l_logMsg = l_enumStr.str();
+ SystemmanagerLogString(ZONE_INFO, __FUNCTION__, l_logMsg); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+
+#undef INITIAL_INDEX
+#undef FINAL_INDEX
+} // End of VOID CSystemManager::LogESystemmanagerStatusEnums()
+
+VOID CSystemManager::LogProtocolIDs() {
+#define INITIAL_INDEX SS_SYSTEM_MANAGER_PROTOCOL_BEGINNING_INDEX
+#define FINAL_INDEX SS_SYSTEM_MANAGER_PROTOCOL_ENDING_INDEX
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ std::stringstream l_enumStr;
+ for (int i = INITIAL_INDEX; i <= FINAL_INDEX; i++) {
+ // LCOV_EXCL_BR_START 11:unexpected branch // NOLINT(whitespace/line_length)
+ l_enumStr << "\n" << "0x" << std::setfill('0') << std::setw(8) << hex << i
+ << "/" << std::setfill(' ') << std::setw(2) << dec << i << ": "
+ << GetStr(static_cast<SS_SystemManagerProtocol>(i));
+ // LCOV_EXCL_BR_STOP
+ }
+
+ std::string l_logMsg = l_enumStr.str();
+ SystemmanagerLogString(ZONE_INFO, __FUNCTION__, l_logMsg); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+
+#undef INITIAL_INDEX
+#undef FINAL_INDEX
+} // End of VOID CSystemManager::LogProtocolIDs()
+
+VOID CSystemManager::SystemmanagerLogString(TFrameworkunifiedZone f_zone, PCSTR f_func, std::string &f_text) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ UI_32 l_offset = 0;
+ UI_32 l_msgLenMax = MAX_QUEUE_MSG_SIZE - 512; // Leave space for the appending of
+ // the NSLog date/time/service/line string.
+
+ if (f_text.at(f_text.length() - 1) == '\n') { // LCOV_EXCL_BR_LINE 6: For setting the initialization conditions at SystemManager startup
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ f_text.erase(f_text.length() - 1); // LCOV_EXCL_LINE 6: For setting the initialization conditions at SystemManager startup
+ }
+
+ while (l_offset < f_text.size()) {
+ UI_32 l_charsRem = static_cast<UI_32>(f_text.size() - l_offset);
+ UI_32 l_msgLen = (l_charsRem > l_msgLenMax) ? // LCOV_EXCL_BR_LINE 6: For setting the initialization conditions at SystemManager startup
+ l_msgLenMax : l_charsRem; // LCOV_EXCL_BR_LINE 6: For setting the initialization conditions at SystemManager startup
+ std::string l_msgStr = f_text.substr(l_offset, l_msgLen);
+ size_t l_newLinePos = l_msgStr.find_last_of("\n", l_msgLen);
+ if ((l_newLinePos != std::string::npos) && (l_charsRem > l_msgLenMax)) { // LCOV_EXCL_BR_LINE 6: For setting the initialization conditions at SystemManager startup // NOLINT(whitespace/line_length)
+ // LCOV_EXCL_START 6: For setting the initialization conditions at SystemManager startup
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ l_msgStr = f_text.substr(l_offset, l_newLinePos);
+ l_offset += static_cast<UI_32>(l_newLinePos);
+ // LCOV_EXCL_STOP
+ } else {
+ l_offset += l_msgLen;
+ }
+
+ FRAMEWORKUNIFIEDLOG(f_zone, f_func, l_msgStr.c_str());
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+} // LCOV_EXCL_BR_LINE 10: Final line
+
+// End of /SS_SystemManager/src/ss_system_manager.cpp
Code Review / staging / basesystem.git / blobdiff