service/system/interface_unified/library/src/ss_sm_client.cpp

   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_SystemManagerIf
  19 /// \brief    This file provides support for the System Manager client interface.
  20 ///
  21 ///////////////////////////////////////////////////////////////////////////////
  22 #include "system_service/ss_sm_client_if.h"
  23 #include <sys/mount.h>
  24 #include <errno.h>
  25 #include <string.h>
  26 #include <fcntl.h>
  27
  28 #include <native_service/frameworkunified_application.h>
  29 #include <native_service/frameworkunified_framework_if.h>
  30 #include <native_service/frameworkunified_types.h>
  31 #include <native_service/frameworkunified_framework_types.h>
  32 #include <native_service/frameworkunified_dispatcher.h>
  33 #include <native_service/frameworkunified_sm_framework_dispatch.h>
  34 #include <native_service/frameworkunified_sm_hsmframework.h>
  35
  36 #include <string>
  37
  38 #include "system_service/ss_system_manager_if.h"
  39 #include "system_service/ss_system_manager_protocol.h"
  40 #include "system_service/ss_system_manager_notifications.h"
  41 #include "system_service/ss_system_if.h"
  42 #include "system_service/ss_services.h"
  43 #include "system_service/ss_power_service_protocol.h"
  44 #include "system_service/ss_templates.h"
  45 #include "system_service/ss_string_maps.h"
  46 #include "system_service/ss_error_message.h"
  47 #include "system_service/ss_sm_client_if_local.h"
  48
  49 #include "system_service/ss_boot_map.h"
  50 #include "ss_system_if_interfaceunifiedlog.h"
  51
  52 typedef struct {
  53   BOOL fAvailable;
  54   HANDLE hService;
  55   std::string szServiceName;
  56   std::string strIAm;
  57 } TSystemManagerSession;  // LCOV_EXCL_BR_LINE 11:Unexpected branch
  58
  59 typedef enum {
  60   MODULE_STATE_INVALID = 0,   /// Initial state of all modules
  61   MODULE_STATE_CONNECTING,    /// Attempting to established a session connection
  62   MODULE_STATE_CONNECTED,     /// A session connection has been established
  63   MODULE_STATE_STARTING,      /// Received a START from System Manager,
  64   ///     called FrameworkunifiedOnStart or enqueued evStart
  65   MODULE_STATE_START_FAILED,  /// Application returned error from FrameworkunifiedOnStart
  66   MODULE_STATE_STARTED,       /// Sent Start Response to System Manager
  67   MODULE_STATE_STOPPING,      /// Received a Stop Request from System Manager,
  68   ///     called FrameworkunifiedOnStop or enqueued evStop
  69   MODULE_STATE_STOP_FAILED,   /// Application returned error from FrameworkunifiedOnStop
  70   MODULE_STATE_STOPPED,       /// Sent Start Response to System Manager
  71   MODULE_STATE_DEBUG_DUMPING,
  72   MODULE_STATE_STARTED_PRE,               //!< Sent Pre-Start Response to System Manager
  73   MODULE_STATE_START_PRE_FAILED,          //!< Application returned error from FrameworkunifiedOnPreStart
  74   MODULE_STATE_STOPPED_PRE,               //!< Sent Pre-Stop Response to System Manager
  75   MODULE_STATE_STOP_PRE_FAILED,           //!< Application returned error from FrameworkunifiedOnPreStop
  76   MODULE_STATE_STARTED_BACKGROUND,        //!< Sent Background-Start Response to System Manager
  77   MODULE_STATE_START_BACKGROUND_FAILED,   //!< Application returned error from FrameworkunifiedOnBackgroundStart
  78   MODULE_STATE_STOPPED_BACKGROUND,        //!< Sent Background-Stop Response to System Manager
  79   MODULE_STATE_STOP_BACKGROUND_FAILED     //!< Application returned error from FrameworkunifiedOnBackgroundStop
  80 } ModuleStateType;
  81
  82 static SMStopCompleteAck g_responseCompleteAck;
  83
  84 static EFrameworkunifiedStatus OnSystemManagerStart(HANDLE hApp);
  85 static EFrameworkunifiedStatus OnSystemManagerStop(HANDLE hApp);
  86 static EFrameworkunifiedStatus OnSystemManagerPreStart(HANDLE hApp);
  87 static EFrameworkunifiedStatus OnSystemManagerPreStop(HANDLE hApp);
  88 static EFrameworkunifiedStatus OnSystemManagerBackgroundStart(HANDLE hApp);
  89 static EFrameworkunifiedStatus OnSystemManagerBackgroundStop(HANDLE hApp);
  90 static EFrameworkunifiedStatus OnSystemManagerOpenSessionAck(HANDLE hApp);
  91 static EFrameworkunifiedStatus DebugDumpAppCbStatistics(HANDLE hApp);
  92 static EFrameworkunifiedStatus DebugDumpMemoryMap(HANDLE hApp);
  93 static EFrameworkunifiedStatus SystemManagerOpenSender(HANDLE hApp);
  94
  95 static TSystemManagerSession g_tSystemManagerSession = { };  // LCOV_EXCL_BR_LINE 11:Unexpected branch
  96 static pthread_mutex_t gMutexObj = PTHREAD_MUTEX_INITIALIZER;
  97
  98 static EFrameworkunifiedStatus SendMsgToSystemManager(UI_32 uiCmd, UI_32 uiLength,
  99     PCVOID pData);
 100 static EFrameworkunifiedStatus SendMsgToSystemManager(UI_32 uiCmd, PCSTR f_pCmdName,
 101     UI_32 uiLength, PCVOID pData);
 102
 103 static EFrameworkunifiedStatus InvokeSyncRequestToSystemManager(UI_32 uiCmd,
 104     PCSTR f_pCmdName,
 105     UI_32 uiLength, PCVOID pData,
 106     UI_32 uiResLength,
 107     PVOID pResData);
 108
 109 static EFrameworkunifiedStatus CommonSystemManagerStartStopCallbackProcessing(
 110   HANDLE hApp, UI_32 f_InterfaceunifiedEvID, SS_String f_pInterfaceunifiedEvName, CbFuncPtr f_InterfaceunifiedFncCb,
 111   PCSTR f_pInterfaceunifiedFncName, ModuleStateType f_moduleSuccessState,
 112   ModuleStateType f_moduleFailureState, BOOL f_bUseNotificationVsFncFlag,
 113   PCSTR f_pUseNotificationText, SS_SystemManagerProtocol f_ProtocolId,
 114   PCSTR f_pProtocolName);
 115
 116 static EFrameworkunifiedStatus SendInterfaceunifiedOnResponseToSystemManager(
 117   SS_SystemManagerProtocol f_ProtocolID, PCSTR f_pProtocolName,
 118   PCSTR f_InterfaceunifiedOnFncName, ModuleStateType f_moduleSuccessState,
 119   ModuleStateType f_moduleFailureState, EFrameworkunifiedStatus f_eStatus);
 120
 121 // Pointer of function which is called when SM OpenSession Ack is received.
 122 // client can register this function pointer using RegisterSMSessionAckCallback() API
 123 static CbFuncPtr CallbackFnPtr = NULL;
 124
 125 static BOOL UseStopCompleteNotificationVsInterfaceunifiedOnStopFnc = FALSE;
 126
 127 static VOID LoadCbHandlerCmdIDsIntoDetachCbIDsArray(
 128   const FrameworkunifiedProtocolCallbackHandler* pMsgHandler, UI_32 * puiCmdIdArray,
 129   UI_32 uiHandlerCount);
 130
 131 static VOID SetModuleState(ModuleStateType f_moduleState, BOOL f_bLog = TRUE);
 132
 133 static ModuleStateType g_moduleState = MODULE_STATE_INVALID;
 134 extern HANDLE g_SystemIf_hApp;
 135
 136 //******************************************************************************
 137 void Init_SS_IF_ModuleState_StrMap(
 138   std::map<ModuleStateType, SS_String> & m_strMap) {  // NOLINT (runtime/references)
 139 // LCOV_EXCL_BR_START 11:Unexpected branch
 140   MAP_ENTRY(m_strMap, MODULE_STATE_INVALID);
 141   MAP_ENTRY(m_strMap, MODULE_STATE_CONNECTING);
 142   MAP_ENTRY(m_strMap, MODULE_STATE_CONNECTED);
 143   MAP_ENTRY(m_strMap, MODULE_STATE_STARTING);
 144   MAP_ENTRY(m_strMap, MODULE_STATE_START_FAILED);
 145   MAP_ENTRY(m_strMap, MODULE_STATE_STARTED);
 146   MAP_ENTRY(m_strMap, MODULE_STATE_STOPPING);
 147   MAP_ENTRY(m_strMap, MODULE_STATE_STOP_FAILED);
 148   MAP_ENTRY(m_strMap, MODULE_STATE_STOPPED);
 149   MAP_ENTRY(m_strMap, MODULE_STATE_STARTED_PRE);
 150   MAP_ENTRY(m_strMap, MODULE_STATE_START_PRE_FAILED);
 151   MAP_ENTRY(m_strMap, MODULE_STATE_STOPPED_PRE);
 152   MAP_ENTRY(m_strMap, MODULE_STATE_STOP_PRE_FAILED);
 153   MAP_ENTRY(m_strMap, MODULE_STATE_STARTED_BACKGROUND);
 154   MAP_ENTRY(m_strMap, MODULE_STATE_START_BACKGROUND_FAILED);
 155   MAP_ENTRY(m_strMap, MODULE_STATE_STOPPED_BACKGROUND);
 156   MAP_ENTRY(m_strMap, MODULE_STATE_STOP_BACKGROUND_FAILED);
 157   MAP_ENTRY(m_strMap, MODULE_STATE_DEBUG_DUMPING);
 158 // LCOV_EXCL_BR_STOP
 159 }  // End of void Init_SS_IF_ModuleState_StrMap(std::map<ModuleStateType, SS_String> & m_strMap)
 160
 161 class EnumStringMap<ModuleStateType, Init_SS_IF_ModuleState_StrMap> g_oSS_IF_ModuleStateStrMap;
 162
 163 // LCOV_EXCL_START 6:Because the condition cannot be set
 164 SS_String GetStr(ModuleStateType f_enum) {
 165   return g_oSS_IF_ModuleStateStrMap.GetStr(f_enum);
 166 }
 167
 168 HANDLE GetSystemManagerSessionHandle(void) {
 169   return g_tSystemManagerSession.hService;
 170 }  // End of HANDLE GetSystemManagerSessionHandle(void)
 171 // LCOV_EXCL_STOP
 172
 173 EFrameworkunifiedStatus InterfaceunifiedSystemConnectToSystemManagerService(HANDLE hApp) {
 174   EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
 175   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 176
 177   CallbackFnPtr = NULL;
 178
 179   /// Avoid opening a session to the SystemManager
 180   /// service Since it uses the framework as well
 181   if (0 != strcmp(SERVICE_SYSMANAGER, FrameworkunifiedGetAppName(hApp))) {
 182     // LCOV_EXCL_BR_LINE 6:Duplicate check(AppName has been checked by the caller)
 183     memset(&g_responseCompleteAck, 0, sizeof(g_responseCompleteAck));
 184     g_responseCompleteAck.unSessionId = 0;
 185     strcpy(g_responseCompleteAck.szServiceName, SERVICE_SYSMANAGER);  // NOLINT (runtime/printf)
 186
 187     pthread_mutex_lock(&gMutexObj);
 188
 189     /// Need to save the Group and Subgroup values
 190     g_tSystemManagerSession.szServiceName = SERVICE_SYSMANAGER;
 191     g_tSystemManagerSession.strIAm = FrameworkunifiedGetAppName(hApp);
 192
 193     /// Cleanup any other data members
 194     g_tSystemManagerSession.fAvailable = FALSE;
 195     g_tSystemManagerSession.hService = NULL;
 196
 197     pthread_mutex_unlock(&gMutexObj);
 198
 199     l_eStatus = SystemManagerOpenSender(hApp);
 200
 201     LOG_STATUS_IF_ERRORED(l_eStatus, "SystemManagerOpenSender()");
 202   } else {
 203     // LCOV_EXCL_START 6:Duplicate check(AppName has been checked by the caller)
 204     FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
 205            " I am SystemManager ! Not registering for '%s' notification",
 206            NTFY_SSSystemMgrAvailability);
 207     // LCOV_EXCL_STOP
 208   }
 209   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 210   return l_eStatus;
 211 }
 212
 213 ///////////////////////////////////////////////////////////
 214 /// Function: SystemManagerOpenSender
 215 ///
 216 ///////////////////////////////////////////////////////////
 217
 218 EFrameworkunifiedStatus SystemManagerOpenSender(HANDLE hApp) {
 219   EFrameworkunifiedStatus l_eStatus;
 220
 221   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 222
 223   pthread_mutex_lock(&gMutexObj);
 224
 225   // LCOV_EXCL_START 6:Duplicate check(hService is NULL only)
 226   if (g_tSystemManagerSession.hService != NULL) {
 227     FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, " Warn: hService != NULL");
 228     pthread_mutex_unlock(&gMutexObj);
 229     return eFrameworkunifiedStatusFail;
 230   }
 231   // LCOV_EXCL_STOP
 232
 233   // opening the service
 234   if (NULL
 235       == (g_tSystemManagerSession.hService = FrameworkunifiedMcOpenSender(hApp,
 236           SERVICE_SYSMANAGER))) {
 237     l_eStatus = eFrameworkunifiedStatusNullPointer;
 238     LOG_ERROR("FrameworkunifiedMcOpenSender(SERVICE_SYSMANAGER)");
 239   } else {
 240     FrameworkunifiedProtocolCallbackHandler l_SystemManager_Protocol_Cbs[] = {
 241       // Command ID,              Call back functions
 242       { SS_SM_PROTOCOL_OPEN_SESSION_ACK, OnSystemManagerOpenSessionAck },
 243       { SS_SM_START, OnSystemManagerStart },
 244       { SS_SM_STOP, OnSystemManagerStop },
 245       { SS_SM_PRE_START, OnSystemManagerPreStart },
 246       { SS_SM_PRE_STOP, OnSystemManagerPreStop },
 247       { SS_SM_BACKGROUND_START, OnSystemManagerBackgroundStart },
 248       { SS_SM_BACKGROUND_STOP, OnSystemManagerBackgroundStop },
 249       { SS_SM_DEBUG_DUMP, OnSystemManagerDebugDump },
 250     };  // LCOV_EXCL_BR_LINE 11:Unexpected branch
 251
 252     /// Attach the valid callback for this service
 253     if (eFrameworkunifiedStatusOK !=  // LCOV_EXCL_BR_LINE 11:Unexpected branch
 254         (l_eStatus = FrameworkunifiedAttachCallbacksToDispatcher(
 255                        hApp, SERVICE_SYSMANAGER, l_SystemManager_Protocol_Cbs,
 256                        _countof(l_SystemManager_Protocol_Cbs)))) {
 257       LOG_ERROR("FrameworkunifiedAttachCallbacksToDispatcher()");
 258     } else if (eFrameworkunifiedStatusOK !=  // LCOV_EXCL_BR_LINE 11:Unexpected branch
 259                (l_eStatus = FrameworkunifiedSendMsg(g_tSystemManagerSession.hService,
 260                                        SS_SM_PROTOCOL_OPEN_SESSION_REQ, 0, NULL))) {
 261       FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: FrameworkunifiedSendMsg(%s) errored: 0x%X/%s",
 262              g_tSystemManagerSession.szServiceName.c_str(), l_eStatus,
 263              GetStr(l_eStatus).c_str());
 264     }  // LCOV_EXCL_BR_LINE 11:Unexpected branch
 265   }
 266   pthread_mutex_unlock(&gMutexObj);
 267
 268   if (eFrameworkunifiedStatusOK == l_eStatus) {
 269     g_moduleState = MODULE_STATE_CONNECTING;
 270   }
 271
 272   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 273   return l_eStatus;  // LCOV_EXCL_BR_LINE 11:Unexpected branch
 274 }
 275
 276 // LCOV_EXCL_START 6:Because the condition cannot be set
 277 ///////////////////////////////////////////////////////////
 278 /// Function: OnSystemManagerOpenSessionAck
 279 /// Service Manager OpenSession callback
 280 ///////////////////////////////////////////////////////////
 281 EFrameworkunifiedStatus OnSystemManagerOpenSessionAck(HANDLE hApp) {
 282   EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
 283   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 284
 285   if (NULL == hApp) {
 286     l_eStatus = eFrameworkunifiedStatusNullPointer;
 287     LOG_ERROR("NULL == hApp");
 288   } else {
 289     pthread_mutex_lock(&gMutexObj);
 290     if (NULL == g_tSystemManagerSession.hService) {
 291       l_eStatus = eFrameworkunifiedStatusNullPointer;
 292       LOG_ERROR("FrameworkunifiedGetOpenSessionHandle()");
 293       g_tSystemManagerSession.fAvailable = FALSE;
 294     } else {
 295       LOG_SUCCESS("FrameworkunifiedGetOpenSessionHandle(hApp)");
 296       g_tSystemManagerSession.fAvailable = TRUE;
 297       g_moduleState = MODULE_STATE_CONNECTED;
 298     }
 299     pthread_mutex_unlock(&gMutexObj);
 300
 301     if ((eFrameworkunifiedStatusOK == l_eStatus) && (CallbackFnPtr != NULL)) {
 302       // Call the RegisterSMSessionAckCallback()-registered function
 303       if (eFrameworkunifiedStatusOK != (l_eStatus = (CallbackFnPtr)(hApp))) {
 304         FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
 305                " Error: The 'CallbackFnPtr' function as set by "
 306                "the RegisterSMSessionAckCallback() function "
 307                "errored: 0x%x/%s",
 308                l_eStatus, GetStr(l_eStatus).c_str());
 309       }
 310     }
 311   }
 312   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 313   return l_eStatus;
 314 }  // EFrameworkunifiedStatus OnSystemManagerOpenSessionAck( HANDLE hApp )
 315 // LCOV_EXCL_STOP
 316
 317 ///////////////////////////////////////////////////////////
 318 /// Macro:
 319 ///
 320 ///////////////////////////////////////////////////////////
 321 #define SETUP_AND_CALL_COMMON_SYSTEM_MANAGER_START_STOP_PROCESSING(      \
 322         hApp, evInterfaceunifiedId, InterfaceunifiedFnc, ModStateSuccess, ModStateFailure, \
 323                 NotifFlag, NotifText, ProtocolId) \
 324   l_eStatus = CommonSystemManagerStartStopCallbackProcessing(         \
 325                           hApp,                \
 326                           evInterfaceunifiedId,             \
 327                           #evInterfaceunifiedId,            \
 328                           InterfaceunifiedFnc,              \
 329                           #InterfaceunifiedFnc "()",        \
 330                           ModStateSuccess,     \
 331                           ModStateFailure,     \
 332                           NotifFlag,           \
 333                           NotifText,           \
 334                           ProtocolId,          \
 335                                                     #ProtocolId);       \
 336   LOG_STATUS(l_eStatus,                                               \
 337                 "CommonSystemManagerStartStopCallbackProcessing(" #InterfaceunifiedFnc "())");
 338
 339 // LCOV_EXCL_START 6:Because the condition cannot be set
 340 ///////////////////////////////////////////////////////////
 341 /// Function: OnSystemManagerStart
 342 ///
 343 ///////////////////////////////////////////////////////////
 344 EFrameworkunifiedStatus OnSystemManagerStart(HANDLE hApp) {
 345   EFrameworkunifiedStatus l_eStatus;
 346   FrameworkunifiedDefaultCallbackHandler cbFuncs;
 347   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 348
 349   l_eStatus = FrameworkunifiedGetDefaultCbHandler(&cbFuncs);
 350   LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedGetDefaultCbHandler()");
 351
 352   // Call CommonSystemManagerStartStopCallbackProcessing(), & log status
 353   SETUP_AND_CALL_COMMON_SYSTEM_MANAGER_START_STOP_PROCESSING(
 354     hApp, FRAMEWORKUNIFIED_EVENT(evFrameworkunifiedStart), cbFuncs.onStart, MODULE_STATE_STARTED,
 355     MODULE_STATE_START_FAILED, FALSE, "", SS_SM_START_COMPL_RSPN);
 356   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 357   return l_eStatus;
 358 }  // End of EFrameworkunifiedStatus OnSystemManagerStart( HANDLE hApp )
 359
 360 ///////////////////////////////////////////////////////////
 361 /// Function: OnSystemManagerStop
 362 ///
 363 ///////////////////////////////////////////////////////////
 364 EFrameworkunifiedStatus OnSystemManagerStop(HANDLE hApp) {
 365   EFrameworkunifiedStatus l_eStatus;
 366   FrameworkunifiedDefaultCallbackHandler cbFuncs;
 367   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 368
 369   l_eStatus = FrameworkunifiedGetDefaultCbHandler(&cbFuncs);
 370   LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedGetDefaultCbHandler()");
 371
 372   // Call CommonSystemManagerStartStopCallbackProcessing(), & log status
 373   SETUP_AND_CALL_COMMON_SYSTEM_MANAGER_START_STOP_PROCESSING(
 374     hApp, FRAMEWORKUNIFIED_EVENT(evFrameworkunifiedStop), cbFuncs.onStop, MODULE_STATE_STOPPED,
 375     MODULE_STATE_STOP_FAILED, UseStopCompleteNotificationVsInterfaceunifiedOnStopFnc,
 376     " 'UseStopCompleteNotificationVsInterfaceunifiedOnStopFnc' is 'True': "
 377     "setting 'l_eStatus' to 'eFrameworkunifiedStatusFail'",
 378     SS_SM_STOP_COMPL_RSPN);
 379
 380   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 381   return l_eStatus;
 382 }  // End of EFrameworkunifiedStatus OnSystemManagerStop( HANDLE hApp )
 383
 384 ///////////////////////////////////////////////////////////
 385 /// Function: OnSystemManagerPreStart
 386 ///
 387 ///////////////////////////////////////////////////////////
 388 static EFrameworkunifiedStatus OnSystemManagerPreStart(HANDLE hApp) {
 389   EFrameworkunifiedStatus l_eStatus;
 390   FrameworkunifiedDefaultCallbackHandler cbFuncs;  // LCOV_EXCL_BR_LINE 11:Excluded due to gcov restrictions(others)
 391   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 392
 393   l_eStatus = FrameworkunifiedGetDefaultCbHandler(&cbFuncs);  // LCOV_EXCL_BR_LINE 11:Excluded due to gcov restrictions(others)
 394   LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedGetDefaultCbHandler()");
 395
 396   // Call CommonSystemManagerStartStopCallbackProcessing(), & log status
 397   SETUP_AND_CALL_COMMON_SYSTEM_MANAGER_START_STOP_PROCESSING(
 398       hApp,
 399       FRAMEWORKUNIFIED_EVENT(evFrameworkunifiedPreStart),
 400       cbFuncs.onPreStart,
 401       MODULE_STATE_STARTED_PRE,
 402       MODULE_STATE_START_PRE_FAILED,
 403       FALSE,
 404       "",
 405       SS_SM_PRE_START_COMPL_RSPN);
 406   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");  // LCOV_EXCL_BR_LINE 15:Excluded for function that are expanded inline
 407   return l_eStatus;
 408 }  // End of EFrameworkunifiedStatus OnSystemManagerPreStart( HANDLE hApp )
 409
 410 ///////////////////////////////////////////////////////////
 411 /// Function: OnSystemManagerPreStop
 412 ///
 413 ///////////////////////////////////////////////////////////
 414 static EFrameworkunifiedStatus OnSystemManagerPreStop(HANDLE hApp) {
 415   EFrameworkunifiedStatus l_eStatus;
 416   FrameworkunifiedDefaultCallbackHandler cbFuncs;  // LCOV_EXCL_BR_LINE 11:Excluded due to gcov restrictions(others)
 417   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 418
 419   l_eStatus = FrameworkunifiedGetDefaultCbHandler(&cbFuncs);  // LCOV_EXCL_BR_LINE 11:Excluded due to gcov restrictions(others)
 420   LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedGetDefaultCbHandler()");
 421
 422   // Call CommonSystemManagerStartStopCallbackProcessing(), & log status
 423   SETUP_AND_CALL_COMMON_SYSTEM_MANAGER_START_STOP_PROCESSING(
 424       hApp,
 425       FRAMEWORKUNIFIED_EVENT(evFrameworkunifiedPreStop),
 426       cbFuncs.onPreStop,
 427       MODULE_STATE_STOPPED_PRE,
 428       MODULE_STATE_STOP_PRE_FAILED,
 429       FALSE,
 430       "",
 431       SS_SM_PRE_STOP_COMPL_RSPN);
 432   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");  // LCOV_EXCL_BR_LINE 15:Excluded for function that are expanded inline
 433   return l_eStatus;
 434 }  // End of EFrameworkunifiedStatus OnSystemManagerPreStop( HANDLE hApp )
 435
 436 ///////////////////////////////////////////////////////////
 437 /// Function: OnSystemManagerBackgroundStart
 438 ///
 439 ///////////////////////////////////////////////////////////
 440 static EFrameworkunifiedStatus OnSystemManagerBackgroundStart(HANDLE hApp) {
 441   EFrameworkunifiedStatus l_eStatus;
 442   FrameworkunifiedDefaultCallbackHandler cbFuncs;  // LCOV_EXCL_BR_LINE 11:Excluded due to gcov restrictions(others)
 443   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 444
 445   l_eStatus = FrameworkunifiedGetDefaultCbHandler(&cbFuncs);  // LCOV_EXCL_BR_LINE 11:Excluded due to gcov restrictions(others)
 446   LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedGetDefaultCbHandler()");
 447
 448   // Call CommonSystemManagerStartStopCallbackProcessing(), & log status
 449   SETUP_AND_CALL_COMMON_SYSTEM_MANAGER_START_STOP_PROCESSING(
 450       hApp,
 451       FRAMEWORKUNIFIED_EVENT(evFrameworkunifiedBackgroundStart),
 452       cbFuncs.onBackgroundStart,
 453       MODULE_STATE_STARTED_BACKGROUND,
 454       MODULE_STATE_START_BACKGROUND_FAILED,
 455       FALSE,
 456       "",
 457       SS_SM_BACKGROUND_START_COMPL_RSPN);
 458   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");  // LCOV_EXCL_BR_LINE 15:Excluded for function that are expanded inline
 459   return l_eStatus;
 460 }  // End of EFrameworkunifiedStatus OnSystemManagerBackgroundStart( HANDLE hApp )
 461
 462 ///////////////////////////////////////////////////////////
 463 /// Function: OnSystemManagerBackgroundStop
 464 ///
 465 ///////////////////////////////////////////////////////////
 466 static EFrameworkunifiedStatus OnSystemManagerBackgroundStop(HANDLE hApp) {
 467   EFrameworkunifiedStatus l_eStatus;
 468   FrameworkunifiedDefaultCallbackHandler cbFuncs;  // LCOV_EXCL_BR_LINE 11:Excluded due to gcov restrictions(others)
 469   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 470
 471   l_eStatus = FrameworkunifiedGetDefaultCbHandler(&cbFuncs);  // LCOV_EXCL_BR_LINE 11:Excluded due to gcov restrictions(others)
 472   LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedGetDefaultCbHandler()");
 473
 474   // Call CommonSystemManagerStartStopCallbackProcessing(), & log status
 475   SETUP_AND_CALL_COMMON_SYSTEM_MANAGER_START_STOP_PROCESSING(
 476       hApp,
 477       FRAMEWORKUNIFIED_EVENT(evFrameworkunifiedBackgroundStop),
 478       cbFuncs.onBackgroundStop,
 479       MODULE_STATE_STOPPED_BACKGROUND,
 480       MODULE_STATE_STOP_BACKGROUND_FAILED,
 481       FALSE,
 482       "",
 483       SS_SM_BACKGROUND_STOP_COMPL_RSPN);
 484   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");  // LCOV_EXCL_BR_LINE 15:Excluded for function that are expanded inline
 485   return l_eStatus;
 486 }  // End of EFrameworkunifiedStatus OnSystemManagerBackgroundStop( HANDLE hApp )
 487
 488 ///////////////////////////////////////////////////////////
 489 /// Function: CommonSystemManagerStartStopCallbackProcessing
 490 ///
 491 ///////////////////////////////////////////////////////////
 492 EFrameworkunifiedStatus CommonSystemManagerStartStopCallbackProcessing(
 493   HANDLE hApp, UI_32 f_InterfaceunifiedEvID, SS_String f_pInterfaceunifiedEvName, CbFuncPtr f_InterfaceunifiedFncCb,
 494   PCSTR f_pInterfaceunifiedFncName, ModuleStateType f_moduleSuccessState,
 495   ModuleStateType f_moduleFailureState, BOOL f_bUseNotificationVsFncFlag,
 496   PCSTR f_pUseNotificationText, SS_SystemManagerProtocol f_ProtocolId,
 497   PCSTR f_pProtocolName) {
 498   EFrameworkunifiedStatus l_eStatus;
 499   EFrameworkunifiedStatus l_StatusFncReturned;
 500   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 501   SS_String l_pInterfaceunifiedFncName;
 502
 503   if (f_moduleSuccessState == g_moduleState) {
 504     FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__,
 505            " Warning: Module state already is '%s', just "
 506            "returning '%s' to System Manager",
 507            GetStr(g_moduleState).c_str(), f_pProtocolName);
 508     l_eStatus = eFrameworkunifiedStatusOK;
 509     l_StatusFncReturned = l_eStatus;
 510   } else {
 511     // If client application is a state machine, post an Event instead of calling
 512     // InterfaceunifiedOnXYZ()
 513     if (FrameworkunifiedIsStateMachineApp(hApp)) {
 514       l_pInterfaceunifiedFncName = "FrameworkunifiedPostEvent(FRAMEWORKUNIFIED_EVENT(" + f_pInterfaceunifiedEvName + " ))";
 515       CFrameworkunifiedHSMFramework* l_pStateMachine = FrameworkunifiedGetStateMachine(hApp);
 516       if (NULL == l_pStateMachine) {
 517         l_eStatus = eFrameworkunifiedStatusNullPointer;
 518         LOG_ERROR("FrameworkunifiedGetStateMachine()");
 519         l_StatusFncReturned = l_eStatus;
 520       } else {
 521         l_eStatus = l_pStateMachine->FrameworkunifiedPostEvent(f_InterfaceunifiedEvID);
 522         if (eFrameworkunifiedStatusOK != l_eStatus) {
 523           FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
 524                  " Error: l_pStateMachine->FrameworkunifiedPostEvent(%s) "
 525                  "errored: %d/'%s'",
 526                  f_pInterfaceunifiedEvName.c_str(), l_eStatus, GetStr(l_eStatus).c_str());
 527           l_StatusFncReturned = l_eStatus;
 528         } else {
 529           FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
 530                  " f_bUseNotificationVsFncFlag is '%s'",
 531                  GetStr(f_bUseNotificationVsFncFlag).c_str());
 532           if (f_bUseNotificationVsFncFlag) {
 533             //
 534             // DON'T send an 'Ok' back to the SendInterfaceunifiedOnResponse function: if
 535             // it detects a 'Ok' it will send a SS_SM_<protocol>_RSPN back
 536             // to System Manager, telling System Manager that the request
 537             // has been completely serviced.
 538             l_StatusFncReturned = eFrameworkunifiedStatusFail;
 539             FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "%s", f_pUseNotificationText);
 540           } else {
 541             //
 542             // Always send an 'Ok' back for the evInterfaceunified<protocol> version
 543             // of InterfaceunifiedOn<protocol>; the l_eStatus applies to the
 544             // FrameworkunifiedPostEvent() function, not the actual <protocol> event
 545             // handler.
 546             l_StatusFncReturned = eFrameworkunifiedStatusOK;
 547           }
 548         }  // End else successful FrameworkunifiedPostEvent()
 549       }  // End else valid FrameworkunifiedGetStateMachine()
 550     } else {  // End if FrameworkunifiedIsStateMachineApp() is TRUE
 551       l_pInterfaceunifiedFncName = f_pInterfaceunifiedFncName;
 552       if (f_InterfaceunifiedFncCb) {
 553         l_eStatus = (f_InterfaceunifiedFncCb)(hApp);
 554         LOG_STATUS(l_eStatus, f_pInterfaceunifiedFncName);
 555         l_StatusFncReturned = l_eStatus;
 556       } else {
 557         SS_ASERT(0);
 558         l_StatusFncReturned = eFrameworkunifiedStatusOK;
 559       }
 560     }
 561   }
 562
 563   l_eStatus = SendInterfaceunifiedOnResponseToSystemManager(f_ProtocolId, f_pProtocolName,
 564               l_pInterfaceunifiedFncName.c_str(),
 565               f_moduleSuccessState,
 566               f_moduleFailureState,
 567               l_StatusFncReturned);
 568   const char l_cFormat[] = "SendInterfaceunifiedOnResponseToSystemManager(%s)";
 569   char l_cBuf[sizeof(l_cFormat) + strlen(f_pProtocolName) + 1];  // NOLINT (runtime/arrays)
 570   snprintf(l_cBuf, sizeof(l_cBuf), l_cFormat, f_pProtocolName);
 571   LOG_STATUS_IF_ERRORED(l_eStatus, l_cBuf);
 572
 573   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 574   return l_eStatus;
 575 }  // End of CommonSystemManagerStartStopCallbackProcessing(
 576
 577
 578 ///////////////////////////////////////////////////////////
 579 /// Function: SendInterfaceunifiedOnStopResponseToSystemManager()
 580 ///
 581 ///////////////////////////////////////////////////////////
 582 EFrameworkunifiedStatus SendInterfaceunifiedOnStopResponseToSystemManager(EFrameworkunifiedStatus f_eStatus) {
 583   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 584   EFrameworkunifiedStatus l_eStatus = SendInterfaceunifiedOnResponseToSystemManager(
 585                            SS_SM_STOP_COMPL_RSPN, "SS_SM_STOP_COMPL_RSPN", "FrameworkunifiedOnStop()",
 586                            MODULE_STATE_STOPPED, MODULE_STATE_STOP_FAILED, f_eStatus);
 587   LOG_STATUS_IF_ERRORED(l_eStatus, "SendInterfaceunifiedOnResponseToSystemManager("
 588                         "SS_SM_STOP_COMPL_RSPN");
 589   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 590   return l_eStatus;
 591 }  // End of EFrameworkunifiedStatus SendInterfaceunifiedOnStopResponseToSystemManager(EFrameworkunifiedStatus f_eStatus)
 592
 593 ///////////////////////////////////////////////////////////
 594 /// Function: GetInterfaceunifiedOnStartExtInfo()
 595 ///
 596 ///////////////////////////////////////////////////////////
 597 EFrameworkunifiedStatus GetInterfaceunifiedOnStartExtInfo(T_SS_SM_START_ExtDataStructType &f_info) {  // NOLINT (runtime/references)
 598   EFrameworkunifiedStatus l_eStatus;
 599   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 600
 601   l_eStatus = InvokeSyncRequestToSystemManager(
 602                 SS_SM_GET_START_EXT_INFO, "SS_SM_GET_START_EXT_INFO", 0, NULL,
 603                 sizeof(T_SS_SM_START_ExtDataStructType), (PVOID) & f_info);
 604   LOG_STATUS_IF_ERRORED(l_eStatus, "InvokeSyncRequestToSystemManager()");
 605
 606   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 607   return l_eStatus;
 608 }
 609
 610 ///////////////////////////////////////////////////////////
 611 /// Function: GetInterfaceunifiedOnStopExtInfo()
 612 ///
 613 ///////////////////////////////////////////////////////////
 614 EFrameworkunifiedStatus GetInterfaceunifiedOnStopExtInfo(T_SS_SM_STOP_ExtDataStructType &f_info) {  // NOLINT (runtime/references)
 615   EFrameworkunifiedStatus l_eStatus;
 616   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 617
 618   l_eStatus = InvokeSyncRequestToSystemManager(
 619                 SS_SM_GET_STOP_EXT_INFO, "SS_SM_GET_STOP_EXT_INFO", 0, NULL,
 620                 sizeof(T_SS_SM_STOP_ExtDataStructType), (PVOID) & f_info);
 621   LOG_STATUS_IF_ERRORED(l_eStatus, "InvokeSyncRequestToSystemManager()");
 622
 623   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 624   return l_eStatus;
 625 }
 626
 627 // LCOV_EXCL_START 6:Because the condition cannot be set
 628 ///////////////////////////////////////////////////////////
 629 /// Function: OnSystemManagerDebugDump
 630 ///
 631 ///////////////////////////////////////////////////////////
 632 EFrameworkunifiedStatus OnSystemManagerDebugDump(HANDLE hApp) {
 633   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 634   EFrameworkunifiedStatus l_eStatus;
 635   FrameworkunifiedDefaultCallbackHandler cbFuncs;
 636
 637   g_moduleState = MODULE_STATE_DEBUG_DUMPING;
 638   l_eStatus = FrameworkunifiedGetDefaultCbHandler(&cbFuncs);
 639   LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedGetDefaultCbHandler()");
 640
 641   if (cbFuncs.onDebugDump) {
 642     l_eStatus = cbFuncs.onDebugDump(hApp);
 643     LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedOnDebugDump()");
 644   } else {
 645     SS_ASERT(0);
 646   }
 647
 648   l_eStatus = DebugDumpAppCbStatistics(hApp);
 649   LOG_STATUS_IF_ERRORED(l_eStatus, "DebugDumpAppCbStatistics()");
 650
 651   l_eStatus = DebugDumpMemoryMap(hApp);
 652   LOG_STATUS_IF_ERRORED(l_eStatus, "DebugDumpMemoryMap()");
 653
 654   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 655   return l_eStatus;
 656 }  // End of EFrameworkunifiedStatus OnSystemManagerDebugDump( HANDLE hApp )
 657
 658 ///////////////////////////////////////////////////////////
 659 /// Function: DebugDumpAppCbStatistics
 660 ///
 661 ///////////////////////////////////////////////////////////
 662 EFrameworkunifiedStatus DebugDumpAppCbStatistics(HANDLE hApp) {
 663   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 664   EFrameworkunifiedStatus l_eStatus;
 665 l_eStatus = eFrameworkunifiedStatusOK;
 666
 667 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 668 return l_eStatus;
 669 }
 670
 671 ///////////////////////////////////////////////////////////
 672 /// Function: DebugDumpMemoryMap
 673 ///
 674 ///////////////////////////////////////////////////////////
 675 EFrameworkunifiedStatus DebugDumpMemoryMap(HANDLE hApp) {
 676 #define MEM_MAP_READ_SIZE 4096
 677 #define DUMP_MAX_SIZE   131072  // 128KB
 678
 679   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 680   EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail;
 681   char buf[MEM_MAP_READ_SIZE];
 682   std::string bufString;
 683   int fd, ret;
 684
 685   fd = open("/proc/self/maps", O_RDONLY);
 686   if (fd != -1) {
 687     while ((ret = read(fd, buf, MEM_MAP_READ_SIZE)) > 0) {
 688       if ((bufString.size() + ret) > DUMP_MAX_SIZE) {
 689         // If read it again, it will break because it overflows
 690         break;
 691       }
 692       bufString.append(buf, ret);
 693     }
 694     close(fd);
 695     if (ret >= 0) {
 696       l_eStatus = eFrameworkunifiedStatusOK;
 697       SendDebugDumpResponseToSystemManager(bufString);
 698     }
 699   }
 700   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 701   return l_eStatus;
 702 }
 703 // LCOV_EXCL_STOP
 704
 705 //////////////////////////////////////////
 706 // SendDebugDumpResponseToSystemManager
 707 //////////////////////////////////////////
 708 VOID SendDebugDumpResponseToSystemManager(BOOL f_bFormatStrRequired,
 709     PCSTR f_cFormat, ...) {
 710   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 711   EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
 712   va_list l_argList;
 713   const UI_32 l_maxDebugDumpMsgSize = (1024 * 4);
 714   CHAR l_cMsg[l_maxDebugDumpMsgSize] = { 0 };
 715   PCSTR l_pAppName;
 716
 717   pthread_mutex_lock(&gMutexObj);
 718
 719   l_pAppName = FrameworkunifiedGetAppName(g_SystemIf_hApp);  // LCOV_EXCL_BR_LINE 11:Unexpected branch
 720   if (f_bFormatStrRequired) {
 721     // build a format string
 722     // Format: AppName/debugdump_data
 723     snprintf(l_cMsg, l_maxDebugDumpMsgSize, "%s/", l_pAppName);
 724   }
 725
 726   va_start(l_argList, f_cFormat);
 727   vsnprintf(&l_cMsg[strlen(l_cMsg)], l_maxDebugDumpMsgSize - strlen(l_cMsg),
 728             f_cFormat, l_argList);
 729   va_end(l_argList);
 730
 731   if (0 == strcmp(SERVICE_SYSMANAGER, l_pAppName)) {
 732     l_eStatus = FrameworkunifiedSendSelf(g_SystemIf_hApp, SS_SM_DEBUG_DUMP_RSPN,
 733                             strlen(l_cMsg) + 1, l_cMsg);  // LCOV_EXCL_BR_LINE 11:Unexpected branch
 734     LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedSendSelf(SS_SM_DEBUG_DUMP_RSPN)");
 735   } else if (NULL != g_tSystemManagerSession.hService) {
 736     l_eStatus = FrameworkunifiedSendMsg(g_tSystemManagerSession.hService,
 737                            SS_SM_DEBUG_DUMP_RSPN, strlen(l_cMsg) + 1, l_cMsg);  // LCOV_EXCL_BR_LINE 11:Unexpected branch
 738     LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedSendMsg(SS_SM_DEBUG_DUMP_RSPN)");
 739   } else {
 740     l_eStatus = eFrameworkunifiedStatusNullPointer;
 741     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
 742            " Error: Invalid handle[g_tSystemManagerSession.hService == NULL]");
 743   }
 744
 745   pthread_mutex_unlock(&gMutexObj);
 746
 747   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 748 }  // End of EFrameworkunifiedStatus SendDebugDumpResponseToSystemManager( HANDLE hApp )
 749
 750 // LCOV_EXCL_START 6:Because the condition cannot be set
 751 //////////////////////////////////////////
 752 // SendDebugDumpResponseToSystemManager
 753 //////////////////////////////////////////
 754 VOID SendDebugDumpResponseToSystemManager(std::string & f_messageStr) {  // NOLINT (runtime/references)
 755   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 756   EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
 757
 758   pthread_mutex_lock(&gMutexObj);
 759
 760   if (0 == strcmp(SERVICE_SYSMANAGER, FrameworkunifiedGetAppName(g_SystemIf_hApp))) {
 761     l_eStatus = FrameworkunifiedSendSelf(g_SystemIf_hApp, SS_SM_DEBUG_DUMP_RSPN,
 762                             f_messageStr.size() + 1, f_messageStr.c_str());
 763     LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedSendSelf(SS_SM_DEBUG_DUMP_RSPN)");
 764   } else if (NULL != g_tSystemManagerSession.hService) {
 765     l_eStatus = FrameworkunifiedSendMsg(g_tSystemManagerSession.hService,
 766                            SS_SM_DEBUG_DUMP_RSPN, f_messageStr.size() + 1,
 767                            f_messageStr.c_str());
 768     LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedSendMsg(SS_SM_DEBUG_DUMP_RSPN)");
 769   } else {
 770     l_eStatus = eFrameworkunifiedStatusNullPointer;
 771     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: hService = NULL");
 772   }
 773
 774   pthread_mutex_unlock(&gMutexObj);
 775
 776   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 777 }  // End of EFrameworkunifiedStatus SendDebugDumpResponseToSystemManager(std::string & f_messageStr)
 778 // LCOV_EXCL_STOP
 779
 780 ///////////////////////////////////////////////////////////
 781 /// Function: SendInterfaceunifiedOnResponseToSystemManager()
 782 ///
 783 ///////////////////////////////////////////////////////////
 784 EFrameworkunifiedStatus SendInterfaceunifiedOnResponseToSystemManager(
 785   SS_SystemManagerProtocol f_ProtocolID, PCSTR f_pProtocolName,
 786   PCSTR f_InterfaceunifiedOnFncName, ModuleStateType f_moduleSuccessState,
 787   ModuleStateType f_moduleFailureState, EFrameworkunifiedStatus f_eStatus) {
 788   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 789   EFrameworkunifiedStatus l_eStatus;
 790
 791   if (eFrameworkunifiedStatusOK != f_eStatus) {
 792     FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__,
 793            " Warning: '%s' returned %d/%s, NOT sending '%s' to System Manager",
 794            f_InterfaceunifiedOnFncName, f_eStatus, GetStr(f_eStatus).c_str(),
 795            f_pProtocolName);
 796     l_eStatus = f_eStatus;
 797     SetModuleState(f_moduleFailureState);
 798   } else {
 799     if (f_moduleSuccessState == g_moduleState) {
 800       FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__,
 801              " Warning: Module state already is '%s', just "
 802              "returning '%s' to System Manager",
 803              GetStr(g_moduleState).c_str(), f_pProtocolName);
 804     }
 805
 806     l_eStatus = SendMsgToSystemManager(static_cast<UI_32>(f_ProtocolID),
 807                                        f_pProtocolName,
 808                                        sizeof(g_responseCompleteAck),
 809                                        &g_responseCompleteAck);  // LCOV_EXCL_BR_LINE 11:Unexpected branch
 810     const char l_cFormat[] = "SendMsgToSystemManager(%s)";
 811     char l_cBuf[sizeof(l_cFormat) + strlen(f_pProtocolName) + 1];  // NOLINT (runtime/arrays)
 812     snprintf(l_cBuf, sizeof(l_cBuf), l_cFormat, f_pProtocolName);
 813     LOG_STATUS(l_eStatus, l_cBuf);
 814     SetModuleState(f_moduleSuccessState);
 815   }
 816
 817   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 818   return l_eStatus;
 819 }  // End of SendInterfaceunifiedOnResponseToSystemManager(
 820
 821 ///////////////////////////////////////////////////////////
 822 /// Function: SendMsgToSystemManager
 823 ///
 824 ///////////////////////////////////////////////////////////
 825 EFrameworkunifiedStatus SendMsgToSystemManager(UI_32 uiCmd, PCSTR f_pCmdName, UI_32 uiLength,
 826                                   PCVOID pData) {
 827   FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " Sending %s", f_pCmdName);
 828
 829   return SendMsgToSystemManager(uiCmd, uiLength, pData);
 830 }  // End of EFrameworkunifiedStatus SendMsgToSystemManager(UI_32 uiCmd, PCSTR f_pCmdName, UI_32 uiLength, PCVOID pData)
 831
 832 ///////////////////////////////////////////////////////////
 833 /// Function: SendMsgToSystemManager
 834 ///
 835 ///////////////////////////////////////////////////////////
 836 EFrameworkunifiedStatus SendMsgToSystemManager(UI_32 uiCmd, UI_32 uiLength, PCVOID pData) {
 837   EFrameworkunifiedStatus l_eStatus;
 838   if (NULL == g_tSystemManagerSession.hService) {
 839     l_eStatus = eFrameworkunifiedStatusNullPointer;
 840     LOG_ERROR("NULL == g_tSystemManagerSession.hService");
 841   } else {
 842     pthread_mutex_lock(&gMutexObj);
 843     l_eStatus = FrameworkunifiedSendMsg(g_tSystemManagerSession.hService, uiCmd, uiLength,
 844                            pData);
 845     pthread_mutex_unlock(&gMutexObj);
 846     LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedSendMsg()");
 847   }
 848   return l_eStatus;
 849 }  // End of EFrameworkunifiedStatus SendMsgToSystemManager(UI_32 uiCmd, UI_32 uiLength, PCVOID pData)
 850
 851 ///////////////////////////////////////////////////////////
 852 /// Function: InvokeSyncRequestToSystemManager
 853 ///
 854 ///////////////////////////////////////////////////////////
 855 EFrameworkunifiedStatus InvokeSyncRequestToSystemManager(UI_32 uiCmd, PCSTR f_pCmdName,
 856     UI_32 uiLength, PCVOID pData,
 857     UI_32 uiResLength, PVOID pResData) {
 858   EFrameworkunifiedStatus l_eStatus;
 859   UI_32 uiRcvLength = 0;
 860   FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " Sending %s", f_pCmdName);
 861
 862   if (NULL == g_tSystemManagerSession.hService) {
 863     l_eStatus = eFrameworkunifiedStatusNullPointer;
 864     LOG_ERROR("NULL == g_tSystemManagerSession.hService");
 865   } else {
 866     pthread_mutex_lock(&gMutexObj);
 867     l_eStatus = FrameworkunifiedInvokeSync(g_tSystemManagerSession.hService, uiCmd, uiLength,
 868                               pData, uiResLength, pResData, &uiRcvLength);  // LCOV_EXCL_BR_LINE 11:Unexpected branch
 869     if (eFrameworkunifiedStatusOK == l_eStatus) {
 870       if (uiResLength != uiRcvLength) {
 871         LOG_ERROR("uiResLength != uiRcvLength");
 872         l_eStatus = eFrameworkunifiedStatusFail;
 873       }
 874     }
 875     pthread_mutex_unlock(&gMutexObj);
 876     LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedInvokeSync()");
 877   }
 878   return l_eStatus;
 879 }  // End of Function
 880
 881 // LCOV_EXCL_START 6:Because the condition cannot be set
 882 ///////////////////////////////////////////////////////////
 883 /// Function: SendWakeUpToSystemManager
 884 ///
 885 ///////////////////////////////////////////////////////////
 886 EFrameworkunifiedStatus SendWakeUpToSystemManager(wakeInfo *pData) {
 887   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 888   EFrameworkunifiedStatus l_eStatus = SendMsgToSystemManager(SS_SM_WAKEUP_MODULES,
 889                          "SS_SM_WAKEUP_MODULES",
 890                          sizeof(wakeInfo),
 891                          (PCVOID) pData);
 892   LOG_STATUS_IF_ERRORED(l_eStatus, "SendMsgToSystemManager()");
 893   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 894   return l_eStatus;
 895 }  // End of EFrameworkunifiedStatus SendWakeUpToSystemManager(wakeInfo *pData)
 896 // LCOV_EXCL_STOP
 897
 898 // LCOV_EXCL_START 6:Because the condition cannot be set
 899 ///////////////////////////////////////////////////////////
 900 /// Function: SendShutdownToSystemManager
 901 ///
 902 ///////////////////////////////////////////////////////////
 903 EFrameworkunifiedStatus SendShutdownToSystemManager(Pwr_ServiceSetInterface *pData) {
 904   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 905   EFrameworkunifiedStatus l_eStatus = SendMsgToSystemManager(SS_SM_SHUTDOWN_MODULES,
 906                          "SS_SM_SHUTDOWN_MODULES",
 907                          sizeof(Pwr_ServiceSetInterface),
 908                          (PCVOID) pData);
 909   LOG_STATUS_IF_ERRORED(l_eStatus, "SendMsgToSystemManager()");
 910   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 911   return l_eStatus;
 912 }  // End of EFrameworkunifiedStatus SendShutdownToSystemManager(Pwr_ServiceSetInterface *pData)
 913 // LCOV_EXCL_STOP
 914
 915 ///////////////////////////////////////////////////////////
 916 /// Function: RegisterSMSessionAckCallback
 917 ///
 918 ///////////////////////////////////////////////////////////
 919 EFrameworkunifiedStatus RegisterSMSessionAckCallback(EFrameworkunifiedStatus (*CallbackPtr)(HANDLE)) {
 920   CallbackFnPtr = CallbackPtr;
 921   return eFrameworkunifiedStatusOK;
 922 }  // End of EFrameworkunifiedStatus RegisterSMSessionAckCallback(EFrameworkunifiedStatus (*CallbackPtr)(HANDLE))
 923
 924 // LCOV_EXCL_START 6:Because the condition cannot be set
 925 ///////////////////////////////////////////////////////////
 926 /// Function: SendSystemModeRequestToSystemManager
 927 ///
 928 ///////////////////////////////////////////////////////////
 929 EFrameworkunifiedStatus SendSystemModeRequestToSystemManager(void) {
 930   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 931   EFrameworkunifiedStatus l_eStatus = SendMsgToSystemManager(SS_SM_SYSTEM_MODE_INFO_REQ,
 932                          "SS_SM_SYSTEM_MODE_INFO_REQ", 0,
 933                          NULL);
 934   LOG_STATUS_IF_ERRORED(l_eStatus, "SendMsgToSystemManager()");
 935   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 936   return l_eStatus;
 937 }  // End of EFrameworkunifiedStatus SendSystemModeRequestToSystemManager(void)
 938
 939 ///////////////////////////////////////////////////////////
 940 /// Function: SendInitCompReportToSystemManager
 941 ///
 942 ///////////////////////////////////////////////////////////
 943 EFrameworkunifiedStatus SendInitCompReportToSystemManager(void) {
 944   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 945   EFrameworkunifiedStatus l_eStatus = SendMsgToSystemManager(SS_SM_INITCOMP_REP,
 946                          "SS_SM_INITCOMP_REP", 0, NULL);
 947   LOG_STATUS_IF_ERRORED(l_eStatus, "SendMsgToSystemManager()");
 948   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 949   return l_eStatus;
 950 }  // End of EFrameworkunifiedStatus  SendInitCompReportToSystemManager(void)
 951
 952
 953 ///////////////////////////////////////////////////////////
 954 /// Function: AttachCallbackToSystemManager
 955 ///
 956 ///////////////////////////////////////////////////////////
 957 EFrameworkunifiedStatus AttachCallbackToSystemManager(HANDLE hApp, UI_32 iCmd,
 958     CbFuncPtr fpOnCmd) {
 959   return FrameworkunifiedAttachCallbackToDispatcher(
 960            hApp, g_tSystemManagerSession.szServiceName.c_str(), iCmd, fpOnCmd);
 961 }  // End of EFrameworkunifiedStatus AttachCallbackToSystemManager( HANDLE hApp, UI_32 iCmd, CbFuncPtr fpOnCmd )
 962 // LCOV_EXCL_STOP
 963
 964 ///////////////////////////////////////////////////////////
 965 /// Function: SetDataResetModeToSystemManager
 966 ///
 967 ///////////////////////////////////////////////////////////
 968 EFrameworkunifiedStatus SetDataResetModeToSystemManager(ESMDataResetModeInfo dataResetMode) {
 969   EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
 970   EFrameworkunifiedStatus l_resData;
 971
 972   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 973
 974   switch (dataResetMode) {
 975   case e_SS_SM_DATA_RESET_MODE_NONE:
 976   case e_SS_SM_DATA_RESET_MODE_USER:
 977   case e_SS_SM_DATA_RESET_MODE_FACTORY:
 978     break;
 979   default:
 980     FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "dataResetMode %d", dataResetMode);
 981     return eFrameworkunifiedStatusInvldParam;
 982   }
 983
 984   l_eStatus = InvokeSyncRequestToSystemManager(SS_SM_DATA_RESET_MODE_SET_REQ,
 985               "SS_SM_DATA_RESET_MODE_SET_REQ",
 986               sizeof(dataResetMode),
 987               (PVOID) & dataResetMode,
 988               sizeof(l_resData),
 989               (PVOID) & l_resData);  // LCOV_EXCL_BR_LINE 11:Unexpected branch
 990   LOG_STATUS_IF_ERRORED(l_eStatus, "InvokeSyncRequestToSystemManager()");
 991
 992   if (eFrameworkunifiedStatusOK == l_eStatus) {
 993     if (eFrameworkunifiedStatusOK != l_resData) {
 994       l_eStatus = l_resData;
 995       FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " l_eStatus %d", l_eStatus);
 996     }
 997   }
 998
 999   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1000   return l_eStatus;
1001 }  // End of EFrameworkunifiedStatus SetDataResetModeToSystemManager(ESMDataResetModeInfo dataResetMode)
1002
1003 ///////////////////////////////////////////////////////////
1004 /// Function: SetProgUpdateStateToSystemManager
1005 ///
1006 ///////////////////////////////////////////////////////////
1007 EFrameworkunifiedStatus SetProgUpdateStateToSystemManager(
1008   SMProgUpdateState progUpdateState) {
1009   EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
1010   EFrameworkunifiedStatus l_resData;
1011
1012   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1013
1014   if (progUpdateState & SS_SM_PROG_UPDATE_STATE_UPDATED) {
1015   } else if (progUpdateState & SS_SM_PROG_UPDATE_STATE_MAP_UPDATED) {
1016   } else if (progUpdateState & SS_SM_PROG_UPDATE_STATE_MAPDIFF_UPDATED) {
1017   } else {
1018     FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "unknown  %#x", progUpdateState);
1019     return eFrameworkunifiedStatusInvldParam;
1020   }
1021
1022   l_eStatus = InvokeSyncRequestToSystemManager(
1023                 SS_SM_PROG_UPDATE_STATE_SET_REQ, "SS_SM_PROG_UPDATE_STATE_SET_REQ",
1024                 sizeof(progUpdateState), (PVOID) & progUpdateState, sizeof(l_resData),
1025                 (PVOID) & l_resData);  // LCOV_EXCL_BR_LINE 11:Unexpected branch
1026   LOG_STATUS_IF_ERRORED(l_eStatus, "InvokeSyncRequestToSystemManager()");
1027
1028   if ((eFrameworkunifiedStatusOK == l_eStatus) && (eFrameworkunifiedStatusOK != l_resData)) {
1029     l_eStatus = l_resData;
1030     LOG_ERROR("SM RESP");
1031   }
1032
1033   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1034   return l_eStatus;
1035 }  // End of EFrameworkunifiedStatus SetProgUpdateStateToSystemManager(SMProgUpdateState progUpdateState)
1036
1037 ///////////////////////////////////////////////////////////
1038 /// Function: SetNextWakeupTypeToSystemManager
1039 ///
1040 ///////////////////////////////////////////////////////////
1041 EFrameworkunifiedStatus SetNextWakeupTypeToSystemManager(ESMNextWakeupType f_wakeupType) {
1042   EFrameworkunifiedStatus l_eStatus;
1043   EFrameworkunifiedStatus l_resData;
1044   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1045
1046   switch (f_wakeupType) {
1047   case e_SS_SM_NEXT_WAKEUP_TYPE_NONE:
1048   case e_SS_SM_NEXT_WAKEUP_TYPE_COLD:
1049   case e_SS_SM_NEXT_WAKEUP_TYPE_HOT:
1050     break;
1051   default:
1052     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "unknown type(%d)", f_wakeupType);
1053     return eFrameworkunifiedStatusInvldParam;
1054   }
1055
1056   l_eStatus = InvokeSyncRequestToSystemManager(SS_SM_NEXT_WAKEUP_TYPE_SET_REQ,
1057               "SS_SM_NEXT_WAKEUP_TYPE_SET_REQ",
1058               sizeof(f_wakeupType),
1059               (PVOID) & f_wakeupType,
1060               sizeof(l_resData),
1061               (PVOID) & l_resData);  // LCOV_EXCL_BR_LINE 11:Unexpected branch
1062   LOG_STATUS_IF_ERRORED(l_eStatus, "InvokeSyncRequestToSystemManager()");
1063
1064   if (eFrameworkunifiedStatusOK == l_eStatus) {
1065     if (eFrameworkunifiedStatusOK != l_resData) {
1066       l_eStatus = l_resData;
1067       FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " l_eStatus %d", l_eStatus);
1068     }
1069   }
1070
1071   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1072   return l_eStatus;
1073 }
1074
1075 ///////////////////////////////////////////////////////////
1076 /// Function: SendCpuResetRequestToSystemManager
1077 ///
1078 ///////////////////////////////////////////////////////////
1079 EFrameworkunifiedStatus SendCpuResetRequestToSystemManager(
1080   ESMCpuResetReason l_eCpuResetReason, std::string f_messageStr/* = "" */,
1081   std::string f_suffixStr/* = "" */) {
1082   TSystemManagerCpuResetInfo l_resetInfo;  // LCOV_EXCL_BR_LINE 11:Unexpected branch
1083   EFrameworkunifiedStatus l_eStatus;
1084
1085   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1086
1087   l_resetInfo.resetReason = l_eCpuResetReason;
1088   snprintf(l_resetInfo.messageStr, SS_SM_RESET_MSG_STR_SIZE, "%s",
1089            f_messageStr.c_str());  // LCOV_EXCL_BR_LINE 11:Unexpected branch
1090   snprintf(l_resetInfo.suffixStr, SS_SM_SUFFIX_STR_SIZE, "%s",
1091            f_suffixStr.c_str());  // LCOV_EXCL_BR_LINE 11:Unexpected branch
1092
1093   l_eStatus = SendMsgToSystemManager(SS_SM_CPU_RESET_REQ, "SS_SM_CPU_RESET_REQ",
1094                                      sizeof(l_resetInfo),
1095                                      (PVOID) & l_resetInfo);  // LCOV_EXCL_BR_LINE 11:Unexpected branch
1096
1097   LOG_STATUS_IF_ERRORED(l_eStatus, "SendMsgToSystemManager()");
1098   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1099   return l_eStatus;
1100 }  // End of SendCpuResetRequestToSystemManager
1101
1102 ///////////////////////////////////////////////////////////
1103 /// Function: SendStartupConfirmationToSystemManager
1104 ///
1105 ///////////////////////////////////////////////////////////
1106 // LCOV_EXCL_START 6:Because the condition cannot be set
1107 EFrameworkunifiedStatus SendStartupConfirmationToSystemManager(
1108   StartupConfirmationMsgStrut &f_startupConfirmationMsg) {  //NOLINT (runtime/references)
1109   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1110   EFrameworkunifiedStatus l_eStatus;
1111
1112   Pwr_ServiceSetInterface tServiceSetIf;
1113   tServiceSetIf.data.startupConfirmationMsg = f_startupConfirmationMsg;
1114
1115   l_eStatus = SendMsgToSystemManager(SS_SM_FWD_STARTUP_CONFIRMATION_MSG_REQ,
1116                                      "SS_SM_FWD_STARTUP_CONFIRMATION_MSG_REQ",
1117                                      sizeof(Pwr_ServiceSetInterface),
1118                                      (PCVOID) & tServiceSetIf);
1119   LOG_STATUS_IF_ERRORED(l_eStatus, "SendMsgToSystemManager()");
1120   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1121   return l_eStatus;
1122 }  // End of EFrameworkunifiedStatus SendStartupConfirmationToSystemManager(
1123 // LCOV_EXCL_STOP
1124
1125 // LCOV_EXCL_START 6:Because the condition cannot be set
1126 EFrameworkunifiedStatus SendSystemErrorToSystemManager(EFrameworkunifiedSystemError f_systemError) {
1127   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1128   EFrameworkunifiedStatus l_eStatus = SendMsgToSystemManager(SS_SM_PROPAGATE_SYSTEM_ERROR,
1129                          sizeof(f_systemError),
1130                          reinterpret_cast<void*>(&f_systemError));
1131   LOG_STATUS_IF_ERRORED(l_eStatus, "SendMsgToSystemManager()");
1132   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1133   return l_eStatus;
1134 }
1135
1136 EFrameworkunifiedStatus Send_CWORD56_HeartBeatRequestToSystemManager(
1137   EPWR_HB_REQ_MSG_STRUCT f_HbReq) {
1138   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1139   EFrameworkunifiedStatus l_eStatus = SendMsgToSystemManager(SS_SM__CWORD56__HEARTBEAT_REQ,
1140                          sizeof(f_HbReq),
1141                          reinterpret_cast<void*>(&f_HbReq));
1142   LOG_STATUS_IF_ERRORED(l_eStatus, "SendMsgToSystemManager()");
1143   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1144   return l_eStatus;
1145 }
1146 // LCOV_EXCL_STOP
1147
1148 VOID Set_UseStopCompleteNotificationVsInterfaceunifiedOnStopFnc_StateVar(BOOL f_SetTrue) {
1149   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1150   UseStopCompleteNotificationVsInterfaceunifiedOnStopFnc = f_SetTrue;
1151   FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
1152          " UseStopCompleteNotificationVsInterfaceunifiedOnStopFnc set '%s'",
1153          UseStopCompleteNotificationVsInterfaceunifiedOnStopFnc ? "True" : "False");
1154   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1155 }
1156
1157 EFrameworkunifiedStatus SendBootMicroResetNotificationToSystemManager(
1158   eSMBootMicroResetReason f_ResetReason) {
1159   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1160   EFrameworkunifiedStatus l_eStatus;
1161
1162   l_eStatus = SendMsgToSystemManager(SS_SM_BOOT_MICRO_RESET_NTF,
1163                                      "SS_SM_BOOT_MICRO_RESET_NTF",
1164                                      sizeof(f_ResetReason), &f_ResetReason);
1165
1166   LOG_STATUS_IF_ERRORED(l_eStatus,
1167                         "SendMsgToSystemManager(SS_SM_BOOT_MICRO_RESET_NTF)");
1168
1169   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1170   return l_eStatus;
1171 }
1172
1173 EFrameworkunifiedStatus SendUserInvokedLoggingRequestToSystemManager(
1174   eSMUserLogType f_userInvokedLogType, std::string f_messageStr/* = "" */,
1175   std::string f_suffixStr/* = "" */) {
1176   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1177   EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
1178
1179   try {
1180     switch (f_userInvokedLogType) {
1181     case e_SS_SM_CAPTURE_ALL_LOGS:
1182     case e_SS_SM_SCREEN_CAPTURE:
1183     case e_SS_SM_CAPTURE_INTERFACEUNIFIED_LOGS:
1184     case e_SS_SM_CAPTURE_DEV_LOGS:
1185     case e_SS_SM_CAPTURE_MODULE_LOGS:
1186     case e_SS_SM_CAPTURE_DTC_LOGS:
1187     case e_SS_SM_CAPTURE_NAVI_LOGS:
1188     case e_SS_SM_CAPTURE_GROUP_RELAUNCH:
1189       break;
1190     default:
1191       FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: Unknown key ID '%d'",
1192              f_userInvokedLogType);
1193       throw eFrameworkunifiedStatusInvldParam;
1194       break;
1195     }
1196
1197     TSystemManagerLoggingRequestInfo l_logInfo = { };
1198
1199     snprintf(l_logInfo.messageStr, SS_SM_LOG_MSG_STR_SIZE, "%s",
1200              f_messageStr.c_str());  // LCOV_EXCL_BR_LINE 11:Unexpected branch
1201     snprintf(l_logInfo.suffixStr, SS_SM_SUFFIX_STR_SIZE, "%s",
1202              f_suffixStr.c_str());  // LCOV_EXCL_BR_LINE 11:Unexpected branch
1203
1204     l_logInfo.logType = f_userInvokedLogType;
1205     l_eStatus = SendMsgToSystemManager(SS_SM_USER_INVOKED_LOG_REQ,
1206                                        "SS_SM_USER_INVOKED_LOG_REQ",
1207                                        sizeof(l_logInfo), &l_logInfo);  // LCOV_EXCL_BR_LINE 11:Unexpected branch
1208     LOG_STATUS_IF_ERRORED(l_eStatus,
1209                           "SendMsgToSystemManager(SS_SM_USER_INVOKED_LOG_REQ)");
1210   } catch (EFrameworkunifiedStatus e) {
1211     l_eStatus = e;
1212   }
1213   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1214   return (l_eStatus);  // LCOV_EXCL_BR_LINE 11:Unexpected branch
1215 }
1216
1217 // LCOV_EXCL_START 6:Because the condition cannot be set
1218 EFrameworkunifiedStatus SendDiagLoggingRequestToSystemManager(
1219   std::string f_copyDestPathStr) {
1220   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1221   EFrameworkunifiedStatus l_eStatus;
1222
1223   l_eStatus = SendMsgToSystemManager(SS_SM_ERROR_EVENT_DIAG_LOG_REQ,
1224                                      "SS_SM_ERROR_EVENT_DIAG_LOG_REQ",
1225                                      f_copyDestPathStr.length() + 1,
1226                                      f_copyDestPathStr.c_str());
1227   LOG_STATUS_IF_ERRORED(
1228     l_eStatus, "SendMsgToSystemManager(SS_SM_ERROR_EVENT_DIAG_LOG_REQ)");
1229
1230   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1231   return (l_eStatus);
1232 }
1233
1234 EFrameworkunifiedStatus SendCANLoggingRequestToSystemManager(void) {
1235   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1236   EFrameworkunifiedStatus l_eStatus;
1237
1238   l_eStatus = SendMsgToSystemManager(SS_SM_ERROR_EVENT_CAN_LOG_REQ,
1239                                      "SS_SM_ERROR_EVENT_CAN_LOG_REQ", 0, NULL);
1240
1241   LOG_STATUS_IF_ERRORED(
1242     l_eStatus, "SendMsgToSystemManager(SS_SM_ERROR_EVENT_CAN_LOG_REQ)");
1243
1244   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1245   return (l_eStatus);
1246 }
1247
1248 EFrameworkunifiedStatus SendDTCLoggingRequestToSystemManager(UI_32 f_dtc) {
1249   SS_ASERT(0);
1250   return eFrameworkunifiedStatusOK;
1251 }
1252 // LCOV_EXCL_STOP
1253
1254 EFrameworkunifiedStatus RegisterBootMicroLogRequestCb(HANDLE hApp, CbFuncPtr fpOnCmd) {
1255   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1256   EFrameworkunifiedStatus l_eStatus;
1257
1258   if (NULL == hApp) {
1259     l_eStatus = eFrameworkunifiedStatusNullPointer;
1260     LOG_ERROR("(NULL == hApp)");
1261   } else if (NULL == fpOnCmd) {
1262     l_eStatus = eFrameworkunifiedStatusNullPointer;
1263     LOG_ERROR("(NULL == fpOnCmd)");
1264   } else {
1265     l_eStatus = FrameworkunifiedSubscribeToSessionEventWithCallback(
1266                   hApp, SS_SM_BOOT_MICRO_LOG_REQ, fpOnCmd,
1267                   g_tSystemManagerSession.hService);  // LCOV_EXCL_BR_LINE 11:Unexpected branch
1268
1269     LOG_STATUS_IF_ERRORED(
1270       l_eStatus,
1271       "FrameworkunifiedSubscribeToSessionEventWithCallback(SS_SM_BOOT_MICRO_LOG_REQ)");
1272   }
1273
1274   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1275   return (l_eStatus);
1276 }
1277
1278 EFrameworkunifiedStatus SendBootMicroLogResponseToSystemManager(std::string f_logString) {
1279   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1280   EFrameworkunifiedStatus l_eStatus;
1281
1282   l_eStatus = SendMsgToSystemManager(SS_SM_BOOT_MICRO_LOG_RSP,
1283                                      "SS_SM_BOOT_MICRO_LOG_RSP",
1284                                      f_logString.size() + 1,
1285                                      f_logString.c_str());
1286
1287   LOG_STATUS_IF_ERRORED(l_eStatus,
1288                         "SendMsgToSystemManager(SS_SM_BOOT_MICRO_LOG_RSP)");
1289
1290   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1291   return l_eStatus;
1292 }
1293
1294 // LCOV_EXCL_START 6:Because the condition cannot be set
1295 EFrameworkunifiedStatus DetachCallbacksFromInterfaceunifiedDispatcher(
1296   HANDLE hApp, PCSTR pServiceName,
1297   const FrameworkunifiedProtocolCallbackHandler* pMsgHandler, UI_32 uiHandlerCount,
1298   HANDLE hSession) {
1299   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1300   EFrameworkunifiedStatus l_eStatus;
1301   PUI_32 l_puiCmdIdArray;
1302
1303   if (NULL == pServiceName) {
1304     l_eStatus = eFrameworkunifiedStatusInvldParam;
1305     LOG_ERROR("NULL == pServiceName");
1306   } else if (NULL == pMsgHandler) {
1307     l_eStatus = eFrameworkunifiedStatusInvldParam;
1308     LOG_ERROR("NULL == pMsgHandler");
1309   } else if (0 == uiHandlerCount) {
1310     l_eStatus = eFrameworkunifiedStatusInvldParam;
1311     LOG_ERROR("0 == uiHandlerCount");
1312   } else if (NULL == hSession) {
1313     l_eStatus = eFrameworkunifiedStatusInvldParam;
1314     LOG_ERROR("NULL == hSession");
1315   } else if (NULL
1316              == (l_puiCmdIdArray = new (std::nothrow) UI_32[uiHandlerCount])) {
1317     l_eStatus = eFrameworkunifiedStatusNullPointer;
1318     LOG_ERROR("new (std::nothrow)UI_32[ uiHandlerCount ]");
1319   } else {
1320     LoadCbHandlerCmdIDsIntoDetachCbIDsArray(pMsgHandler, l_puiCmdIdArray,
1321                                             uiHandlerCount);
1322
1323     l_eStatus = FrameworkunifiedDetachCallbacksFromDispatcher(hApp, pServiceName,
1324                 l_puiCmdIdArray,
1325                 uiHandlerCount, hSession);
1326     LOG_STATUS(l_eStatus, "FrameworkunifiedDetachCallbacksFromDispatcher()");
1327     delete[] l_puiCmdIdArray;
1328   }
1329   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1330   return l_eStatus;
1331 }  // End of EFrameworkunifiedStatus DetachCallbacksFromInterfaceunifiedDispatcher(HANDLE hApp,
1332
1333 EFrameworkunifiedStatus DetachParentCallbacksFromInterfaceunifiedDispatcher(
1334   HANDLE hApp, const FrameworkunifiedProtocolCallbackHandler* pMsgHandler,
1335   UI_32 uiHandlerCount) {
1336   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1337   EFrameworkunifiedStatus l_eStatus;
1338   PUI_32 l_puiCmdIdArray;
1339
1340   if (NULL == pMsgHandler) {
1341     l_eStatus = eFrameworkunifiedStatusInvldParam;
1342     LOG_ERROR("NULL == pMsgHandler");
1343   } else if (0 == uiHandlerCount) {
1344     l_eStatus = eFrameworkunifiedStatusInvldParam;
1345     LOG_ERROR("0 == uiHandlerCount");
1346   } else if (NULL
1347              == (l_puiCmdIdArray = new (std::nothrow) UI_32[uiHandlerCount])) {
1348     l_eStatus = eFrameworkunifiedStatusNullPointer;
1349     LOG_ERROR("new (std::nothrow)UI_32[ uiHandlerCount ]");
1350   } else {
1351     LoadCbHandlerCmdIDsIntoDetachCbIDsArray(pMsgHandler, l_puiCmdIdArray,
1352                                             uiHandlerCount);
1353
1354     l_eStatus = FrameworkunifiedDetachParentCallbacksFromDispatcher(hApp, l_puiCmdIdArray,
1355                 uiHandlerCount);
1356     LOG_STATUS(l_eStatus, "FrameworkunifiedDetachParentCallbacksFromDispatcher()");
1357     delete[] l_puiCmdIdArray;
1358   }
1359
1360   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1361   return l_eStatus;
1362 }  // End of EFrameworkunifiedStatus DetachParentCallbacksFromInterfaceunifiedDispatcher(HANDLE hApp,
1363
1364 VOID LoadCbHandlerCmdIDsIntoDetachCbIDsArray(
1365   const FrameworkunifiedProtocolCallbackHandler* pMsgHandler, UI_32 * puiCmdIdArray,
1366   UI_32 uiHandlerCount) {
1367   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1368   for (UI_32 i = 0; i < uiHandlerCount; i++) {
1369     puiCmdIdArray[i] = pMsgHandler[i].iCmd;
1370   }
1371   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1372 }  // End of VOID LoadCbHandlerCmdIDsIntoDetachCbIDsArray(const FrameworkunifiedProtocolCallbackHandler* pMsgHandler,
1373
1374 ///////////////////////////////////////////////////////////
1375 /// Function: SendLogStartRequestToSystemManager
1376 ///
1377 ///////////////////////////////////////////////////////////
1378 EFrameworkunifiedStatus SendLogStartRequestToSystemManager(EErrorEventType f_errorEvent) {
1379   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1380   EFrameworkunifiedStatus l_eStatus;
1381
1382   l_eStatus = SendMsgToSystemManager(SS_SM_ERROR_EVENT_LOGGING_START_REQ,
1383                                      "SS_SM_ERROR_EVENT_LOGGING_START_REQ",
1384                                      sizeof(f_errorEvent), &f_errorEvent);
1385
1386   LOG_STATUS_IF_ERRORED(
1387     l_eStatus, "SendMsgToSystemManager(SS_SM_ERROR_EVENT_LOGGING_START_REQ)");
1388
1389   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1390   return (l_eStatus);
1391 }
1392
1393 ///////////////////////////////////////////////////////////
1394 /// Function: SendLogArtifactRequestToSystemManager
1395 ///
1396 ///////////////////////////////////////////////////////////
1397 EFrameworkunifiedStatus SendLogArtifactRequestToSystemManager(EArtifactId f_artifactId) {
1398   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1399   EFrameworkunifiedStatus l_eStatus;
1400
1401   l_eStatus = SendMsgToSystemManager(SS_SM_ERROR_EVENT_ARTIFACT_REQ,
1402                                      "SS_SM_ERROR_EVENT_ARTIFACT_REQ",
1403                                      sizeof(f_artifactId), &f_artifactId);
1404
1405   LOG_STATUS_IF_ERRORED(
1406     l_eStatus, "SendMsgToSystemManager(SS_SM_ERROR_EVENT_ARTIFACT_REQ)");
1407
1408   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1409   return (l_eStatus);
1410 }
1411
1412 ///////////////////////////////////////////////////////////
1413 /// Function: SendLogCompleteRequestToSystemManager
1414 ///
1415 ///////////////////////////////////////////////////////////
1416 EFrameworkunifiedStatus SendLogCompleteRequestToSystemManager(EFrameworkunifiedStatus f_eStatus) {
1417   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1418   EFrameworkunifiedStatus l_eStatus;
1419
1420   if (eFrameworkunifiedStatusOK != f_eStatus) {
1421     l_eStatus = eFrameworkunifiedStatusFail;
1422   } else {
1423     l_eStatus = f_eStatus;
1424   }
1425
1426   l_eStatus = SendMsgToSystemManager(SS_SM_ERROR_EVENT_LOGGING_COMPLETE,
1427                                      "SS_SM_ERROR_EVENT_LOGGING_COMPLETE",
1428                                      sizeof(l_eStatus), &l_eStatus);
1429
1430   LOG_STATUS_IF_ERRORED(
1431     l_eStatus, "SendMsgToSystemManager(SS_SM_ERROR_EVENT_LOGGING_COMPLETE)");
1432
1433   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1434   return (l_eStatus);
1435 }
1436
1437 ///////////////////////////////////////////////////////////
1438 /// Function: SendEelExportRequestToSystemManager
1439 ///
1440 ///////////////////////////////////////////////////////////
1441 EFrameworkunifiedStatus SendEelExportRequestToSystemManager(std::string f_path) {
1442   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1443   EFrameworkunifiedStatus l_eStatus;
1444
1445   l_eStatus = SendMsgToSystemManager(SS_SM_ERROR_EVENT_EEL_EXPORT_REQ,
1446                                      "SS_SM_ERROR_EVENT_EEL_EXPORT_REQ",
1447                                      f_path.length() + 1, f_path.c_str());
1448
1449   LOG_STATUS_IF_ERRORED(
1450     l_eStatus, "SendMsgToSystemManager(SS_SM_ERROR_EVENT_EEL_EXPORT_REQ)");
1451
1452   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1453   return (l_eStatus);
1454 }
1455 // LCOV_EXCL_STOP
1456
1457 ///////////////////////////////////////////////////////////
1458 /// Function: SendInterfaceunifiedEmmcLogsRequestToSystemManager
1459 ///
1460 ///////////////////////////////////////////////////////////
1461 EFrameworkunifiedStatus SendInterfaceunifiedEmmcLogsRequestToSystemManager(std::string f_path) {
1462   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1463   EFrameworkunifiedStatus l_eStatus;
1464
1465   l_eStatus = SendMsgToSystemManager(SS_SM_ERROR_EVENT_INTERFACEUNIFIED_EMMC_LOGS_REQ,
1466                                      "SS_SM_ERROR_EVENT_INTERFACEUNIFIED_EMMC_LOGS_REQ",
1467                                      f_path.length() + 1, f_path.c_str());
1468
1469   LOG_STATUS_IF_ERRORED(
1470     l_eStatus, "SendMsgToSystemManager(SS_SM_ERROR_EVENT_INTERFACEUNIFIED_EMMC_LOGS_REQ)");
1471
1472   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1473   return (l_eStatus);
1474 }
1475
1476 ///////////////////////////////////////////////////////////
1477 /// Function: SendClearLogsRequestToSystemManager
1478 ///
1479 ///////////////////////////////////////////////////////////
1480 EFrameworkunifiedStatus SendClearLogsRequestToSystemManager(
1481   TSystemManagerClearLogsInfo *f_info) {
1482   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1483   EFrameworkunifiedStatus l_eStatus;
1484
1485   if (!f_info) {
1486     l_eStatus = eFrameworkunifiedStatusInvldParam;
1487   } else {
1488     l_eStatus = SendMsgToSystemManager(SS_SM_ERROR_EVENT_CLR_LOGS_REQ,
1489                                        "SS_SM_ERROR_EVENT_CLR_LOGS_REQ", 0,
1490                                        NULL);
1491
1492     LOG_STATUS_IF_ERRORED(
1493       l_eStatus, "SendMsgToSystemManager(SS_SM_ERROR_EVENT_CLR_LOGS_REQ)");
1494   }
1495
1496   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1497   return (l_eStatus);
1498 }
1499
1500 VOID SetModuleState(ModuleStateType f_moduleState, BOOL f_bLog) {
1501   if (f_bLog) {  // LCOV_EXCL_BR_LINE 8:f_bLog is true only
1502     FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " Changing SM_IF state from '%s' to '%s'",
1503            GetStr(g_moduleState).c_str(), GetStr(f_moduleState).c_str());
1504   }
1505   g_moduleState = f_moduleState;
1506 }  // LCOV_EXCL_BR_LINE 10:Because the last line
1507 // End of VOID ModuleLaunchParams::SetModuleState(SMModuleState f_moduleState )
1508
1509 // EOF /SS_SystemIf/src/ss_sm_client.cpp