service/system/system_manager/server/include/ss_system_manager.h

   1 /*
   2  * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 ///////////////////////////////////////////////////////////////////////////////
  18 /// \ingroup  tag_SystemManager
  19 /// \brief    This file provides support for System Manager business logic.
  20 ///
  21 ///////////////////////////////////////////////////////////////////////////////
  22
  23 #ifndef __SS_SYSTEM_MANAGER_H__  // NOLINT
  24 #define __SS_SYSTEM_MANAGER_H__
  25
  26 #include <system_service/ss_heartbeat_service_protocol.h>
  27 #include <system_service/ss_system_manager_if.h>
  28 #include <system_service/ss_error_event_common_local.h>
  29 #include <system_service/ss_system_timer.h>
  30 #include <crashdetector/ss_crashdetector.h>
  31 #include <system_service/ss_system_manager_protocol.h>
  32 #include <system_service/ss_power_service_protocol.h>
  33 #include <heartbeat/ss_hb_if.h>
  34 #include <other_service/PosixBasedOS001ClockCycleApi.h>
  35 #include <system_service/ss_string_maps.h>
  36 #include <system_service/ss_templates.h>
  37 #include <system_service/ss_system_manager_conf.h>
  38 #include <system_service/ss_system_manager_protocol_local.h>
  39 #include <system_service/ss_logger_store_logs.h>
  40 #include <native_service/ns_logger_if.h>
  41 #include <native_service/frameworkunified_types.h>
  42 #include <power_hal.h>
  43 #include <stdio.h>
  44 #include <stdlib.h>
  45 #include <pthread.h>
  46 #include <inttypes.h>
  47 #include <map>
  48 #include <string>
  49 #include <vector>
  50 #include <queue>
  51 #include <sstream>
  52 #include <set>
  53 #include <list>
  54 #include <utility>
  55
  56 #include "ss_sm_config.h"
  57 #include "ss_sm_systemmanagerlog.h"
  58 #include "ss_system_thread_info.h"
  59 #include "ss_system_memory_monitor.h"
  60 #include "ss_sm_dynamic_launcher.h"
  61
  62 static_assert((SS_SM_PROG_UPDATE_STATE_NONE == PWR_PROGUPDATE_STATE_NONE),
  63   "SS_SM_PROG_UPDATE_STATE_NONE should be equal to "
  64   "PWR_PROGUPDATE_STATE_NONE");
  65 static_assert((SS_SM_PROG_UPDATE_STATE_UPDATED == PWR_PROGUPDATE_STATE_UPDATED),
  66   "SS_SM_PROG_UPDATE_STATE_UPDATED should be equal to "
  67   "PWR_PROGUPDATE_STATE_UPDATED");
  68 static_assert((SS_SM_PROG_UPDATE_STATE_MAP_UPDATED ==
  69   PWR_PROGUPDATE_STATE_MAP_UPDATED),
  70   "SS_SM_PROG_UPDATE_STATE_MAP_UPDATED should be equal to "
  71   "PWR_PROGUPDATE_STATE_MAP_UPDATED");
  72 static_assert((SS_SM_PROG_UPDATE_STATE_MAPDIFF_UPDATED ==
  73   PWR_PROGUPDATE_STATE_MAPDIFF_UPDATED),
  74   "SS_SM_PROG_UPDATE_STATE_MAPDIFF_UPDATED should be equal to "
  75   "PWR_PROGUPDATE_STATE_MAPDIFF_UPDATED");
  76
  77 #define SM_SHUTDOWN_COMPLETE_MONITOR_TIMEOUT 60
  78
  79 typedef enum {
  80   eSM_TIMER_GROUP_MONITOR = 0x00
  81   , eSM_TIMER_PROCESS_LAUNCH_MONITOR
  82   , eSM_TIMER_HEARTBEAT_MONITOR
  83   , eSM_TIMER_PROCESSLAUNCHER_MONITOR
  84   , eSM_TIMER_CLIENT_START_MONITOR
  85   , eSM_TIMER_NPP_STATUS_CHECK_MONITOR
  86   , eSM_TIMER__CWORD56__HEARTBEAT_RESPONSE
  87   , eSM_TIMER_LAUNCH_GROUP_TRIGGER_PROC_RESP_TIMER
  88   , eSM_TIMER_GROUP_LAUNCH_WAIT_TIMER
  89   , eSM_TIMER_MODULE_CONNECT_WAIT_TIMER
  90   , eSM_TIMER_START_RESP_MONITOR_WAIT_TIMER
  91   , eSM_TIMER_SHUTDOWN_COMPLETE_MONITOR
  92   , eSM_TIMER_CLIENT_STOP_MONITOR
  93   , eSM_TIMERS_END
  94 } ESMTimerIDs;
  95
  96 typedef enum {
  97   eSM_ERROR_EVENT_TIMER_LOGGER_START_REQ
  98   , eSM_ERROR_EVENT_TIMER_DEBUG_DUMP_RSPN
  99   , eSM_ERROR_EVENT_TIMER_BOOT_MICRO_LOG_RSPN
 100   , eSM_ERROR_EVENT_TIMER_CORE_FILE_POLL
 101   , eSM_ERROR_EVENT_TIMER_END
 102 } ESMErrorEventTimers;
 103
 104 typedef enum {
 105   eErrorEventResetTypeNone = 0,
 106   eErrorEventResetTypeHard
 107 } EErrorEventResetType;
 108
 109 typedef enum _ESMInternalProtocol {
 110   SS_SM_SendTriggerToSelf = SS_SM_PROTOCOL_INTERFACE_END  ///< System Manager to System Manager
 111 } ESMInternalProtocol;
 112
 113 typedef enum _SS_SMGroupHirarchy {
 114   SS_SM_INVALID_GROUP = 0
 115   , SS_SM_INITIAL_GROUP
 116   , SS_SM_SECOND_GROUP
 117   , SS_SM_THIRD_GROUP
 118 } SS_SMGroupHirarchy;
 119
 120 typedef enum _SS_SMModuleState {
 121   SS_SM_READY_TO_LAUNCH_APP = 0x00
 122   , SS_SM_APPS_LAUNCH_IN_PROGRESS
 123   , SS_SM_APPS_LAUNCHED_READY_TO_START
 124   , SS_SM_APPS_START_IN_PROGRESS
 125   , SS_SM_APPS_START_COMPLETE
 126   , SS_SM_APPS_STOPPING_AT__CWORD56__REQ
 127   , SS_SM_APPS_STOPPING_AT_INTERNAL_REQ
 128   , SS_SM_WAITING_FOR_CRITICAL_APPS_AT__CWORD56__REQ
 129   , SS_SM_WAITING_FOR_CRITICAL_APPS_AT_INTERNAL_REQ
 130   , SS_SM_APPS_PRE_START_IN_PROGRESS
 131   , SS_SM_APPS_PRE_STOP_IN_PROGRESS
 132   , SS_SM_APPS_PRE_RUN_COMPLETE
 133   , SS_SM_APPS_BACKGROUND_START_IN_PROGRESS
 134   , SS_SM_APPS_BACKGROUND_STOP_IN_PROGRESS
 135   , SS_SM_APPS_BACKGROUND_RUN_COMPLETE
 136 } SS_SMModuleState;
 137
 138 typedef struct _SMProcessExitInfo {
 139   _SMProcessExitInfo() {
 140     this->pid                = 0;
 141     this->exitValue          = 0;
 142     this->signalNumber       = 0;
 143     this->binaryFileName[0]  = '\0';
 144   }
 145
 146   UI_32  pid;
 147   SI_32  exitValue;
 148   SI_32  signalNumber;
 149   CHAR   binaryFileName[MAX_PATH_LENGTH];
 150 } SMProcessExitInfo;
 151
 152 typedef struct _SMLoggingInfo {  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
 153   _SMLoggingInfo() {
 154     this->pid               = 0;
 155     this->exitValue         = 0;
 156     this->signalNumber      = 0;
 157     this->binaryFileName[0] = '\0';
 158     this->messageStr        = "";
 159     this->suffixStr         = "";
 160     this->path              = "";
 161     this->resetReason       = e_SS_SM_CPU_RESET_REASON_INVALID;
 162   }
 163
 164   UI_32              pid;
 165   SI_32              exitValue;
 166   SI_32              signalNumber;
 167   CHAR               binaryFileName[MAX_PATH_LENGTH];
 168   std::string        messageStr;
 169   std::string        suffixStr;
 170   std::string        path;
 171   ESMCpuResetReason  resetReason;
 172 } SMLoggingInfo;
 173
 174 struct ERROR_EVENT_INFO {  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
 175   ERROR_EVENT_INFO() :
 176     m_eventEnqueueTimeStamp(""),
 177     m_moduleQueueName(""),
 178     m_eventType(eErrorEventTypeMaxValue),
 179     m_prio(eErrorEventPrioDefault),
 180     m_uniqueCycles(ClockCycle()),  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
 181     m_errorEventResetType(eErrorEventResetTypeNone) {  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
 182   }
 183
 184   std::string      m_eventEnqueueTimeStamp;
 185   std::string      m_moduleQueueName;
 186   EErrorEventType  m_eventType;
 187   SMLoggingInfo    m_loggingInfo;
 188   EErrorEventPrio  m_prio;
 189   UI_64            m_uniqueCycles;
 190   EErrorEventResetType m_errorEventResetType;
 191 };
 192
 193 struct ERROR_EVENT_COMPARE {
 194   bool operator() (const ERROR_EVENT_INFO& lhs,
 195            const ERROR_EVENT_INFO& rhs) const {
 196     if ((eErrorEventPrioDefault == lhs.m_prio) &&
 197         (eErrorEventPrioDefault == rhs.m_prio)) {
 198       return (lhs.m_uniqueCycles < rhs.m_uniqueCycles);
 199     } else {
 200       return (lhs.m_prio > rhs.m_prio);
 201     }
 202   }
 203 };
 204
 205 typedef  std::set<ERROR_EVENT_INFO, ERROR_EVENT_COMPARE> ERROR_EVENT_QUEUE;
 206 typedef  ERROR_EVENT_QUEUE::iterator                     ERROR_EVENT_QUEUE_ITER;
 207 typedef  std::pair<ERROR_EVENT_QUEUE_ITER, BOOL>         ERROR_EVENT_QUEUE_RET;
 208
 209 typedef EFrameworkunifiedStatus (*HndlrCb)(HANDLE hApp);
 210 typedef EFrameworkunifiedStatus (*FncCbType2)(HANDLE hApp, UI_32 f_UI_32);
 211 typedef BOOL       (*FncCbType3)(UI_32 f_UI_32);
 212
 213 typedef std::pair<SS_SystemManagerProtocol, Pwr_ServiceSetInterface> SM_POWER_EVENT_INFO;
 214 typedef std::queue<SM_POWER_EVENT_INFO>                              SM_POWER_EVENT_QUEUE;
 215
 216 typedef struct {
 217   std::string m_cmd;
 218   UI_64       m_time;
 219   std::string m_sender;
 220 } Ts_cmdHist;
 221
 222 typedef std::list<std::string> ErrorGroupList;
 223 typedef ErrorGroupList::iterator ErrorGroupListIter;
 224
 225 typedef std::vector<Ts_cmdHist> cmdHist;
 226 typedef cmdHist::iterator cmdHistIter;
 227
 228 typedef std::vector<std::string> HBList;
 229 typedef HBList::iterator HBListIter;
 230
 231 class CVersionNumInfo {
 232  public:
 233   CVersionNumInfo() : m_VersionNumber(0), m_eSystemmanagerStatus(eFrameworkunifiedStatusErrOther) {}
 234   CVersionNumInfo(SS_VersionNumberType f_vn, EFrameworkunifiedStatus f_eStatus)
 235                 : m_VersionNumber(f_vn), m_eSystemmanagerStatus(f_eStatus) {}
 236
 237   // System Manager's local data store; write once on initialization,
 238   // read as needed at clients' request
 239   SS_VersionNumberType m_VersionNumber;
 240   EFrameworkunifiedStatus           m_eSystemmanagerStatus;    // Validity / status of version number
 241 };
 242
 243 #define SS_SM_RELAUNCH_NO_LIMIT -1
 244 typedef struct _PreLaunchModuleParams {
 245   _PreLaunchModuleParams() {
 246     this->LaunchFunc     = NULL;
 247     this->name           = "";
 248     this->binaryFileName = "";
 249     this->critical       = FALSE;
 250     this->relaunchLimit  =  0;
 251     this->pid            = -1;
 252     this->relaunchCount  =  0;
 253   }
 254
 255   int          (*LaunchFunc)();  // Launching function
 256   std::string  name;             // Process name
 257   std::string  binaryFileName;   // Binary file name
 258   BOOL         critical;         // Reboot attribute
 259   int          relaunchLimit;    // Maximum number of Relaunch
 260   int          pid;              // pid
 261   int          relaunchCount;    // Count of Relaunching
 262 } PreLaunchModuleParams;
 263
 264 typedef std::list<PreLaunchModuleParams> PreLaunchModuleList;
 265 typedef PreLaunchModuleList::iterator PreLaunchModuleListIter;
 266
 267 typedef struct _GroupRelaunchModuleParams {
 268   _GroupRelaunchModuleParams() {
 269     this->name    = "";
 270     this->bIsKilled = FALSE;
 271   }
 272
 273   std::string  name;      // Process name
 274   BOOL     bIsKilled;     // Flag indicates while forced quit process
 275 } GroupRelaunchModuleParams;
 276
 277 typedef std::list<GroupRelaunchModuleParams> GroupRelaunchModuleList;
 278 typedef GroupRelaunchModuleList::iterator GroupRelaunchModuleListIter;
 279
 280
 281 class CSystemManager {
 282  public:
 283   static std::string m_bootOpt;   // BOOT OPTION
 284
 285   CSystemManager();
 286   virtual ~CSystemManager();
 287
 288   static CSystemManager & GetInstance();
 289   EFrameworkunifiedStatus        Initialize(HANDLE hApp);
 290   void       Initialize_memory(HANDLE hApp, bool* l_isInitFail, EFrameworkunifiedStatus* l_eStatus, BOOL isIllReset);
 291   void       Initialize_callbacks(HANDLE hApp, bool *l_isInitFail, EFrameworkunifiedStatus *l_eStatus);
 292   /// < Process Launcher Thread Callbacks
 293   EFrameworkunifiedStatus OnModuleLaunchResponse(HANDLE hApp);
 294   EFrameworkunifiedStatus OnTerminateModuleResponse(HANDLE hApp);
 295   EFrameworkunifiedStatus OnReLaunchModuleResponse(HANDLE hApp);
 296   EFrameworkunifiedStatus PerformModuleLaunchRespProcessing(HANDLE         hApp,
 297                          GroupLaunchMapIter   & f_GroupIter,  // NOLINT
 298                          ModuleLaunchListIter & f_ModuleIter,  // NOLINT
 299                          PCSTR        p_sPPD_tag);
 300   EFrameworkunifiedStatus OnModuleStatusResponse(HANDLE hApp);
 301   EFrameworkunifiedStatus OnGroupLaunchTimerExpiry(HANDLE hApp);
 302   EFrameworkunifiedStatus OnLaunchGroup(HANDLE hApp);
 303   EFrameworkunifiedStatus OnLaunchGroupSelfTrigger(HANDLE hApp);
 304   EFrameworkunifiedStatus OnProcessLaunchTimerExpiry(HANDLE hApp);
 305   EFrameworkunifiedStatus OnHeartBeatMonitorTimerExpiry(HANDLE hApp);
 306   EFrameworkunifiedStatus OnProcessLaunchMonitorTimerExpiry(HANDLE hApp);
 307   EFrameworkunifiedStatus OnHeartBeatThreadHeartbeatResponse(HANDLE hApp);
 308   EFrameworkunifiedStatus OnCheckAvailResponse(HANDLE f_hApp);
 309
 310   EFrameworkunifiedStatus OnProcessLauncherThreadHeartbeatResponse(HANDLE hApp);
 311   EFrameworkunifiedStatus OnClientStartMonitorTimerExpiry(HANDLE hApp);
 312   EFrameworkunifiedStatus OnClientStopMonitorTimerExpiry(HANDLE hApp);
 313   EFrameworkunifiedStatus OnNPPStatusCheckMonitorTimerExpiry(HANDLE hApp);
 314   EFrameworkunifiedStatus OnPowerServiceAvailableNotify(HANDLE hApp);
 315   EFrameworkunifiedStatus OnLVI1Notify(HANDLE hApp);
 316   EFrameworkunifiedStatus OnLVI2Notify(HANDLE hApp);
 317
 318   EFrameworkunifiedStatus OnModuleStartCompleteResponse(HANDLE hApp);  /// Process start complete from client
 319   EFrameworkunifiedStatus OnModuleStopCompleteResponse(HANDLE hApp);    /// Process stop Complete from client
 320   EFrameworkunifiedStatus OnGetStartExtInfo(HANDLE hApp);
 321   EFrameworkunifiedStatus OnGetStopExtInfo(HANDLE hApp);
 322   EFrameworkunifiedStatus OnModuleStopCompleteNotification(HANDLE hApp);
 323   EFrameworkunifiedStatus ProcessModuleStopCompleteResponse(HANDLE hApp,
 324                          PCSTR  f_moduleName);
 325   EFrameworkunifiedStatus ModuleCompleteResponse(HANDLE         hApp,
 326                      ModuleLaunchListIter f_ModuleListIter,
 327                      SMModuleState    f_moduleState,
 328                      FncCbType3       f_isGroupDoneFnc,
 329                      FncCbType2       f_groupDoneFnc,
 330                      PCSTR        f_sCompleteTypeText);
 331
 332   EFrameworkunifiedStatus ProcessGroupOnModuleStopResponse(HANDLE hApp, UI_32 f_groupID);
 333
 334
 335
 336   EFrameworkunifiedStatus OnLaunchGroupTriggerProcessResponseTimerExpiry(HANDLE hApp);
 337
 338   EFrameworkunifiedStatus OnNppStopComplete(HANDLE hApp);      /// Process stop Complete from NPPService
 339   EFrameworkunifiedStatus OnOpenSession(HANDLE hApp);     /// Process open session request
 340   EFrameworkunifiedStatus OnCloseSession(HANDLE hApp);         /// Process close session acknowledgment
 341
 342   EFrameworkunifiedStatus CloseApplication(HANDLE hApp);
 343   EFrameworkunifiedStatus OnGetAppInfo(HANDLE hApp);
 344
 345   /// < Heartbeat Thread Callbacks
 346   EFrameworkunifiedStatus OnHeartBeatErrorReport(HANDLE hApp);
 347
 348   EFrameworkunifiedStatus OnCurrentSMStateQuery(HANDLE hApp);
 349
 350   EFrameworkunifiedStatus OnNPPReadyStatusCallback(HANDLE hApp);
 351   EFrameworkunifiedStatus OnNPPReadyEventCallback(HANDLE hApp);
 352   EFrameworkunifiedStatus OnWakeupCallback(HANDLE hApp);
 353   EFrameworkunifiedStatus OnPowerRequestCallback(HANDLE hApp);
 354   EFrameworkunifiedStatus OnBackupMgrAvailCallback(HANDLE hApp);
 355   EFrameworkunifiedStatus OnShutdownModulesRequest(HANDLE hApp);
 356   EFrameworkunifiedStatus OnSystemModeInfoRequest(HANDLE hApp);
 357   EFrameworkunifiedStatus ClearDramBackupInfo(HANDLE hApp);
 358   EFrameworkunifiedStatus OnInitCompReportCallback(HANDLE hApp);
 359   EFrameworkunifiedStatus SetEnvVariableForVupMode(BOOL bIsVupMode);
 360   static int CreateRtUsb();
 361   EFrameworkunifiedStatus SecureChipOff();
 362   EFrameworkunifiedStatus CallStopCompleteHandler(HANDLE hApp, BOOL bISDetectTimeout = FALSE);
 363
 364   EFrameworkunifiedStatus On_CWORD56_HeartBeatRequest(HANDLE hApp);
 365   EFrameworkunifiedStatus On_CWORD56_HeartBeatResponseIntervalTimerExpiry(HANDLE hApp);
 366   EFrameworkunifiedStatus OnGroupLaunchWaitTimeout(HANDLE hApp);
 367   EFrameworkunifiedStatus OnModuleConnectWaitTimeout(HANDLE hApp);
 368   EFrameworkunifiedStatus OnStartRespMonitorTimeout(HANDLE hApp);
 369   EFrameworkunifiedStatus OnShutdownCompleteMonitorTimeout(HANDLE hApp);
 370   EFrameworkunifiedStatus PerformCpuReset(HANDLE hApp, ESMCpuResetReason f_eSmCpuResetReason, std::string f_messageStr = "");  // NOLINT
 371   EFrameworkunifiedStatus OnCpuResetRequest(HANDLE hApp);
 372   EFrameworkunifiedStatus OnSetDataResetModeRequest(HANDLE hApp);
 373   EFrameworkunifiedStatus OnSetProgUpdateStateRequest(HANDLE hApp);
 374   EFrameworkunifiedStatus OnLaunchGroupTriggerProcessResponse(HANDLE hApp);
 375   EFrameworkunifiedStatus OnSetNextWakeupTypeRequest(HANDLE hApp);
 376
 377   bool GetDramPowerStatusInfo(const HANDLE h_app);
 378   bool GetDramStoreStatusInfo(const HANDLE h_app);
 379   bool GetSyscomPowerStatusInfo(const HANDLE h_app);
 380   //
 381   // Start Confirmation, Get _CWORD56_ Version callback functions
 382   EFrameworkunifiedStatus OnSetStartupConfirmationDataRequest(HANDLE hApp);
 383
 384   void SystemManagerDebugDump(HANDLE hApp);
 385
 386
 387  private:
 388   CThreadInfo              m_hHeartbeatThread;            // Handle to Heartbeat Thread
 389   CThreadInfo              m_hProcLauncherThread;         // Handle to Process Launcher Thread
 390   UI_32                    m_SystemLaunchProgress;        // Launch Progress of system
 391   TimerCtrl *              m_GroupLaunchTimer;            // Launch Monitor Timer
 392   UI_32                    m_aTimerIDs[eSM_TIMERS_END];   // TimerIDs returned by create timer
 393   PreLaunchModuleList      m_PreLaunchModuleList;         // List of modules that shuuld be launched preliminarily.
 394   GroupRelaunchModuleList  m_GroupRelaunchModuleList;     // List of modules that need to relaunch
 395   UI_32                    m_GroupRelaunchCount;          // Count for group relaunch
 396   UI_32                    m_GroupRelaunchLimit;          // Limit for group relaunch
 397   GroupLaunchMap           m_MapProclaunchGrps;           // Map of modules that should be launched.
 398   ProcessNameMap           m_MapProcNames;                // Map of module binary names to queue names.
 399   HANDLE                   m_hPowerServiceSession;
 400   UI_32                    m_ActiveGroupId;               // Modules of Group to whom START/STOP has been sent
 401   wakeInfo                 m_Wake;                        // WakeUp data from power
 402   EPWR_WAKEUP_FACTOR_TYPE  m_StartUpReason;               // System Manager preserve start up reason
 403   ESMDataResetModeInfo     m_DataResetMode;               // Data Reset Mode
 404   SMProgUpdateState        m_ProgUpdateState;             // ProgUpdate State
 405   ESMNextWakeupType        m_NextWakeupType;              // Next Progupdate State
 406   ESMDramBackupStatus      m_DramBackupStatus;            // Dram Backup Status
 407   BOOL                     m_isIlgReset;                  // Error Detected by SYS-ucon
 408   ESMResetStatus           m_ResetStatus;                 // Reset Status
 409   UI_32                    m_ResetCount;                  // Reset Count
 410   T_SS_SM_INIT_HOOK_OUT_PARAM m_productCustomPrm;         // Product customized parameters
 411
 412   SS_SMModuleState         m_SMCurrentState;              // Current state of System Manager
 413   UI_32                    m_MaxShutdownTime;             // Calculate Max shutdown time based on info from xml
 414   UI_32                    m_NbrDebugDumpRspnRecv;        // Total number of debug dump responses received.
 415   BOOL                     m_isRcvModeInfo;
 416   SystemModeInfo           m_SystemModeInfo;  // System Mode Info, SM to read data from persistent file at start
 417   SS_String                m_BinaryFilesPath;             // Store binary files path
 418   SS_String                m_ConfigFilesPath;             // Store config files path
 419   ConfigurationData        m_SMConfig;                    // Configuration Data of System Manager and its threads
 420   HndlrCb                  m_pfStopCompleteHandler;
 421   CVersionNumInfo          m_VersionNumberStruct;
 422   SS_String                m_BuildInfoStr;
 423
 424   BOOL                     m_isRstPending;
 425   TSystemManagerCpuResetInfo m_rstPendingInfo;
 426
 427   SM_POWER_EVENT_QUEUE     m_dqDeferMsg;
 428   BOOL                     m_UsingVMPlayer;               // Running on a VMPlayer ?
 429   UI_32                    NVM_VALID_SIGNATURE;
 430   StartupConfirmationMsgStrut  m_startUpConfirmationMsg;
 431   EPWR_USER_MODE_TYPE      m_lastUserMode;
 432   EPWR_SHUTDOWN_TRIGGER_TYPE   m_shutdownTrigger;         // Set from Shutdown_Request
 433                                                           // msg from _CWORD56_, sent to
 434                                                           // all modules as part of
 435                                                           // SS_SM_STOP msg.
 436   BOOL                     m_isImmediateReset;
 437   BOOL                     m_isImmResetReq;
 438   BOOL                     m_needReNotifyStartPrm;
 439   CHAR                    *m_pVarCodeStr;
 440   GroupLaunchMapIter       m_SSLGroupLaunchMapIterator;
 441   ModuleLaunchListIter     m_ModuleLaunchListIter;
 442   BOOL                     m_bIsNPP_ServicesStarted;
 443   BOOL                     m_bIsBackupAvail;
 444   //
 445   DynamicLauncher          m_oSystemLauncher;
 446   DynamicModuleStart       m_SystemStarter;
 447   //
 448   BOOL                     m_NPPStopSent;
 449   ePwrServiceUserModeChangeReasonType m_userModeChangeReason;
 450
 451   HBList                   m_HBList;
 452
 453   cmdHist                  m__CWORD56_CmdHist;
 454   cmdHistIter              m__CWORD56_HistIter;
 455   cmdHist                  m_SMCmdHist;
 456   cmdHistIter              m_SMHistIter;
 457   cmdHist                  m_TimerCmdHist;
 458   cmdHistIter              m_TimerHistIter;
 459   cmdHist                  m_PubCmdHist;
 460   cmdHistIter              m_PubHistIter;
 461   cmdHist                  m_ErrHist;
 462   cmdHistIter              m_ErrHistIter;
 463
 464   pthread_mutex_t sm_hist_mutex;
 465
 466   bool  m_InitialBoot;
 467
 468   PsmFactorT m_ResetFactor;     //  reset(start-up) factor.
 469
 470   void SetCmdHist(std::string cmd, cmdHist &hist, cmdHistIter &it, std::string sender);  // NOLINT
 471
 472   // ILGRST or ACCOFFON Logging
 473   bool StoreDebugLogs(const HANDLE h_app, SS_STORELOGS_OPE_TYPE);
 474
 475   UI_32 InProgressStateToSendMsg() const;
 476   SMModuleState InProgressStateToState() const;
 477
 478   //************************************************************************
 479   // Error Event Logging                                                   *
 480   //
 481   int              m_ClProcessSigFd;
 482   CSysMemoryMonitor        m_SysMemMonitor;
 483
 484   UI_32              m_FreeMemAvailable;
 485   off_t              m_coreFileSizeBytes;
 486   THbReportData          m_HBReport;
 487   eSMBootMicroResetReason    m_BootMicroResetReason;
 488   BOOL               m_errorEventQueueLocked;
 489   ERROR_EVENT_QUEUE        m_errorEventQueue;
 490   Timer              m_errorEventTimers[eSM_ERROR_EVENT_TIMER_END];
 491   BOOL               m_isPrevErrEventCompleted;
 492   EFrameworkunifiedStatus           m_errorEventResult;
 493   EArtifactId          m_requestedArtifactId;
 494   ERROR_EVENT_QUEUE_ITER     m_errorEventCurrentIter;
 495   //                                                                       *
 496   // End of Error Event Logging                                            *
 497   //************************************************************************
 498
 499
 500   ////******************************************************************////
 501   ////     enum<=>enum maps                                             ////
 502   //
 503   //
 504   //  EPWR_POWER_STATE_TYPE <=> BOOL
 505   std::map<EPWR_POWER_STATE_TYPE, BOOL>    m_PowerType_to_SSBoolEnumMap;
 506   std::map<EPWR_POWER_STATE_TYPE, EPWR_USER_MODE_TYPE>
 507                          m_PowerType_to_SSUserModeEnumMap;
 508   std::map<BOOL, EPWR_POWER_STATE_TYPE>    m_SSBool_to_PowerTypeEnumMap;
 509   //
 510   //  User Mode
 511   std::map<EPWR_USER_MODE_TYPE, BOOL>    m_SSUserMode_to_SSBoolEnumMap;
 512   std::map<BOOL, EPWR_USER_MODE_TYPE>    m_SSBool_to_SSUserModeEnumMap;
 513
 514   //
 515   ////     End of enum<=>enum maps                                      ////
 516   ////******************************************************************////
 517
 518   EFrameworkunifiedStatus init_process_launcher(HANDLE hApp);
 519   EFrameworkunifiedStatus start_process_launching(HANDLE hApp);
 520   EFrameworkunifiedStatus init_Heartbeat(HANDLE hApp);
 521   EFrameworkunifiedStatus init_crash_detector(HANDLE hApp);
 522   EFrameworkunifiedStatus init_sysmem_monitor(HANDLE hApp);
 523   EFrameworkunifiedStatus SendRequestToHeartBeat(HANDLE hAPP, EHBProtocolMessages, VOID *, UI_32);
 524   EFrameworkunifiedStatus send_launch_status(HANDLE hApp, UI_32 u32LaunchState);
 525
 526   EFrameworkunifiedStatus register_all_notification_callbacks(HANDLE hApp);
 527   VOID SMStateStartCompleteEntry(HANDLE hApp);
 528   VOID SMStateEntry(HANDLE hApp, SS_SMModuleState l_SMState);
 529   VOID SMStateExit(HANDLE hApp, SS_SMModuleState l_SMState);
 530   VOID SMSetState(HANDLE hApp, SS_SMModuleState l_SMState);
 531
 532   // Wakeup from Power
 533   EFrameworkunifiedStatus BeginStartup(HANDLE hApp);
 534   EFrameworkunifiedStatus start_all_modules_of_group(HANDLE hApp, UI_32 f_ui32GroupNumber);
 535   EFrameworkunifiedStatus send_power_request_complete_response(HANDLE hApp,
 536                            std::string pStr);
 537   BOOL     have_all_services_start_completed(const SMModuleState f_moduleState);
 538
 539   // Power Off from Power
 540   EFrameworkunifiedStatus PublishPowerOnOffNotification(HANDLE hApp);
 541
 542   // Shutdown from Power
 543   EFrameworkunifiedStatus stop_all_modules_of_group(HANDLE hApp);
 544   UI_32    calculate_max_shutdown_time();
 545   BOOL     is_service_shutdown_ready(ModuleLaunchListIter &modIte);  // NOLINT
 546   BOOL     have_critical_services_stopped();
 547   VOID     check_all_groups_have_stopped(HANDLE hApp);
 548   EFrameworkunifiedStatus perform_force_reset(HANDLE hApp);
 549   EFrameworkunifiedStatus send_shutdown_complete_response(HANDLE hApp);
 550   EFrameworkunifiedStatus SendShutdownResponseMessage(HANDLE hApp);
 551
 552   PsmFactorT GetResetFactor(PCSTR f_module_name, BOOL f_user_reset);
 553   PsmFactorT GetResetFactor(const ModuleLaunchListIter f_module_iter, BOOL f_user_reset);
 554
 555   EFrameworkunifiedStatus ValidateUserModeMessage(HANDLE hApp, EPWR_USER_MODE_TYPE &l_eUserModeState);  // NOLINT
 556
 557   VOID SetStartGroup();
 558
 559   VOID ReadPathFromEnvironmentVariables();
 560   SS_String ReadConfigDataFileNameFromEnvironmentVariable();
 561   SS_String ReadLaunchConfigFileNameFromEnvironmentVariable();
 562
 563
 564   VOID ReadUsingVMPlayerEnvironmentVariable();
 565
 566   VOID       InitiateAllGroupsShutdown(HANDLE hApp);
 567   VOID       SendDeferMsg(HANDLE hApp);
 568   EFrameworkunifiedStatus GetVersionNumber(SS_VersionNumberType &f_VersionNumber);  // NOLINT
 569   EFrameworkunifiedStatus GetBuildInfo(std::string &f_BuildInfoStr);  // NOLINT
 570   EFrameworkunifiedStatus RegisterCallbacksForRequester(HANDLE hApp, PCSTR pRequester);
 571   EFrameworkunifiedStatus SetSystemModeInfoStruct();
 572
 573   EFrameworkunifiedStatus PerformLaunchProcedure(HANDLE hApp
 574                                   , ModuleLaunchListIter f_ModuleIterator
 575                                   , SS_String & f_stopCompName);  // NOLINT
 576
 577   EFrameworkunifiedStatus PerformTerminateProcedure(HANDLE hApp
 578                                  , ModuleLaunchListIter f_ModuleIterator
 579                                  , SS_String & f_availabilityName
 580                                  , SS_String & f_stopCompName);  // NOLINT
 581
 582   EFrameworkunifiedStatus SendRequestToLauncher(HANDLE        hApp
 583                    , ModuleLaunchListIter  f_ModuleIterator
 584                    , ESMPLThreadCommandIds f_CommandId
 585                    , SS_String       f_CommandIdStr);
 586
 587   EFrameworkunifiedStatus FindNameOfTerminatedProcess(SI_32 pid, SS_String &f_ModuleName);  // NOLINT
 588
 589   EFrameworkunifiedStatus GetBinaryNameOfProcess(SS_String  f_ModuleQueueName,
 590                     SS_String &f_ModuleBinaryName);  // NOLINT
 591
 592   EFrameworkunifiedStatus RemoveModuleEntryFromHB(HANDLE hApp, const CHAR *f_ModuleName);
 593
 594   EFrameworkunifiedStatus PublishUserModeNotification(HANDLE hApp);
 595   EFrameworkunifiedStatus PerformPowerOnOffUserModePublication(
 596                   HANDLE hApp,
 597                   const char * p_NotificationStr);
 598   EFrameworkunifiedStatus SendSystemModeInfoResponse(
 599           HANDLE hApp,
 600           EPWR_STARTUP_STAGE_TYPE f_startupStage);
 601
 602   VOID     SYSTEMMANAGERLOG_StartupConfirmationMsg(EPWR_SC_MSG_STRUCT & f_scMsg);  // NOLINT
 603   VOID     LogGroupModulesState(UI_32 f_groupId, std::string pStr);
 604   VOID     LogAllGroupModulesState(std::string pStr);
 605
 606   EFrameworkunifiedStatus ProcessGroupAsStarted(HANDLE hApp
 607                   , GroupLaunchMapIter f_GroupIterator);
 608   EFrameworkunifiedStatus ProcessGroupAsStarted(HANDLE hApp
 609                   , UI_32 f_groupId);
 610   EFrameworkunifiedStatus GetModuleIterator(PCSTR f_moduleName, ModuleLaunchListIter & f_moduleIter);  // NOLINT
 611   BOOL     IsGroupStarted(UI_32 f_groupId);
 612   BOOL     IsGroupStopped(UI_32 f_groupId);
 613   EFrameworkunifiedStatus ResetModulesStateToConnected(HANDLE hApp);
 614
 615   EFrameworkunifiedStatus GetTimeStamp(std::string& TimeStamp);  // NOLINT
 616   std::string GetErrorEventInString(UI_32 &ErrorEventType);  // NOLINT
 617   EFrameworkunifiedStatus GetLastSourceInfo(SS_SOURCE &source_type);  // NOLINT
 618   //
 619   // Return True when Module is in correct / appropriate state wrt SM state
 620   // return false otherwise
 621   BOOL     GetModuleCondition(ModuleLaunchListIter & f_ModuleIter);  // NOLINT
 622
 623   VOID LogESystemmanagerStatusEnums();
 624   VOID LogProtocolIDs();
 625
 626   VOID SystemmanagerLogString(TFrameworkunifiedZone   f_zone,
 627             PCSTR    f_func,
 628             std::string &f_text);  // NOLINT
 629
 630   inline BOOL is_current_state(SS_SMModuleState SMState) {
 631     return (m_SMCurrentState == SMState);
 632   }
 633
 634   //**************************************************************************
 635   // Get results from TestClient                                             *
 636   //                                                                         *
 637   EFrameworkunifiedStatus add_state_information_to_response(CHAR *f_MessageResponse) const;
 638   EFrameworkunifiedStatus construct_get_result_response(CHAR *f_MessageResponse);      // *
 639   EFrameworkunifiedStatus open_session_with_sm_test_client(HANDLE hApp,                // *
 640                                               PCSTR pRequester);          // *
 641   //                                                                         *
 642   // End of 'Get results from TestClient'                                    *
 643   //**************************************************************************
 644
 645   //************************************************************************
 646   // Error Event Logging                                                   *
 647   //                                                                       *
 648   EFrameworkunifiedStatus  ErrorEventInit(HANDLE                f_hApp);
 649
 650   EFrameworkunifiedStatus  OnHeartBeatErrorDetected(HANDLE                f_hApp);
 651   EFrameworkunifiedStatus  OnProcessTermDetected(HANDLE                f_hApp);
 652   BOOL        isPreLaunchedProcess(int                   f_pid);
 653   EFrameworkunifiedStatus  OnPreLaunchedProcessTermDetected(HANDLE                f_hApp,
 654                                                SMProcessExitInfo    &f_procExitInfo,  // NOLINT
 655                                                BOOL                  f_bIsExited);
 656   EFrameworkunifiedStatus  OnProcessCrashDetected(HANDLE                f_hApp,
 657                                      SMProcessExitInfo    &f_procExitInfo);  // NOLINT
 658   EFrameworkunifiedStatus  OnProcessExitDetected(HANDLE                f_hApp,
 659                                     SMProcessExitInfo    &f_procExitInfo);  // NOLINT
 660
 661   EFrameworkunifiedStatus  OnUserInvokedLoggingRequest(HANDLE                f_hApp);
 662
 663   EFrameworkunifiedStatus  OnEelExportRequest(HANDLE                f_hApp);
 664
 665   EFrameworkunifiedStatus  OnSystemmanagerEmmcLogsRequest(HANDLE                f_hApp);
 666   EFrameworkunifiedStatus  OnSystemmanagerClearLogsRequest(HANDLE                f_hApp);
 667
 668   EFrameworkunifiedStatus  OnDiagLoggingRequest(HANDLE                f_hApp);
 669   EFrameworkunifiedStatus  OnCANLoggingRequest(HANDLE                f_hApp);
 670
 671   EFrameworkunifiedStatus  OnPropagateSystemError(HANDLE                f_hApp);
 672
 673   EFrameworkunifiedStatus  OnCaptureAllLogsRequest(HANDLE                f_hApp);
 674   EFrameworkunifiedStatus  OnCaptureScreenShotRequest(HANDLE                f_hApp);
 675   EFrameworkunifiedStatus  OnCaptureSystemmanagerLogsRequest(HANDLE                f_hApp);
 676
 677
 678   EFrameworkunifiedStatus  OnBootMicroResetNotification(HANDLE                f_hApp);
 679
 680   EFrameworkunifiedStatus  OnObtainBootMicroLog(HANDLE                f_hApp);
 681   EFrameworkunifiedStatus  RequestBootMicroLog(HANDLE                f_hApp);
 682
 683   EFrameworkunifiedStatus  OnBootMicroLogResponse(HANDLE                f_hApp);
 684
 685   EFrameworkunifiedStatus  OnErrorEventBootMicroLogResponseTimeout(HANDLE                f_hApp);
 686
 687   EFrameworkunifiedStatus  OnLowSystemMemory(HANDLE                f_hApp);
 688   EFrameworkunifiedStatus  OnObtainSystemmanagerSystemDataCsv(HANDLE                f_hApp);
 689   EFrameworkunifiedStatus  OnObtainShowMemTxt(HANDLE                f_hApp);
 690
 691   EFrameworkunifiedStatus  OnErrorEventCoreFilePollTimeout(HANDLE                f_hApp);
 692
 693   EFrameworkunifiedStatus  OnObtainDebugDumpLog(HANDLE                f_hApp);
 694   EFrameworkunifiedStatus  SendDebugDumpRequestToAllModules(HANDLE                f_hApp);
 695
 696   EFrameworkunifiedStatus  OnDebugDumpResponseReceived(HANDLE                f_hApp);
 697
 698   EFrameworkunifiedStatus  OnDebugDumpCompleteTimeout(HANDLE                f_hApp);
 699
 700   EFrameworkunifiedStatus  ErrorEventEnqueue(HANDLE                f_hApp,
 701                                 EErrorEventType       f_eventType,
 702                                 std::string          &f_moduleQueueName,  // NOLINT
 703                                 EErrorEventResetType  f_resetType   = eErrorEventResetTypeNone,
 704                                 const SMLoggingInfo  &f_loggingInfo = SMLoggingInfo());
 705
 706   EFrameworkunifiedStatus  PerformResetAfterLogging(HANDLE                f_hApp,
 707                                        ESMCpuResetReason     f_eCpuResetReason,
 708                                        std::string           f_messageStr = "");
 709
 710   EFrameworkunifiedStatus  ErrorEventProcessNext(HANDLE                f_hApp);
 711
 712   EFrameworkunifiedStatus  OnLoggingStartRequest(HANDLE                f_hApp);
 713   EFrameworkunifiedStatus  OnErrorEventLoggerStartRequestTimeout(HANDLE                f_hApp);
 714
 715   EFrameworkunifiedStatus  OnErrorEventArtifactRequest(HANDLE                f_hApp);
 716
 717   EFrameworkunifiedStatus  SendLogArtifactResponseToLogger(HANDLE                f_hApp,
 718                                               EArtifactId           f_artifactId,
 719                                               std::string           f_artifactFilePathAndName);
 720
 721   EFrameworkunifiedStatus  OnErrorEventLoggingComplete(HANDLE                f_hApp);
 722
 723   EFrameworkunifiedStatus  ActOnModuleFailure(HANDLE                f_hApp,
 724                                  SS_String             f_moduleName,
 725                                  BOOL                 &f_refResetRequired);  // NOLINT
 726   std::string ErrorEventCreateHmiDisplayString(void);
 727
 728   //                                                                       *
 729   // End of Error Event Logging                                            *
 730   //************************************************************************
 731
 732   UI_32 m_SystemManagerPriority;
 733 };
 734 #define REC_HIST(pStrCmd, hist, it, pStrSender)    \
 735   SetCmdHist(pStrCmd, hist, it, pStrSender);
 736
 737 #define REC_HIST_IF_SUCCESSFUL(pStr, hist, it, sender, l_eStatus) \
 738   if (eFrameworkunifiedStatusOK == l_eStatus) {     \
 739     REC_HIST(pStr, hist, it, sender) \
 740   }
 741
 742 #define LOG_ERROR_REC_HIST(l_eStatus, pStr) { \
 743     LOG_ERROR(pStr);                     \
 744     REC_HIST(pStr, m_ErrHist, m_ErrHistIter, GetStr(l_eStatus).c_str()); \
 745   }
 746 #define LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, pStr)   \
 747   if (eFrameworkunifiedStatusOK != l_eStatus) { \
 748     LOG_ERROR(pStr);                 \
 749     REC_HIST(pStr, m_ErrHist, m_ErrHistIter, GetStr(l_eStatus).c_str()); \
 750   } else {                           \
 751     LOG_SUCCESS(pStr);               \
 752   }  // End of #define LOG_STATUS(l_eStatus,pStr)
 753
 754 #define LOG_ERROR_REC_HIST_IF_ERRORED(l_eStatus, pStr) \
 755   if (eFrameworkunifiedStatusOK != l_eStatus) {                  \
 756     LOG_ERROR(pStr);                                  \
 757     REC_HIST(pStr, m_ErrHist, m_ErrHistIter, GetStr(l_eStatus).c_str()); \
 758   }  // End of #define LOG_STATUS_IF_ERRORED(l_eStatus,pStr)
 759
 760 #endif  // __SS_SYSTEM_MANAGER_H__  // NOLINT