diff options
author | Tadao Tanikawa <tanikawa.tadao@jp.panasonic.com> | 2020-11-20 23:36:23 +0900 |
---|---|---|
committer | Tadao Tanikawa <tanikawa.tadao@jp.panasonic.com> | 2020-11-22 09:02:55 +0900 |
commit | 17cf21bcf8a2e29d2cbcf0a313474d2a4ee44f5d (patch) | |
tree | 582a9768558d9eaf261ca5df6136e9de54c95816 /service/system/system_manager/server/include/ss_system_manager.h | |
parent | 9e86046cdb356913ae026f616e5bf17f6f238aa5 (diff) |
Re-organized sub-directory by category
Since all the sub-directories were placed in the
first level, created sub-directories, "hal", "module",
and "service" for classification and relocated each component.
Signed-off-by: Tadao Tanikawa <tanikawa.tadao@jp.panasonic.com>
Change-Id: Ifdf743ac0d1893bd8e445455cf0d2c199a011d5c
Diffstat (limited to 'service/system/system_manager/server/include/ss_system_manager.h')
-rwxr-xr-x | service/system/system_manager/server/include/ss_system_manager.h | 760 |
1 files changed, 760 insertions, 0 deletions
diff --git a/service/system/system_manager/server/include/ss_system_manager.h b/service/system/system_manager/server/include/ss_system_manager.h new file mode 100755 index 0000000..12d5bad --- /dev/null +++ b/service/system/system_manager/server/include/ss_system_manager.h @@ -0,0 +1,760 @@ +/* + * @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 |