--- /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.
+///
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef __SS_SYSTEM_MANAGER_H__ // NOLINT
+#define __SS_SYSTEM_MANAGER_H__
+
+#include <system_service/ss_heartbeat_service_protocol.h>
+#include <system_service/ss_system_manager_if.h>
+#include <system_service/ss_error_event_common_local.h>
+#include <system_service/ss_system_timer.h>
+#include <crashdetector/ss_crashdetector.h>
+#include <system_service/ss_system_manager_protocol.h>
+#include <system_service/ss_power_service_protocol.h>
+#include <heartbeat/ss_hb_if.h>
+#include <other_service/PosixBasedOS001ClockCycleApi.h>
+#include <system_service/ss_string_maps.h>
+#include <system_service/ss_templates.h>
+#include <system_service/ss_system_manager_conf.h>
+#include <system_service/ss_system_manager_protocol_local.h>
+#include <system_service/ss_logger_store_logs.h>
+#include <native_service/ns_logger_if.h>
+#include <native_service/frameworkunified_types.h>
+#include <power_hal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include <inttypes.h>
+#include <map>
+#include <string>
+#include <vector>
+#include <queue>
+#include <sstream>
+#include <set>
+#include <list>
+#include <utility>
+
+#include "ss_sm_config.h"
+#include "ss_sm_systemmanagerlog.h"
+#include "ss_system_thread_info.h"
+#include "ss_system_memory_monitor.h"
+#include "ss_sm_dynamic_launcher.h"
+
+static_assert((SS_SM_PROG_UPDATE_STATE_NONE == PWR_PROGUPDATE_STATE_NONE),
+ "SS_SM_PROG_UPDATE_STATE_NONE should be equal to "
+ "PWR_PROGUPDATE_STATE_NONE");
+static_assert((SS_SM_PROG_UPDATE_STATE_UPDATED == PWR_PROGUPDATE_STATE_UPDATED),
+ "SS_SM_PROG_UPDATE_STATE_UPDATED should be equal to "
+ "PWR_PROGUPDATE_STATE_UPDATED");
+static_assert((SS_SM_PROG_UPDATE_STATE_MAP_UPDATED ==
+ PWR_PROGUPDATE_STATE_MAP_UPDATED),
+ "SS_SM_PROG_UPDATE_STATE_MAP_UPDATED should be equal to "
+ "PWR_PROGUPDATE_STATE_MAP_UPDATED");
+static_assert((SS_SM_PROG_UPDATE_STATE_MAPDIFF_UPDATED ==
+ PWR_PROGUPDATE_STATE_MAPDIFF_UPDATED),
+ "SS_SM_PROG_UPDATE_STATE_MAPDIFF_UPDATED should be equal to "
+ "PWR_PROGUPDATE_STATE_MAPDIFF_UPDATED");
+
+#define SM_SHUTDOWN_COMPLETE_MONITOR_TIMEOUT 60
+
+typedef enum {
+ eSM_TIMER_GROUP_MONITOR = 0x00
+ , eSM_TIMER_PROCESS_LAUNCH_MONITOR
+ , eSM_TIMER_HEARTBEAT_MONITOR
+ , eSM_TIMER_PROCESSLAUNCHER_MONITOR
+ , eSM_TIMER_CLIENT_START_MONITOR
+ , eSM_TIMER_NPP_STATUS_CHECK_MONITOR
+ , eSM_TIMER__CWORD56__HEARTBEAT_RESPONSE
+ , eSM_TIMER_LAUNCH_GROUP_TRIGGER_PROC_RESP_TIMER
+ , eSM_TIMER_GROUP_LAUNCH_WAIT_TIMER
+ , eSM_TIMER_MODULE_CONNECT_WAIT_TIMER
+ , eSM_TIMER_START_RESP_MONITOR_WAIT_TIMER
+ , eSM_TIMER_SHUTDOWN_COMPLETE_MONITOR
+ , eSM_TIMER_CLIENT_STOP_MONITOR
+ , eSM_TIMERS_END
+} ESMTimerIDs;
+
+typedef enum {
+ eSM_ERROR_EVENT_TIMER_LOGGER_START_REQ
+ , eSM_ERROR_EVENT_TIMER_DEBUG_DUMP_RSPN
+ , eSM_ERROR_EVENT_TIMER_BOOT_MICRO_LOG_RSPN
+ , eSM_ERROR_EVENT_TIMER_CORE_FILE_POLL
+ , eSM_ERROR_EVENT_TIMER_END
+} ESMErrorEventTimers;
+
+typedef enum {
+ eErrorEventResetTypeNone = 0,
+ eErrorEventResetTypeHard
+} EErrorEventResetType;
+
+typedef enum _ESMInternalProtocol {
+ SS_SM_SendTriggerToSelf = SS_SM_PROTOCOL_INTERFACE_END ///< System Manager to System Manager
+} ESMInternalProtocol;
+
+typedef enum _SS_SMGroupHirarchy {
+ SS_SM_INVALID_GROUP = 0
+ , SS_SM_INITIAL_GROUP
+ , SS_SM_SECOND_GROUP
+ , SS_SM_THIRD_GROUP
+} SS_SMGroupHirarchy;
+
+typedef enum _SS_SMModuleState {
+ SS_SM_READY_TO_LAUNCH_APP = 0x00
+ , SS_SM_APPS_LAUNCH_IN_PROGRESS
+ , SS_SM_APPS_LAUNCHED_READY_TO_START
+ , SS_SM_APPS_START_IN_PROGRESS
+ , SS_SM_APPS_START_COMPLETE
+ , SS_SM_APPS_STOPPING_AT__CWORD56__REQ
+ , SS_SM_APPS_STOPPING_AT_INTERNAL_REQ
+ , SS_SM_WAITING_FOR_CRITICAL_APPS_AT__CWORD56__REQ
+ , SS_SM_WAITING_FOR_CRITICAL_APPS_AT_INTERNAL_REQ
+ , SS_SM_APPS_PRE_START_IN_PROGRESS
+ , SS_SM_APPS_PRE_STOP_IN_PROGRESS
+ , SS_SM_APPS_PRE_RUN_COMPLETE
+ , SS_SM_APPS_BACKGROUND_START_IN_PROGRESS
+ , SS_SM_APPS_BACKGROUND_STOP_IN_PROGRESS
+ , SS_SM_APPS_BACKGROUND_RUN_COMPLETE
+} SS_SMModuleState;
+
+typedef struct _SMProcessExitInfo {
+ _SMProcessExitInfo() {
+ this->pid = 0;
+ this->exitValue = 0;
+ this->signalNumber = 0;
+ this->binaryFileName[0] = '\0';
+ }
+
+ UI_32 pid;
+ SI_32 exitValue;
+ SI_32 signalNumber;
+ CHAR binaryFileName[MAX_PATH_LENGTH];
+} SMProcessExitInfo;
+
+typedef struct _SMLoggingInfo { // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ _SMLoggingInfo() {
+ this->pid = 0;
+ this->exitValue = 0;
+ this->signalNumber = 0;
+ this->binaryFileName[0] = '\0';
+ this->messageStr = "";
+ this->suffixStr = "";
+ this->path = "";
+ this->resetReason = e_SS_SM_CPU_RESET_REASON_INVALID;
+ }
+
+ UI_32 pid;
+ SI_32 exitValue;
+ SI_32 signalNumber;
+ CHAR binaryFileName[MAX_PATH_LENGTH];
+ std::string messageStr;
+ std::string suffixStr;
+ std::string path;
+ ESMCpuResetReason resetReason;
+} SMLoggingInfo;
+
+struct ERROR_EVENT_INFO { // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ ERROR_EVENT_INFO() :
+ m_eventEnqueueTimeStamp(""),
+ m_moduleQueueName(""),
+ m_eventType(eErrorEventTypeMaxValue),
+ m_prio(eErrorEventPrioDefault),
+ m_uniqueCycles(ClockCycle()), // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ m_errorEventResetType(eErrorEventResetTypeNone) { // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ }
+
+ std::string m_eventEnqueueTimeStamp;
+ std::string m_moduleQueueName;
+ EErrorEventType m_eventType;
+ SMLoggingInfo m_loggingInfo;
+ EErrorEventPrio m_prio;
+ UI_64 m_uniqueCycles;
+ EErrorEventResetType m_errorEventResetType;
+};
+
+struct ERROR_EVENT_COMPARE {
+ bool operator() (const ERROR_EVENT_INFO& lhs,
+ const ERROR_EVENT_INFO& rhs) const {
+ if ((eErrorEventPrioDefault == lhs.m_prio) &&
+ (eErrorEventPrioDefault == rhs.m_prio)) {
+ return (lhs.m_uniqueCycles < rhs.m_uniqueCycles);
+ } else {
+ return (lhs.m_prio > rhs.m_prio);
+ }
+ }
+};
+
+typedef std::set<ERROR_EVENT_INFO, ERROR_EVENT_COMPARE> ERROR_EVENT_QUEUE;
+typedef ERROR_EVENT_QUEUE::iterator ERROR_EVENT_QUEUE_ITER;
+typedef std::pair<ERROR_EVENT_QUEUE_ITER, BOOL> ERROR_EVENT_QUEUE_RET;
+
+typedef EFrameworkunifiedStatus (*HndlrCb)(HANDLE hApp);
+typedef EFrameworkunifiedStatus (*FncCbType2)(HANDLE hApp, UI_32 f_UI_32);
+typedef BOOL (*FncCbType3)(UI_32 f_UI_32);
+
+typedef std::pair<SS_SystemManagerProtocol, Pwr_ServiceSetInterface> SM_POWER_EVENT_INFO;
+typedef std::queue<SM_POWER_EVENT_INFO> SM_POWER_EVENT_QUEUE;
+
+typedef struct {
+ std::string m_cmd;
+ UI_64 m_time;
+ std::string m_sender;
+} Ts_cmdHist;
+
+typedef std::list<std::string> ErrorGroupList;
+typedef ErrorGroupList::iterator ErrorGroupListIter;
+
+typedef std::vector<Ts_cmdHist> cmdHist;
+typedef cmdHist::iterator cmdHistIter;
+
+typedef std::vector<std::string> HBList;
+typedef HBList::iterator HBListIter;
+
+class CVersionNumInfo {
+ public:
+ CVersionNumInfo() : m_VersionNumber(0), m_eSystemmanagerStatus(eFrameworkunifiedStatusErrOther) {}
+ CVersionNumInfo(SS_VersionNumberType f_vn, EFrameworkunifiedStatus f_eStatus)
+ : m_VersionNumber(f_vn), m_eSystemmanagerStatus(f_eStatus) {}
+
+ // System Manager's local data store; write once on initialization,
+ // read as needed at clients' request
+ SS_VersionNumberType m_VersionNumber;
+ EFrameworkunifiedStatus m_eSystemmanagerStatus; // Validity / status of version number
+};
+
+#define SS_SM_RELAUNCH_NO_LIMIT -1
+typedef struct _PreLaunchModuleParams {
+ _PreLaunchModuleParams() {
+ this->LaunchFunc = NULL;
+ this->name = "";
+ this->binaryFileName = "";
+ this->critical = FALSE;
+ this->relaunchLimit = 0;
+ this->pid = -1;
+ this->relaunchCount = 0;
+ }
+
+ int (*LaunchFunc)(); // Launching function
+ std::string name; // Process name
+ std::string binaryFileName; // Binary file name
+ BOOL critical; // Reboot attribute
+ int relaunchLimit; // Maximum number of Relaunch
+ int pid; // pid
+ int relaunchCount; // Count of Relaunching
+} PreLaunchModuleParams;
+
+typedef std::list<PreLaunchModuleParams> PreLaunchModuleList;
+typedef PreLaunchModuleList::iterator PreLaunchModuleListIter;
+
+typedef struct _GroupRelaunchModuleParams {
+ _GroupRelaunchModuleParams() {
+ this->name = "";
+ this->bIsKilled = FALSE;
+ }
+
+ std::string name; // Process name
+ BOOL bIsKilled; // Flag indicates while forced quit process
+} GroupRelaunchModuleParams;
+
+typedef std::list<GroupRelaunchModuleParams> GroupRelaunchModuleList;
+typedef GroupRelaunchModuleList::iterator GroupRelaunchModuleListIter;
+
+
+class CSystemManager {
+ public:
+ static std::string m_bootOpt; // BOOT OPTION
+
+ CSystemManager();
+ virtual ~CSystemManager();
+
+ static CSystemManager & GetInstance();
+ EFrameworkunifiedStatus Initialize(HANDLE hApp);
+ void Initialize_memory(HANDLE hApp, bool* l_isInitFail, EFrameworkunifiedStatus* l_eStatus, BOOL isIllReset);
+ void Initialize_callbacks(HANDLE hApp, bool *l_isInitFail, EFrameworkunifiedStatus *l_eStatus);
+ /// < Process Launcher Thread Callbacks
+ EFrameworkunifiedStatus OnModuleLaunchResponse(HANDLE hApp);
+ EFrameworkunifiedStatus OnTerminateModuleResponse(HANDLE hApp);
+ EFrameworkunifiedStatus OnReLaunchModuleResponse(HANDLE hApp);
+ EFrameworkunifiedStatus PerformModuleLaunchRespProcessing(HANDLE hApp,
+ GroupLaunchMapIter & f_GroupIter, // NOLINT
+ ModuleLaunchListIter & f_ModuleIter, // NOLINT
+ PCSTR p_sPPD_tag);
+ EFrameworkunifiedStatus OnModuleStatusResponse(HANDLE hApp);
+ EFrameworkunifiedStatus OnGroupLaunchTimerExpiry(HANDLE hApp);
+ EFrameworkunifiedStatus OnLaunchGroup(HANDLE hApp);
+ EFrameworkunifiedStatus OnLaunchGroupSelfTrigger(HANDLE hApp);
+ EFrameworkunifiedStatus OnProcessLaunchTimerExpiry(HANDLE hApp);
+ EFrameworkunifiedStatus OnHeartBeatMonitorTimerExpiry(HANDLE hApp);
+ EFrameworkunifiedStatus OnProcessLaunchMonitorTimerExpiry(HANDLE hApp);
+ EFrameworkunifiedStatus OnHeartBeatThreadHeartbeatResponse(HANDLE hApp);
+ EFrameworkunifiedStatus OnCheckAvailResponse(HANDLE f_hApp);
+
+ EFrameworkunifiedStatus OnProcessLauncherThreadHeartbeatResponse(HANDLE hApp);
+ EFrameworkunifiedStatus OnClientStartMonitorTimerExpiry(HANDLE hApp);
+ EFrameworkunifiedStatus OnClientStopMonitorTimerExpiry(HANDLE hApp);
+ EFrameworkunifiedStatus OnNPPStatusCheckMonitorTimerExpiry(HANDLE hApp);
+ EFrameworkunifiedStatus OnPowerServiceAvailableNotify(HANDLE hApp);
+ EFrameworkunifiedStatus OnLVI1Notify(HANDLE hApp);
+ EFrameworkunifiedStatus OnLVI2Notify(HANDLE hApp);
+
+ EFrameworkunifiedStatus OnModuleStartCompleteResponse(HANDLE hApp); /// Process start complete from client
+ EFrameworkunifiedStatus OnModuleStopCompleteResponse(HANDLE hApp); /// Process stop Complete from client
+ EFrameworkunifiedStatus OnGetStartExtInfo(HANDLE hApp);
+ EFrameworkunifiedStatus OnGetStopExtInfo(HANDLE hApp);
+ EFrameworkunifiedStatus OnModuleStopCompleteNotification(HANDLE hApp);
+ EFrameworkunifiedStatus ProcessModuleStopCompleteResponse(HANDLE hApp,
+ PCSTR f_moduleName);
+ EFrameworkunifiedStatus ModuleCompleteResponse(HANDLE hApp,
+ ModuleLaunchListIter f_ModuleListIter,
+ SMModuleState f_moduleState,
+ FncCbType3 f_isGroupDoneFnc,
+ FncCbType2 f_groupDoneFnc,
+ PCSTR f_sCompleteTypeText);
+
+ EFrameworkunifiedStatus ProcessGroupOnModuleStopResponse(HANDLE hApp, UI_32 f_groupID);
+
+
+
+ EFrameworkunifiedStatus OnLaunchGroupTriggerProcessResponseTimerExpiry(HANDLE hApp);
+
+ EFrameworkunifiedStatus OnNppStopComplete(HANDLE hApp); /// Process stop Complete from NPPService
+ EFrameworkunifiedStatus OnOpenSession(HANDLE hApp); /// Process open session request
+ EFrameworkunifiedStatus OnCloseSession(HANDLE hApp); /// Process close session acknowledgment
+
+ EFrameworkunifiedStatus CloseApplication(HANDLE hApp);
+ EFrameworkunifiedStatus OnGetAppInfo(HANDLE hApp);
+
+ /// < Heartbeat Thread Callbacks
+ EFrameworkunifiedStatus OnHeartBeatErrorReport(HANDLE hApp);
+
+ EFrameworkunifiedStatus OnCurrentSMStateQuery(HANDLE hApp);
+
+ EFrameworkunifiedStatus OnNPPReadyStatusCallback(HANDLE hApp);
+ EFrameworkunifiedStatus OnNPPReadyEventCallback(HANDLE hApp);
+ EFrameworkunifiedStatus OnWakeupCallback(HANDLE hApp);
+ EFrameworkunifiedStatus OnPowerRequestCallback(HANDLE hApp);
+ EFrameworkunifiedStatus OnBackupMgrAvailCallback(HANDLE hApp);
+ EFrameworkunifiedStatus OnShutdownModulesRequest(HANDLE hApp);
+ EFrameworkunifiedStatus OnSystemModeInfoRequest(HANDLE hApp);
+ EFrameworkunifiedStatus ClearDramBackupInfo(HANDLE hApp);
+ EFrameworkunifiedStatus OnInitCompReportCallback(HANDLE hApp);
+ EFrameworkunifiedStatus SetEnvVariableForVupMode(BOOL bIsVupMode);
+ static int CreateRtUsb();
+ EFrameworkunifiedStatus SecureChipOff();
+ EFrameworkunifiedStatus CallStopCompleteHandler(HANDLE hApp, BOOL bISDetectTimeout = FALSE);
+
+ EFrameworkunifiedStatus On_CWORD56_HeartBeatRequest(HANDLE hApp);
+ EFrameworkunifiedStatus On_CWORD56_HeartBeatResponseIntervalTimerExpiry(HANDLE hApp);
+ EFrameworkunifiedStatus OnGroupLaunchWaitTimeout(HANDLE hApp);
+ EFrameworkunifiedStatus OnModuleConnectWaitTimeout(HANDLE hApp);
+ EFrameworkunifiedStatus OnStartRespMonitorTimeout(HANDLE hApp);
+ EFrameworkunifiedStatus OnShutdownCompleteMonitorTimeout(HANDLE hApp);
+ EFrameworkunifiedStatus PerformCpuReset(HANDLE hApp, ESMCpuResetReason f_eSmCpuResetReason, std::string f_messageStr = ""); // NOLINT
+ EFrameworkunifiedStatus OnCpuResetRequest(HANDLE hApp);
+ EFrameworkunifiedStatus OnSetDataResetModeRequest(HANDLE hApp);
+ EFrameworkunifiedStatus OnSetProgUpdateStateRequest(HANDLE hApp);
+ EFrameworkunifiedStatus OnLaunchGroupTriggerProcessResponse(HANDLE hApp);
+ EFrameworkunifiedStatus OnSetNextWakeupTypeRequest(HANDLE hApp);
+
+ bool GetDramPowerStatusInfo(const HANDLE h_app);
+ bool GetDramStoreStatusInfo(const HANDLE h_app);
+ bool GetSyscomPowerStatusInfo(const HANDLE h_app);
+ //
+ // Start Confirmation, Get _CWORD56_ Version callback functions
+ EFrameworkunifiedStatus OnSetStartupConfirmationDataRequest(HANDLE hApp);
+
+ void SystemManagerDebugDump(HANDLE hApp);
+
+
+ private:
+ CThreadInfo m_hHeartbeatThread; // Handle to Heartbeat Thread
+ CThreadInfo m_hProcLauncherThread; // Handle to Process Launcher Thread
+ UI_32 m_SystemLaunchProgress; // Launch Progress of system
+ TimerCtrl * m_GroupLaunchTimer; // Launch Monitor Timer
+ UI_32 m_aTimerIDs[eSM_TIMERS_END]; // TimerIDs returned by create timer
+ PreLaunchModuleList m_PreLaunchModuleList; // List of modules that shuuld be launched preliminarily.
+ GroupRelaunchModuleList m_GroupRelaunchModuleList; // List of modules that need to relaunch
+ UI_32 m_GroupRelaunchCount; // Count for group relaunch
+ UI_32 m_GroupRelaunchLimit; // Limit for group relaunch
+ GroupLaunchMap m_MapProclaunchGrps; // Map of modules that should be launched.
+ ProcessNameMap m_MapProcNames; // Map of module binary names to queue names.
+ HANDLE m_hPowerServiceSession;
+ UI_32 m_ActiveGroupId; // Modules of Group to whom START/STOP has been sent
+ wakeInfo m_Wake; // WakeUp data from power
+ EPWR_WAKEUP_FACTOR_TYPE m_StartUpReason; // System Manager preserve start up reason
+ ESMDataResetModeInfo m_DataResetMode; // Data Reset Mode
+ SMProgUpdateState m_ProgUpdateState; // ProgUpdate State
+ ESMNextWakeupType m_NextWakeupType; // Next Progupdate State
+ ESMDramBackupStatus m_DramBackupStatus; // Dram Backup Status
+ BOOL m_isIlgReset; // Error Detected by SYS-ucon
+ ESMResetStatus m_ResetStatus; // Reset Status
+ UI_32 m_ResetCount; // Reset Count
+ T_SS_SM_INIT_HOOK_OUT_PARAM m_productCustomPrm; // Product customized parameters
+
+ SS_SMModuleState m_SMCurrentState; // Current state of System Manager
+ UI_32 m_MaxShutdownTime; // Calculate Max shutdown time based on info from xml
+ UI_32 m_NbrDebugDumpRspnRecv; // Total number of debug dump responses received.
+ BOOL m_isRcvModeInfo;
+ SystemModeInfo m_SystemModeInfo; // System Mode Info, SM to read data from persistent file at start
+ SS_String m_BinaryFilesPath; // Store binary files path
+ SS_String m_ConfigFilesPath; // Store config files path
+ ConfigurationData m_SMConfig; // Configuration Data of System Manager and its threads
+ HndlrCb m_pfStopCompleteHandler;
+ CVersionNumInfo m_VersionNumberStruct;
+ SS_String m_BuildInfoStr;
+
+ BOOL m_isRstPending;
+ TSystemManagerCpuResetInfo m_rstPendingInfo;
+
+ SM_POWER_EVENT_QUEUE m_dqDeferMsg;
+ BOOL m_UsingVMPlayer; // Running on a VMPlayer ?
+ UI_32 NVM_VALID_SIGNATURE;
+ StartupConfirmationMsgStrut m_startUpConfirmationMsg;
+ EPWR_USER_MODE_TYPE m_lastUserMode;
+ EPWR_SHUTDOWN_TRIGGER_TYPE m_shutdownTrigger; // Set from Shutdown_Request
+ // msg from _CWORD56_, sent to
+ // all modules as part of
+ // SS_SM_STOP msg.
+ BOOL m_isImmediateReset;
+ BOOL m_isImmResetReq;
+ BOOL m_needReNotifyStartPrm;
+ CHAR *m_pVarCodeStr;
+ GroupLaunchMapIter m_SSLGroupLaunchMapIterator;
+ ModuleLaunchListIter m_ModuleLaunchListIter;
+ BOOL m_bIsNPP_ServicesStarted;
+ BOOL m_bIsBackupAvail;
+ //
+ DynamicLauncher m_oSystemLauncher;
+ DynamicModuleStart m_SystemStarter;
+ //
+ BOOL m_NPPStopSent;
+ ePwrServiceUserModeChangeReasonType m_userModeChangeReason;
+
+ HBList m_HBList;
+
+ cmdHist m__CWORD56_CmdHist;
+ cmdHistIter m__CWORD56_HistIter;
+ cmdHist m_SMCmdHist;
+ cmdHistIter m_SMHistIter;
+ cmdHist m_TimerCmdHist;
+ cmdHistIter m_TimerHistIter;
+ cmdHist m_PubCmdHist;
+ cmdHistIter m_PubHistIter;
+ cmdHist m_ErrHist;
+ cmdHistIter m_ErrHistIter;
+
+ pthread_mutex_t sm_hist_mutex;
+
+ bool m_InitialBoot;
+
+ PsmFactorT m_ResetFactor; // reset(start-up) factor.
+
+ void SetCmdHist(std::string cmd, cmdHist &hist, cmdHistIter &it, std::string sender); // NOLINT
+
+ // ILGRST or ACCOFFON Logging
+ bool StoreDebugLogs(const HANDLE h_app, SS_STORELOGS_OPE_TYPE);
+
+ UI_32 InProgressStateToSendMsg() const;
+ SMModuleState InProgressStateToState() const;
+
+ //************************************************************************
+ // Error Event Logging *
+ //
+ int m_ClProcessSigFd;
+ CSysMemoryMonitor m_SysMemMonitor;
+
+ UI_32 m_FreeMemAvailable;
+ off_t m_coreFileSizeBytes;
+ THbReportData m_HBReport;
+ eSMBootMicroResetReason m_BootMicroResetReason;
+ BOOL m_errorEventQueueLocked;
+ ERROR_EVENT_QUEUE m_errorEventQueue;
+ Timer m_errorEventTimers[eSM_ERROR_EVENT_TIMER_END];
+ BOOL m_isPrevErrEventCompleted;
+ EFrameworkunifiedStatus m_errorEventResult;
+ EArtifactId m_requestedArtifactId;
+ ERROR_EVENT_QUEUE_ITER m_errorEventCurrentIter;
+ // *
+ // End of Error Event Logging *
+ //************************************************************************
+
+
+ ////******************************************************************////
+ //// enum<=>enum maps ////
+ //
+ //
+ // EPWR_POWER_STATE_TYPE <=> BOOL
+ std::map<EPWR_POWER_STATE_TYPE, BOOL> m_PowerType_to_SSBoolEnumMap;
+ std::map<EPWR_POWER_STATE_TYPE, EPWR_USER_MODE_TYPE>
+ m_PowerType_to_SSUserModeEnumMap;
+ std::map<BOOL, EPWR_POWER_STATE_TYPE> m_SSBool_to_PowerTypeEnumMap;
+ //
+ // User Mode
+ std::map<EPWR_USER_MODE_TYPE, BOOL> m_SSUserMode_to_SSBoolEnumMap;
+ std::map<BOOL, EPWR_USER_MODE_TYPE> m_SSBool_to_SSUserModeEnumMap;
+
+ //
+ //// End of enum<=>enum maps ////
+ ////******************************************************************////
+
+ EFrameworkunifiedStatus init_process_launcher(HANDLE hApp);
+ EFrameworkunifiedStatus start_process_launching(HANDLE hApp);
+ EFrameworkunifiedStatus init_Heartbeat(HANDLE hApp);
+ EFrameworkunifiedStatus init_crash_detector(HANDLE hApp);
+ EFrameworkunifiedStatus init_sysmem_monitor(HANDLE hApp);
+ EFrameworkunifiedStatus SendRequestToHeartBeat(HANDLE hAPP, EHBProtocolMessages, VOID *, UI_32);
+ EFrameworkunifiedStatus send_launch_status(HANDLE hApp, UI_32 u32LaunchState);
+
+ EFrameworkunifiedStatus register_all_notification_callbacks(HANDLE hApp);
+ VOID SMStateStartCompleteEntry(HANDLE hApp);
+ VOID SMStateEntry(HANDLE hApp, SS_SMModuleState l_SMState);
+ VOID SMStateExit(HANDLE hApp, SS_SMModuleState l_SMState);
+ VOID SMSetState(HANDLE hApp, SS_SMModuleState l_SMState);
+
+ // Wakeup from Power
+ EFrameworkunifiedStatus BeginStartup(HANDLE hApp);
+ EFrameworkunifiedStatus start_all_modules_of_group(HANDLE hApp, UI_32 f_ui32GroupNumber);
+ EFrameworkunifiedStatus send_power_request_complete_response(HANDLE hApp,
+ std::string pStr);
+ BOOL have_all_services_start_completed(const SMModuleState f_moduleState);
+
+ // Power Off from Power
+ EFrameworkunifiedStatus PublishPowerOnOffNotification(HANDLE hApp);
+
+ // Shutdown from Power
+ EFrameworkunifiedStatus stop_all_modules_of_group(HANDLE hApp);
+ UI_32 calculate_max_shutdown_time();
+ BOOL is_service_shutdown_ready(ModuleLaunchListIter &modIte); // NOLINT
+ BOOL have_critical_services_stopped();
+ VOID check_all_groups_have_stopped(HANDLE hApp);
+ EFrameworkunifiedStatus perform_force_reset(HANDLE hApp);
+ EFrameworkunifiedStatus send_shutdown_complete_response(HANDLE hApp);
+ EFrameworkunifiedStatus SendShutdownResponseMessage(HANDLE hApp);
+
+ PsmFactorT GetResetFactor(PCSTR f_module_name, BOOL f_user_reset);
+ PsmFactorT GetResetFactor(const ModuleLaunchListIter f_module_iter, BOOL f_user_reset);
+
+ EFrameworkunifiedStatus ValidateUserModeMessage(HANDLE hApp, EPWR_USER_MODE_TYPE &l_eUserModeState); // NOLINT
+
+ VOID SetStartGroup();
+
+ VOID ReadPathFromEnvironmentVariables();
+ SS_String ReadConfigDataFileNameFromEnvironmentVariable();
+ SS_String ReadLaunchConfigFileNameFromEnvironmentVariable();
+
+
+ VOID ReadUsingVMPlayerEnvironmentVariable();
+
+ VOID InitiateAllGroupsShutdown(HANDLE hApp);
+ VOID SendDeferMsg(HANDLE hApp);
+ EFrameworkunifiedStatus GetVersionNumber(SS_VersionNumberType &f_VersionNumber); // NOLINT
+ EFrameworkunifiedStatus GetBuildInfo(std::string &f_BuildInfoStr); // NOLINT
+ EFrameworkunifiedStatus RegisterCallbacksForRequester(HANDLE hApp, PCSTR pRequester);
+ EFrameworkunifiedStatus SetSystemModeInfoStruct();
+
+ EFrameworkunifiedStatus PerformLaunchProcedure(HANDLE hApp
+ , ModuleLaunchListIter f_ModuleIterator
+ , SS_String & f_stopCompName); // NOLINT
+
+ EFrameworkunifiedStatus PerformTerminateProcedure(HANDLE hApp
+ , ModuleLaunchListIter f_ModuleIterator
+ , SS_String & f_availabilityName
+ , SS_String & f_stopCompName); // NOLINT
+
+ EFrameworkunifiedStatus SendRequestToLauncher(HANDLE hApp
+ , ModuleLaunchListIter f_ModuleIterator
+ , ESMPLThreadCommandIds f_CommandId
+ , SS_String f_CommandIdStr);
+
+ EFrameworkunifiedStatus FindNameOfTerminatedProcess(SI_32 pid, SS_String &f_ModuleName); // NOLINT
+
+ EFrameworkunifiedStatus GetBinaryNameOfProcess(SS_String f_ModuleQueueName,
+ SS_String &f_ModuleBinaryName); // NOLINT
+
+ EFrameworkunifiedStatus RemoveModuleEntryFromHB(HANDLE hApp, const CHAR *f_ModuleName);
+
+ EFrameworkunifiedStatus PublishUserModeNotification(HANDLE hApp);
+ EFrameworkunifiedStatus PerformPowerOnOffUserModePublication(
+ HANDLE hApp,
+ const char * p_NotificationStr);
+ EFrameworkunifiedStatus SendSystemModeInfoResponse(
+ HANDLE hApp,
+ EPWR_STARTUP_STAGE_TYPE f_startupStage);
+
+ VOID SYSTEMMANAGERLOG_StartupConfirmationMsg(EPWR_SC_MSG_STRUCT & f_scMsg); // NOLINT
+ VOID LogGroupModulesState(UI_32 f_groupId, std::string pStr);
+ VOID LogAllGroupModulesState(std::string pStr);
+
+ EFrameworkunifiedStatus ProcessGroupAsStarted(HANDLE hApp
+ , GroupLaunchMapIter f_GroupIterator);
+ EFrameworkunifiedStatus ProcessGroupAsStarted(HANDLE hApp
+ , UI_32 f_groupId);
+ EFrameworkunifiedStatus GetModuleIterator(PCSTR f_moduleName, ModuleLaunchListIter & f_moduleIter); // NOLINT
+ BOOL IsGroupStarted(UI_32 f_groupId);
+ BOOL IsGroupStopped(UI_32 f_groupId);
+ EFrameworkunifiedStatus ResetModulesStateToConnected(HANDLE hApp);
+
+ EFrameworkunifiedStatus GetTimeStamp(std::string& TimeStamp); // NOLINT
+ std::string GetErrorEventInString(UI_32 &ErrorEventType); // NOLINT
+ EFrameworkunifiedStatus GetLastSourceInfo(SS_SOURCE &source_type); // NOLINT
+ //
+ // Return True when Module is in correct / appropriate state wrt SM state
+ // return false otherwise
+ BOOL GetModuleCondition(ModuleLaunchListIter & f_ModuleIter); // NOLINT
+
+ VOID LogESystemmanagerStatusEnums();
+ VOID LogProtocolIDs();
+
+ VOID SystemmanagerLogString(TFrameworkunifiedZone f_zone,
+ PCSTR f_func,
+ std::string &f_text); // NOLINT
+
+ inline BOOL is_current_state(SS_SMModuleState SMState) {
+ return (m_SMCurrentState == SMState);
+ }
+
+ //**************************************************************************
+ // Get results from TestClient *
+ // *
+ EFrameworkunifiedStatus add_state_information_to_response(CHAR *f_MessageResponse) const;
+ EFrameworkunifiedStatus construct_get_result_response(CHAR *f_MessageResponse); // *
+ EFrameworkunifiedStatus open_session_with_sm_test_client(HANDLE hApp, // *
+ PCSTR pRequester); // *
+ // *
+ // End of 'Get results from TestClient' *
+ //**************************************************************************
+
+ //************************************************************************
+ // Error Event Logging *
+ // *
+ EFrameworkunifiedStatus ErrorEventInit(HANDLE f_hApp);
+
+ EFrameworkunifiedStatus OnHeartBeatErrorDetected(HANDLE f_hApp);
+ EFrameworkunifiedStatus OnProcessTermDetected(HANDLE f_hApp);
+ BOOL isPreLaunchedProcess(int f_pid);
+ EFrameworkunifiedStatus OnPreLaunchedProcessTermDetected(HANDLE f_hApp,
+ SMProcessExitInfo &f_procExitInfo, // NOLINT
+ BOOL f_bIsExited);
+ EFrameworkunifiedStatus OnProcessCrashDetected(HANDLE f_hApp,
+ SMProcessExitInfo &f_procExitInfo); // NOLINT
+ EFrameworkunifiedStatus OnProcessExitDetected(HANDLE f_hApp,
+ SMProcessExitInfo &f_procExitInfo); // NOLINT
+
+ EFrameworkunifiedStatus OnUserInvokedLoggingRequest(HANDLE f_hApp);
+
+ EFrameworkunifiedStatus OnEelExportRequest(HANDLE f_hApp);
+
+ EFrameworkunifiedStatus OnSystemmanagerEmmcLogsRequest(HANDLE f_hApp);
+ EFrameworkunifiedStatus OnSystemmanagerClearLogsRequest(HANDLE f_hApp);
+
+ EFrameworkunifiedStatus OnDiagLoggingRequest(HANDLE f_hApp);
+ EFrameworkunifiedStatus OnCANLoggingRequest(HANDLE f_hApp);
+
+ EFrameworkunifiedStatus OnPropagateSystemError(HANDLE f_hApp);
+
+ EFrameworkunifiedStatus OnCaptureAllLogsRequest(HANDLE f_hApp);
+ EFrameworkunifiedStatus OnCaptureScreenShotRequest(HANDLE f_hApp);
+ EFrameworkunifiedStatus OnCaptureSystemmanagerLogsRequest(HANDLE f_hApp);
+
+
+ EFrameworkunifiedStatus OnBootMicroResetNotification(HANDLE f_hApp);
+
+ EFrameworkunifiedStatus OnObtainBootMicroLog(HANDLE f_hApp);
+ EFrameworkunifiedStatus RequestBootMicroLog(HANDLE f_hApp);
+
+ EFrameworkunifiedStatus OnBootMicroLogResponse(HANDLE f_hApp);
+
+ EFrameworkunifiedStatus OnErrorEventBootMicroLogResponseTimeout(HANDLE f_hApp);
+
+ EFrameworkunifiedStatus OnLowSystemMemory(HANDLE f_hApp);
+ EFrameworkunifiedStatus OnObtainSystemmanagerSystemDataCsv(HANDLE f_hApp);
+ EFrameworkunifiedStatus OnObtainShowMemTxt(HANDLE f_hApp);
+
+ EFrameworkunifiedStatus OnErrorEventCoreFilePollTimeout(HANDLE f_hApp);
+
+ EFrameworkunifiedStatus OnObtainDebugDumpLog(HANDLE f_hApp);
+ EFrameworkunifiedStatus SendDebugDumpRequestToAllModules(HANDLE f_hApp);
+
+ EFrameworkunifiedStatus OnDebugDumpResponseReceived(HANDLE f_hApp);
+
+ EFrameworkunifiedStatus OnDebugDumpCompleteTimeout(HANDLE f_hApp);
+
+ EFrameworkunifiedStatus ErrorEventEnqueue(HANDLE f_hApp,
+ EErrorEventType f_eventType,
+ std::string &f_moduleQueueName, // NOLINT
+ EErrorEventResetType f_resetType = eErrorEventResetTypeNone,
+ const SMLoggingInfo &f_loggingInfo = SMLoggingInfo());
+
+ EFrameworkunifiedStatus PerformResetAfterLogging(HANDLE f_hApp,
+ ESMCpuResetReason f_eCpuResetReason,
+ std::string f_messageStr = "");
+
+ EFrameworkunifiedStatus ErrorEventProcessNext(HANDLE f_hApp);
+
+ EFrameworkunifiedStatus OnLoggingStartRequest(HANDLE f_hApp);
+ EFrameworkunifiedStatus OnErrorEventLoggerStartRequestTimeout(HANDLE f_hApp);
+
+ EFrameworkunifiedStatus OnErrorEventArtifactRequest(HANDLE f_hApp);
+
+ EFrameworkunifiedStatus SendLogArtifactResponseToLogger(HANDLE f_hApp,
+ EArtifactId f_artifactId,
+ std::string f_artifactFilePathAndName);
+
+ EFrameworkunifiedStatus OnErrorEventLoggingComplete(HANDLE f_hApp);
+
+ EFrameworkunifiedStatus ActOnModuleFailure(HANDLE f_hApp,
+ SS_String f_moduleName,
+ BOOL &f_refResetRequired); // NOLINT
+ std::string ErrorEventCreateHmiDisplayString(void);
+
+ // *
+ // End of Error Event Logging *
+ //************************************************************************
+
+ UI_32 m_SystemManagerPriority;
+};
+#define REC_HIST(pStrCmd, hist, it, pStrSender) \
+ SetCmdHist(pStrCmd, hist, it, pStrSender);
+
+#define REC_HIST_IF_SUCCESSFUL(pStr, hist, it, sender, l_eStatus) \
+ if (eFrameworkunifiedStatusOK == l_eStatus) { \
+ REC_HIST(pStr, hist, it, sender) \
+ }
+
+#define LOG_ERROR_REC_HIST(l_eStatus, pStr) { \
+ LOG_ERROR(pStr); \
+ REC_HIST(pStr, m_ErrHist, m_ErrHistIter, GetStr(l_eStatus).c_str()); \
+ }
+#define LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, pStr) \
+ if (eFrameworkunifiedStatusOK != l_eStatus) { \
+ LOG_ERROR(pStr); \
+ REC_HIST(pStr, m_ErrHist, m_ErrHistIter, GetStr(l_eStatus).c_str()); \
+ } else { \
+ LOG_SUCCESS(pStr); \
+ } // End of #define LOG_STATUS(l_eStatus,pStr)
+
+#define LOG_ERROR_REC_HIST_IF_ERRORED(l_eStatus, pStr) \
+ if (eFrameworkunifiedStatusOK != l_eStatus) { \
+ LOG_ERROR(pStr); \
+ REC_HIST(pStr, m_ErrHist, m_ErrHistIter, GetStr(l_eStatus).c_str()); \
+ } // End of #define LOG_STATUS_IF_ERRORED(l_eStatus,pStr)
+
+#endif // __SS_SYSTEM_MANAGER_H__ // NOLINT
Code Review / staging / basesystem.git / blobdiff