--- /dev/null
+/*
+ * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup tag_SystemManager
+/// \brief This file provides support for IAT error event logging.
+///
+///////////////////////////////////////////////////////////////////////////////
+#include <stdlib.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <sys/mman.h>
+#include <sys/procfs.h>
+#include <libgen.h>
+#include <spawn.h>
+#include <errno.h>
+#include <sys/timeb.h>
+#include <system_service/ss_system_manager_notifications.h>
+#include <native_service/frameworkunified_framework_if.h>
+#include <native_service/frameworkunified_multithreading.h>
+#include <system_service/ss_services.h>
+#include <system_service/ss_client_names.h>
+#include <system_service/ss_power_service_if.h>
+#include <processlauncher/ProcessLauncher_if.h>
+#include <processlauncher/ss_sm_process_launcher_protocol.h>
+#include <processlauncher/ss_sm_process_launcher.h>
+#include <heartbeat/ss_hb_if.h>
+#include <system_service/ss_heartbeat_service_protocol.h>
+#include <system_service/ss_power_service_notifications.h>
+#include <system_service/ss_power_service_protocol.h>
+#include <stub/ss_diag.h>
+#include <system_service/ss_test_clients.h>
+#include <native_service/ns_np_service_protocol.h>
+#include <native_service/frameworkunified_application.h>
+
+#include <system_service/ss_sm_thread_names.h>
+#include <system_service/ss_templates.h>
+#include <native_service/ns_plogger_if.h>
+#include <native_service/frameworkunified_thread_priority.h>
+#include <native_service/ns_np_service_nor_persistence.h>
+#include <boost/bind.hpp>
+#include <string>
+#include "ss_system_manager.h"
+#include "ss_sm_systemmanagerlog.h"
+#include "ss_sm_default_paths.h"
+#include "ss_sm_version.h"
+
+template<typename C, eFrameworkunifiedStatus (C::*M)(HANDLE)>
+ EFrameworkunifiedStatus SysMgrCallback(HANDLE hApp) { // LCOV_EXCL_START 6: Can not set condition
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail;
+ C * pObj = static_cast<C *>(&CSystemManager::GetInstance());
+ if (pObj) {
+ l_eStatus = (pObj->*M)(hApp);
+ }
+ return l_eStatus;
+}
+// LCOV_EXCL_STOP
+
+//******************************************************************************
+void Init_EErrorEventReset_StrMap(std::map<EErrorEventResetType, SS_String> & m_strMap) { // NOLINT
+ MAP_ENTRY(m_strMap, eErrorEventResetTypeNone); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ MAP_ENTRY(m_strMap, eErrorEventResetTypeHard); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+}
+class EnumStringMap<EErrorEventResetType, Init_EErrorEventReset_StrMap> m_oEErrorEventResetTypeMap;
+SS_String GetStr(EErrorEventResetType f_enum) { // LCOV_EXCL_START 6: Can not set condition
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ return m_oEErrorEventResetTypeMap.GetStr(f_enum);
+}
+// LCOV_EXCL_STOP
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup ErrorEventInit
+/// This function initializes the error event handling subsystem.
+/// This function MUST be called by System Manager initialization.
+///
+/// \param HANDLE f_hApp AGL FW application handle.
+///
+/// \return Status
+/// EFrameworkunifiedStatus - success or error
+///////////////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::ErrorEventInit(HANDLE f_hApp) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ Timer *l_pTimer;
+
+ m_isPrevErrEventCompleted = TRUE;
+ m_errorEventResult = eFrameworkunifiedStatusOK;
+ m_errorEventQueueLocked = FALSE;
+ m_errorEventCurrentIter = m_errorEventQueue.end();
+
+ l_pTimer = &m_errorEventTimers[eSM_ERROR_EVENT_TIMER_LOGGER_START_REQ];
+ l_pTimer->Initialize(f_hApp, SS_SM_ERROR_EVENT_TIMER_ID_LOGGER_START_REQ,
+ boost::bind(&CSystemManager::OnErrorEventLoggerStartRequestTimeout, this, _1)); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+
+ l_pTimer = &m_errorEventTimers[eSM_ERROR_EVENT_TIMER_DEBUG_DUMP_RSPN];
+ l_pTimer->Initialize(f_hApp, SS_SM_ERROR_EVENT_TIMER_ID_DEBUG_DUMP_RSPN,
+ boost::bind(&CSystemManager::OnDebugDumpCompleteTimeout, this, _1)); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+
+ l_pTimer = &m_errorEventTimers[eSM_ERROR_EVENT_TIMER_BOOT_MICRO_LOG_RSPN];
+ l_pTimer->Initialize(f_hApp, SS_SM_ERROR_EVENT_TIMER_ID_BOOT_MICRO_LOG_RSPN,
+ boost::bind(&CSystemManager::OnErrorEventBootMicroLogResponseTimeout, this, _1)); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+
+ l_pTimer = &m_errorEventTimers[eSM_ERROR_EVENT_TIMER_CORE_FILE_POLL];
+ l_pTimer->Initialize(f_hApp, SS_SM_ERROR_EVENT_TIMER_ID_CORE_FILE_POLL,
+ boost::bind(&CSystemManager::OnErrorEventCoreFilePollTimeout, this, _1)); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return (l_eStatus);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup ErrorEventEnqueue
+/// Conditional queue error events for processing by the error event state
+/// machine.
+///
+/// \param f_hApp Handle to AGL application.
+///
+/// \param f_eventType Error event type.
+///
+/// \param f_moduleQueueName Error event trigger module queue name.
+///
+/// \param f_resetType Error event reset type (none, hard).
+///
+/// \param f_loggingInfo Logging information if applicable (optional).
+///
+/// \return EFrameworkunifiedStatus
+/// Success ==> eFrameworkunifiedStatusOK
+/// Failure ==> Other values
+///////////////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::ErrorEventEnqueue(HANDLE f_hApp,
+ EErrorEventType f_eventType, std::string &f_moduleQueueName,
+ EErrorEventResetType f_resetType, const SMLoggingInfo &f_loggingInfo) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ ERROR_EVENT_INFO l_errorEventInfo;
+ ERROR_EVENT_QUEUE_ITER l_errorEventIter;
+ ERROR_EVENT_QUEUE_RET l_retVal;
+ BOOL isErrorReset = FALSE;
+
+ if (eErrorEventResetTypeHard == f_resetType) {
+ // Forced reset if shutdown process is not completed after Reboot requesting
+ m_GroupLaunchTimer->StartTimer(
+ m_aTimerIDs[eSM_TIMER_SHUTDOWN_COMPLETE_MONITOR],
+ SM_SHUTDOWN_COMPLETE_MONITOR_TIMEOUT, 0, 0, 0);
+
+ switch (f_loggingInfo.resetReason) {
+ case e_SS_SM_CPU_RESET_REASON_GENERIC_ERR:
+ case e_SS_SM_CPU_RESET_REASON_DSP_ERR:
+ isErrorReset = TRUE;
+ break;
+ default:
+ break;
+ }
+ // LCOV_EXCL_START 6:This variable cannot be modified by external API
+ if ((m_ResetCount > SS_SM_ERR_NAVI_RESET_LIMIT) && isErrorReset) {
+ // LCOV_EXCL_BR_STOP
+ // LCOV_EXCL_START 6:This variable cannot be modified by external API (evaluated only initial value)
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ fprintf(stderr,
+ "SS_SysManager/%s:will NAVIDET as continuous error(%d) \n", __FUNCTION__, m_ResetCount);
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "will NAVIDET as continuous error(%d)", m_ResetCount);
+ m_pfStopCompleteHandler = (SysMgrCallback<CSystemManager, &CSystemManager::perform_force_reset>);
+ // LCOV_EXCL_STOP
+ }
+ }
+
+ if (TRUE == m_errorEventQueueLocked) {
+ l_eStatus = eFrameworkunifiedStatusAccessError;
+ FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__,
+ " Warning. The Error Event Queue has been locked. No further items may be enqueued. System reset pending."); // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length)
+ } else {
+ GetTimeStamp(l_errorEventInfo.m_eventEnqueueTimeStamp);
+
+ l_errorEventInfo.m_moduleQueueName = f_moduleQueueName;
+ l_errorEventInfo.m_eventType = f_eventType;
+ l_errorEventInfo.m_errorEventResetType = f_resetType;
+ l_errorEventInfo.m_loggingInfo = f_loggingInfo;
+ l_errorEventInfo.m_prio = eErrorEventPrioDefault; // Make Prios of all ErrorEvent first-win as default
+ // It needs to add eErrorEventPrioxxx properly if design modification about priority required
+
+ if (eErrorEventResetTypeNone != f_resetType) {
+ FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, " System will reset after logging");
+ }
+
+ l_retVal = m_errorEventQueue.insert(l_errorEventInfo);
+ if (FALSE == l_retVal.second) {
+ std::string l_errorEventName = GetStr(l_errorEventInfo.m_eventType);
+ TEXT(__FUNCTION__, // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length)
+ " ERROR EVENT: %s is already queued or is in progress. Event dropped.", // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length)
+ l_errorEventName.c_str()); // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length)
+ }
+
+ l_eStatus = ErrorEventProcessNext(f_hApp);
+ LOG_ERROR_REC_HIST_IF_ERRORED(l_eStatus, "ErrorEventProcessNext()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length)
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return (l_eStatus);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup PerformResetAfterLogging
+/// perform CPU reset after logging complete
+///
+/// \param f_hApp Handle to AGL application.
+/// f_eCpuResetReason CPU reset reason
+/// f_messageStr Error message string
+///
+/// \return EFrameworkunifiedStatus
+/// Success ==> eFrameworkunifiedStatusOK
+/// Failure ==> Other values
+///
+///
+///////////////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::PerformResetAfterLogging(HANDLE f_hApp,
+ ESMCpuResetReason f_eCpuResetReason, std::string f_messageStr) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+
+ l_eStatus = PerformCpuReset(f_hApp, f_eCpuResetReason, f_messageStr);
+ LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, "PerformCpuReset()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length)
+ // LCOV_EXCL_BR_START 200: Can not satisfy the condition for calling from caller
+ if (eFrameworkunifiedStatusOK != l_eStatus) {
+ // LCOV_EXCL_BR_STOP
+ // LCOV_EXCL_START 200: Can not satisfy the condition for calling from caller
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ SS_ASERT_LOG(0, "PerformCpuReset() : %d", l_eStatus);
+ // Erasing ErrorEvent only if resetting process is failed
+ m_errorEventQueue.erase(m_errorEventCurrentIter); // Erase last processed event.
+ // LCOV_EXCL_STOP
+ } else {
+ m_errorEventQueueLocked = TRUE; // Permanent lock until post reset.
+ m_errorEventQueue.clear(); // Drop queued events.
+ SendDeferMsg(f_hApp);
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return (l_eStatus);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup ErrorEventProcessNext
+/// Process the next error event from error event queue.
+///
+/// \param f_hApp Handle to AGL application.
+///
+/// \return EFrameworkunifiedStatus
+/// Success ==> eFrameworkunifiedStatusOK
+/// Failure ==> Other values
+///
+/// \Notes (1) Removal from the queue occurs AFTER the entry has been processed
+/// AND just before the NEXT entry is to be obtained. Therefore,
+/// the first item enqueued MUST not be removed since it has not
+/// been processed. This is ensured by setting the iterator to END
+/// during module initialization. After processing the first event,
+/// the iterator will no longer be END until all events have been
+/// processed.
+///////////////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::ErrorEventProcessNext(HANDLE f_hApp) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ ERROR_EVENT_QUEUE_ITER l_errorEventIter;
+ SMErrorEventNtfData l_errorEventNtfData;
+
+ if (TRUE == m_isPrevErrEventCompleted) { // Remove last completed item from front of queue.
+ // See Note #1.
+ if ((0 != m_errorEventQueue.size()) &&
+ (m_errorEventQueue.end() != m_errorEventCurrentIter)) {
+ // Completed logging by ErrorEvent
+ switch (m_errorEventCurrentIter->m_errorEventResetType) {
+ case eErrorEventResetTypeNone:
+ switch (m_errorEventCurrentIter->m_eventType) {
+ case eErrorEventTypeInterfaceunifiedEmmcLogs:
+ case eErrorEventTypeUserInvokedClearLogs:
+ if (eFrameworkunifiedStatusOK == m_errorEventResult) {
+ if (PowerHalSetResetInfo(AGL_ERRLOG_COUNTER, 0)) {
+ // Logging only.
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "Could not reset AGL_ERRLOG_COUNTER");
+ }
+ }
+ break;
+ default:
+ break;
+ }
+
+ if (eErrorEventTypeInterfaceunifiedEmmcLogs == m_errorEventCurrentIter->m_eventType) {
+ HANDLE hSession = FrameworkunifiedMcOpenSender(f_hApp,
+ m_errorEventCurrentIter->m_moduleQueueName.c_str());
+
+ if (hSession == NULL) { // LCOV_EXCL_BR_LINE 4: NSFW error case
+ // LCOV_EXCL_START 4: NSFW error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ SS_ASERT(0); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ // LCOV_EXCL_STOP
+ } else {
+ if (eFrameworkunifiedStatusOK // LCOV_EXCL_BR_LINE 4: NSFW error case
+ != FrameworkunifiedSendMsg(hSession,
+ SS_SM_ERROR_EVENT_INTERFACEUNIFIED_EMMC_LOGS_RSPN,
+ sizeof(m_errorEventResult),
+ &m_errorEventResult)) {
+ // LCOV_EXCL_START 4: NSFW error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ SS_ASERT(0); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ // LCOV_EXCL_STOP
+ }
+ if (eFrameworkunifiedStatusOK != FrameworkunifiedMcClose(hSession)) { // LCOV_EXCL_BR_LINE 4: NSFW error case
+ // LCOV_EXCL_START 4: NSFW error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ SS_ASERT(0); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ // LCOV_EXCL_STOP
+ }
+ }
+ }
+ m_errorEventQueue.erase(m_errorEventCurrentIter); // Erase last processed event.
+ break;
+ case eErrorEventResetTypeHard:
+ TEXT(__FUNCTION__, "ERROR EVENT: Hard reset required for previously processed error event." // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length)
+ "Initiating reset and flushing logging queue."); // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length)
+
+ if (eFrameworkunifiedStatusOK != m_errorEventResult) {
+ // Logging at next launching by setting L to NaviDet if logging failed before rebooting
+ fprintf(stderr,
+ "SS_SysManager/%s:will NAVIDET as LOG save failed\n", __FUNCTION__);
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "will NAVIDET as LOG save failed");
+ m_pfStopCompleteHandler = (SysMgrCallback<CSystemManager,
+ &CSystemManager::perform_force_reset>);
+ }
+
+ if ((m_errorEventCurrentIter->m_loggingInfo.resetReason == e_SS_SM_CPU_RESET_REASON_CRITICAL_ERR) ||
+ (m_errorEventCurrentIter->m_loggingInfo.resetReason == e_SS_SM_CPU_RESET_REASON_GENERIC_ERR) ||
+ (m_errorEventCurrentIter->m_loggingInfo.resetReason == e_SS_SM_CPU_RESET_REASON_DSP_ERR) ||
+ (m_errorEventCurrentIter->m_loggingInfo.resetReason == e_SS_SM_CPU_RESET_REASON_USER_FORCE_RESET)) {
+ BOOL l_user_reset = FALSE;
+ if (m_errorEventCurrentIter->m_loggingInfo.resetReason == e_SS_SM_CPU_RESET_REASON_USER_FORCE_RESET) {
+ l_user_reset = TRUE;
+ }
+ m_ResetFactor = GetResetFactor(m_errorEventCurrentIter->m_moduleQueueName.c_str(), l_user_reset);
+ }
+
+ l_eStatus = PerformResetAfterLogging(f_hApp,
+ m_errorEventCurrentIter->m_loggingInfo.resetReason,
+ m_errorEventCurrentIter->m_loggingInfo.messageStr); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length)
+ "PerformResetAfterLogging()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length)
+
+ break;
+ // LCOV_EXCL_START 6:Can not satisfy condition to branch
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ default:
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error. Unknown reset type encountered: 0x%X/%d. No action taken.",
+ m_errorEventCurrentIter->m_errorEventResetType,
+ m_errorEventCurrentIter->m_errorEventResetType);
+ break;
+ // LCOV_EXCL_STOP
+ }
+ }
+
+ // Check if a new work item exists.
+ if (0 != m_errorEventQueue.size()) {
+ // ErrorEvent startup process
+ m_errorEventCurrentIter = m_errorEventQueue.begin();
+
+ l_errorEventNtfData.EventType = m_errorEventCurrentIter->m_eventType;
+
+ if (eErrorEventResetTypeHard == m_errorEventCurrentIter->m_errorEventResetType) {
+ l_errorEventNtfData.isNeedReboot = TRUE;
+ } else {
+ l_errorEventNtfData.isNeedReboot = FALSE;
+ }
+
+ // Check BufferSize
+ size_t modl_len = sizeof(l_errorEventNtfData.ModuleName) - 1;
+
+ // SS Logger uses the l_errorEventNtfData.ModuleName as the LOGGERSERVICE_EMMC_LOGS and
+ // EEL_EXPORT destination path. eErrorEventTypeDiagEvent sends the destination path.
+ // For all other event types, the binary name is sent to logger.
+ // LCOV_EXCL_BR_START 6: Because the applicable variable cannot be changed from the external API (only evaluated by the initial value)
+ if ((eErrorEventTypeInterfaceunifiedEmmcLogs
+ == m_errorEventCurrentIter->m_eventType) ||
+ (eErrorEventTypeEelExport
+ == m_errorEventCurrentIter->m_eventType) ||
+ (eErrorEventTypeDiagEvent
+ == m_errorEventCurrentIter->m_eventType)) {
+ // LCOV_EXCL_BR_STOP
+ strncpy(l_errorEventNtfData.ModuleName,
+ m_errorEventCurrentIter->m_loggingInfo.path.c_str(),
+ sizeof(l_errorEventNtfData.ModuleName) - 1);
+
+ size_t path_len = strlen(m_errorEventCurrentIter->m_loggingInfo.path.c_str());
+ if (path_len > modl_len) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "Input buffer size over. input : %ld, enable : %ld",
+ path_len, modl_len);
+ }
+ l_errorEventNtfData.ModuleName[sizeof(l_errorEventNtfData.ModuleName) - 1] = 0;
+ } else {
+ strncpy(l_errorEventNtfData.ModuleName,
+ m_errorEventCurrentIter->m_loggingInfo.suffixStr.c_str(),
+ sizeof(l_errorEventNtfData.ModuleName) - 1);
+ }
+
+ // When the Reboot process is started during the execution of the LOG save sequence, an undefined value was set
+ // in m_errorEventCurrentIter. Therefore, the Reboot start timing due to an error in SS_Loger was changed from
+ // the time of ErrorEvent queuing to the time of dequeuing.
+
+ // LCOV_EXCL_BR_START 6: Because the following conditions cannot be satisfied when called from an external API
+ if ((SERVICE_LOGGER == m_errorEventCurrentIter->m_moduleQueueName)
+ && ((eErrorEventTypeProcessCrash
+ == m_errorEventCurrentIter->m_eventType)
+ || (eErrorEventTypeProcessExit
+ == m_errorEventCurrentIter->m_eventType)
+ || (eErrorEventTypeHeartBeatFailure
+ == m_errorEventCurrentIter->m_eventType)
+ || (eErrorEventTypeModConnFailed
+ == m_errorEventCurrentIter->m_eventType)
+ || (eErrorEventTypeStartRespFailed
+ == m_errorEventCurrentIter->m_eventType))) {
+ // LCOV_EXCL_BR_STOP
+ // LCOV_EXCL_START 6: Because the following conditions cannot be satisfied when called from an external API
+ // Note: If logger crashes, a core file will exist.
+ std::string l_hmiDispStr;
+ l_hmiDispStr = SERVICE_LOGGER;
+ if (eErrorEventResetTypeNone != m_errorEventCurrentIter->m_errorEventResetType) {
+ l_hmiDispStr += " - Shutting down, check for core file.";
+
+ // Since LOG save cannot be performed when an SSL error is detected, the LOG is saved at the next startup
+ // by rebooting with NaviDet = L after completion of the process.
+ fprintf(stderr, "SS_SysManager/%s:will NAVIDET as SSL dead\n", __FUNCTION__);
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "will NAVIDET as SSL dead");
+ m_pfStopCompleteHandler = (SysMgrCallback<CSystemManager,
+ &CSystemManager::perform_force_reset>);
+
+ m_ResetFactor = GetResetFactor(SERVICE_LOGGER, FALSE);
+
+ l_eStatus = PerformResetAfterLogging(f_hApp,
+ e_SS_SM_CPU_RESET_REASON_GENERIC_ERR);
+ LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, "PerformResetAfterLogging()");
+ } else {
+ l_hmiDispStr += " - Check for core file.";
+ }
+
+ SMErrorEventNtfData l_errorEventNtfData;
+ l_errorEventNtfData.EventType = m_errorEventCurrentIter->m_eventType;
+ l_errorEventNtfData.isNeedReboot = FALSE;
+ snprintf(l_errorEventNtfData.ModuleName,
+ sizeof(l_errorEventNtfData.ModuleName), "%s",
+ l_hmiDispStr.c_str());
+
+ l_eStatus = FrameworkunifiedPublishEvent(f_hApp, // Show indication on HMI.
+ SS_SM_EVENT_ERROR,
+ NULL, &l_errorEventNtfData, sizeof(l_errorEventNtfData));
+
+ LOG_ERROR_REC_HIST_IF_ERRORED(l_eStatus,
+ "FrameworkunifiedPublishEvent(SS_SM_EVENT_ERROR)");
+ } else if (m_errorEventCurrentIter->m_eventType == eErrorEventTypeModuleInvokedResetRequest
+ && (m_errorEventCurrentIter->m_loggingInfo.resetReason == e_SS_SM_CPU_RESET_REASON_NORMAL
+ || m_errorEventCurrentIter->m_loggingInfo.resetReason == e_SS_SM_CPU_RESET_REASON_DATA_RESET)) {
+ l_eStatus = PerformResetAfterLogging(f_hApp,
+ m_errorEventCurrentIter->m_loggingInfo.resetReason,
+ m_errorEventCurrentIter->m_loggingInfo.messageStr); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, "PerformResetAfterLogging()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length)
+ } else {
+ BOOL bIsNeedLogging = TRUE;
+
+ {
+ UI_32 l_ErrLogCount = 0;
+ if (PowerHalGetResetInfo(AGL_ERRLOG_COUNTER, &l_ErrLogCount)) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "Could not get AGL_ERRLOG_COUNTER form power_hal, assume to 0.");
+ l_ErrLogCount = 0;
+ }
+
+ {
+ if ((l_ErrLogCount >= SS_SM_ERR_LOGGING_LIMIT)
+ && (eErrorEventResetTypeHard == m_errorEventCurrentIter->m_errorEventResetType)) {
+ fprintf(stderr, "SS_SysManager/%s:Skip Logging by continuous error \n", __FUNCTION__);
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Skip Logging by continuous error ");
+
+ m_ResetFactor = PSM_FACTOR_AGL_WITH_HISTORY;
+
+ l_eStatus =
+ PerformResetAfterLogging(f_hApp,
+ m_errorEventCurrentIter->m_loggingInfo.resetReason,
+ m_errorEventCurrentIter->m_loggingInfo.messageStr);
+ LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, "PerformResetAfterLogging()");
+ bIsNeedLogging = FALSE;
+ } else if (eErrorEventResetTypeHard
+ == m_errorEventCurrentIter->m_errorEventResetType) {
+ l_ErrLogCount++;
+ if (PowerHalSetResetInfo(AGL_ERRLOG_COUNTER, l_ErrLogCount)) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "Could not set AGL_ERRLOG_COUNTER to power_hal.");
+ }
+ }
+ }
+ }
+
+ if (bIsNeedLogging) {
+ m_isPrevErrEventCompleted = FALSE;
+ m_errorEventResult = eFrameworkunifiedStatusOK;
+ BOOL result =
+ m_errorEventTimers[eSM_ERROR_EVENT_TIMER_LOGGER_START_REQ].Start(
+ SS_ERROR_EVENT_START_REQ_TO_SEC, 0, 0, 0);
+ if (FALSE == result) { // LCOV_EXCL_BR_LINE 6: Because the applicable variable cannot be changed from the external API (only evaluated by the initial value)
+ // LCOV_EXCL_START 6: Because the applicable variable cannot be changed from the external API (only evaluated by the initial value)
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error. Failed to start timer eSM_ERROR_EVENT_TIMER_LOGGER_START_REQ.");
+ // LCOV_EXCL_STOP
+ }
+
+ l_eStatus = FrameworkunifiedPublishEvent(f_hApp,
+ SS_SM_EVENT_ERROR_TO_SSL,
+ NULL, &l_errorEventNtfData,
+ sizeof(l_errorEventNtfData));
+
+ if (l_eStatus != eFrameworkunifiedStatusOK) { // LCOV_EXCL_BR_LINE 4: NSFW error case.
+ // LCOV_EXCL_START 4: NSFW error case.
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
+ " FrameworkunifiedPublishEvent(SS_SM_EVENT_ERROR_TO_SSL, "
+ "module name (optional): '%s', "
+ "event type: %d) returned '%d'/'%s'",
+ l_errorEventNtfData.ModuleName,
+ l_errorEventNtfData.EventType, l_eStatus,
+ GetStr(l_eStatus).c_str());
+ // LCOV_EXCL_STOP 4: NSFW error case.
+ }
+ }
+ }
+ }
+
+ // If Reboot has been started up to this point, m_errorEventQueue is cleared and checking is performed at the end because m_errorEventQueue is cleared.
+ if (0 == m_errorEventQueue.size()) {
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
+ " Info. Error Event queue empty. Error logging complete.");
+ m_errorEventCurrentIter = m_errorEventQueue.end(); // Invalidate iterator in case of spurious events.
+ SendDeferMsg(f_hApp);
+ }
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return (l_eStatus);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup OnLoggingStartRequestFromSL
+/// This function gets called when System Logger initiates artifact
+/// collection for a trigger source that originates within System
+/// Logger or as a result of System Manager raising a logging
+/// event notification to System Logger.
+///
+/// \param [in] hApp
+/// HANDLE - Handle of the Client Application
+///
+/// \return Status
+/// EFrameworkunifiedStatus - success or error
+///////////////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::OnLoggingStartRequest(HANDLE f_hApp) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ ModuleLaunchListIter l_ModuleListIter;
+ HANDLE l_hLoggerServiceSession;
+ EErrorEventType l_eventType;
+ SMErrorEventNtfData l_errorEventNtfData;
+
+ m_errorEventTimers[eSM_ERROR_EVENT_TIMER_LOGGER_START_REQ].Stop();
+
+ INTERFACEUNIFIEDLOG_RECEIVED_FROM(f_hApp);
+
+ if (eFrameworkunifiedStatusOK
+ != (l_eStatus = ReadMsg < EErrorEventType > (f_hApp, l_eventType))) {
+ LOG_ERROR("ReadMsg()");
+ } else {
+ if (0 == m_errorEventQueue.size()) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error. Logging start request received for event type: %d/'%s', "
+ "but the logging queue is empty.!", l_eventType,
+ GetStr(l_eventType).c_str());
+ l_eStatus = eFrameworkunifiedStatusFail;
+ } else if (m_errorEventCurrentIter == m_errorEventQueue.end()) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error. Logging start request received for event type: %d/'%s', "
+ "but the current event iterator is invalid.",
+ l_eventType, GetStr(l_eventType).c_str());
+ l_eStatus = eFrameworkunifiedStatusFail;
+ } else if (m_errorEventCurrentIter->m_eventType != l_eventType) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error. Logging start request received for event type: %d/'%s', "
+ "but current work item is for event type: %d/'%s'.",
+ l_eventType, GetStr(l_eventType).c_str(),
+ m_errorEventCurrentIter->m_eventType,
+ GetStr(m_errorEventCurrentIter->m_eventType).c_str());
+ l_eStatus = eFrameworkunifiedStatusFail;
+ } else {
+ l_errorEventNtfData.EventType = l_eventType;
+ l_errorEventNtfData.isNeedReboot = FALSE;
+
+ // For boot micro reset, customize the string as per the reset reason.
+ if (l_eventType == eErrorEventTypeBootMicroReset) {
+ switch (m_BootMicroResetReason) {
+ case SS_SM_BOOT_MICRO_RESET_REASON_SELF_RESET:
+ (void) snprintf(l_errorEventNtfData.ModuleName,
+ sizeof(l_errorEventNtfData.ModuleName),
+ "Boot Micro Reset. Reason: %d, Self Reset",
+ m_BootMicroResetReason);
+ break;
+
+ case SS_SM_BOOT_MICRO_RESET_REASON_USER_FORCE_RESET: // User Force Reset timeout.
+ (void) snprintf(l_errorEventNtfData.ModuleName,
+ sizeof(l_errorEventNtfData.ModuleName),
+ "Boot Micro Reset. Reason: %d, UFR Timeout",
+ m_BootMicroResetReason);
+ break;
+
+ case SS_SM_BOOT_MICRO_RESET_REASON_DSP_RESET:
+ (void) snprintf(l_errorEventNtfData.ModuleName,
+ sizeof(l_errorEventNtfData.ModuleName),
+ "Boot Micro Reset. Reason: %d, DSP Reset",
+ m_BootMicroResetReason);
+ break;
+
+ case SS_SM_BOOT_MICRO_RESET_REASON_HB_TIMEOUT:
+ (void) snprintf(l_errorEventNtfData.ModuleName,
+ sizeof(l_errorEventNtfData.ModuleName),
+ "Boot Micro Reset. Reason: %d, HB Timeout",
+ m_BootMicroResetReason);
+ break;
+
+ default:
+ (void) snprintf(l_errorEventNtfData.ModuleName,
+ sizeof(l_errorEventNtfData.ModuleName),
+ "Boot Micro Reset. Reason: %d, Unknown",
+ m_BootMicroResetReason);
+ break;
+ }
+ } else {
+ // All other error event types format =
+ // Binary Name <circumstantial> PID: TID: Additional info: </circumstantial>
+ std::string l_hmiDispStr = ErrorEventCreateHmiDisplayString();
+
+ (void) snprintf(l_errorEventNtfData.ModuleName,
+ sizeof(l_errorEventNtfData.ModuleName), "%s",
+ l_hmiDispStr.c_str());
+ }
+
+ l_eStatus = FrameworkunifiedPublishEvent(f_hApp, SS_SM_EVENT_ERROR, // To HMI
+ NULL, &l_errorEventNtfData, sizeof(l_errorEventNtfData));
+
+ LOG_ERROR_REC_HIST_IF_ERRORED(l_eStatus,
+ "FrameworkunifiedPublishEvent(SS_SM_EVENT_ERROR)");
+ }
+
+ if (eFrameworkunifiedStatusOK
+ != (l_eStatus = GetModuleIterator(SERVICE_LOGGER, l_ModuleListIter))) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error: GetModuleIterator(%s) errored: %d/'%s'",
+ SERVICE_LOGGER, l_eStatus, GetStr(l_eStatus).c_str());
+ } else {
+ l_hLoggerServiceSession = l_ModuleListIter->hsession;
+
+ l_eStatus = FrameworkunifiedSendMsg(l_hLoggerServiceSession,
+ SS_SM_ERROR_EVENT_LOGGING_START_RSPN, 0, NULL);
+
+ LOG_ERROR_REC_HIST_IF_ERRORED(l_eStatus,
+ "FrameworkunifiedSendMsg(SS_SM_ERROR_EVENT_LOGGING_START_RSPN)");
+ }
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return (l_eStatus);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup OnErrorEventLoggerStartRequestTimeout
+///
+/// \brief This function is called if System Logger fails to respond in a
+/// timely fashion to the published logger start request event
+/// SS_SM_EVENT_ERROR_TO_SSL. See OnLoggingStartRequest() which
+/// is the expected path should the timer period NOT expire.
+///
+/// \param [in] hApp
+/// HANDLE - Handle of the Client Application
+///
+/// \return Status
+/// EFrameworkunifiedStatus - success or error
+///////////////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CSystemManager::OnErrorEventLoggerStartRequestTimeout(HANDLE f_hApp) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ SMErrorEventNtfData l_errorEventNtfData;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error. Logger failed to respond to message SS_SM_EVENT_ERROR_TO_SSL in a timely fashion. Logging aborted.");
+
+ // Publish to HMI even if the error event will not be processed.
+ // In this way, developers can be made aware of the error condition
+ // and determine why logging did not proceed as expected.
+ if (m_errorEventCurrentIter != m_errorEventQueue.end()) {
+ l_errorEventNtfData.EventType = m_errorEventCurrentIter->m_eventType;
+ l_errorEventNtfData.isNeedReboot = FALSE;
+
+ std::string l_hmiDispStr = ErrorEventCreateHmiDisplayString();
+ snprintf(l_errorEventNtfData.ModuleName,
+ sizeof(l_errorEventNtfData.ModuleName), "%s.", l_hmiDispStr.c_str());
+
+ l_eStatus = FrameworkunifiedPublishEvent(f_hApp, SS_SM_EVENT_ERROR, // To HMI
+ NULL, &l_errorEventNtfData, sizeof(l_errorEventNtfData)); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+
+ LOG_ERROR_REC_HIST_IF_ERRORED(l_eStatus, "FrameworkunifiedPublishEvent(SS_SM_EVENT_ERROR)"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length)
+ }
+
+ m_isPrevErrEventCompleted = TRUE;
+ m_errorEventResult = eFrameworkunifiedStatusFail;
+ l_eStatus = ErrorEventProcessNext(f_hApp);
+ LOG_ERROR_REC_HIST_IF_ERRORED(l_eStatus, "ErrorEventProcessNext()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length)
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return (l_eStatus);
+}
+
+EFrameworkunifiedStatus CSystemManager::OnErrorEventLoggingComplete(HANDLE f_hApp) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ HANDLE l_hLoggerServiceSession;
+ ModuleLaunchListIter l_ModuleListIter;
+
+ // If logger does not send a logging start and instead immediately
+ // sends a logging complete response, then the start timer must be
+ // stopped to prevent a start response timeout from occuring.
+ m_errorEventTimers[eSM_ERROR_EVENT_TIMER_LOGGER_START_REQ].Stop();
+
+ m_errorEventResult = eFrameworkunifiedStatusFail;
+ if (sizeof(m_errorEventResult) != FrameworkunifiedGetMsgLength(f_hApp)) {
+ LOG_ERROR("DataSize mismatch");
+ } else if (eFrameworkunifiedStatusOK
+ != (l_eStatus = FrameworkunifiedGetMsgDataOfSize(f_hApp, &m_errorEventResult,
+ sizeof(m_errorEventResult), eSMRRelease))) {
+ LOG_ERROR("FrameworkunifiedGetMsgDataOfSize()");
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "m_errorEventResult = %d", m_errorEventResult);
+ }
+ m_isPrevErrEventCompleted = TRUE;
+
+ if (eFrameworkunifiedStatusOK
+ != (l_eStatus = GetModuleIterator(SERVICE_LOGGER, l_ModuleListIter))) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error: GetModuleIterator(%s) errored: %d/'%s'",
+ SERVICE_LOGGER, l_eStatus, GetStr(l_eStatus).c_str());
+ } else {
+ l_hLoggerServiceSession = l_ModuleListIter->hsession;
+
+ l_eStatus = FrameworkunifiedSendMsg(l_hLoggerServiceSession,
+ SS_SM_ERROR_EVENT_LOGGING_COMPLETE_RSPN, 0, NULL);
+
+ LOG_ERROR_REC_HIST_IF_ERRORED(l_eStatus,
+ "FrameworkunifiedSendMsg(SS_SM_ERROR_EVENT_LOGGING_START_RSPN)");
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, " Info. Done processing error event %s.",
+ GetStr(m_errorEventCurrentIter->m_eventType).c_str());
+
+ l_eStatus = ErrorEventProcessNext(f_hApp);
+ LOG_ERROR_REC_HIST_IF_ERRORED(l_eStatus, "ErrorEventProcessNext()");
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return (l_eStatus);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup ActOnModuleFailure
+/// This function is called to take appropriate action of the failure
+/// reported by heart beat or crash detector. Attributes set in
+/// Launch configuration file are considered while taking action
+/// on the failed module.
+///
+/// \param f_hApp AGL FW application handle.
+/// f_moduleName Failed module name.
+/// f_refSoftResetRequired Return parameter indicating if a
+/// soft reset will be required.
+/// \return Status
+/// EFrameworkunifiedStatus - success or error
+///////////////////////////////////////////////////////////////////////////////
+const CHAR RestartModule[] = "me";
+
+EFrameworkunifiedStatus CSystemManager::ActOnModuleFailure(HANDLE f_hApp,
+ SS_String f_moduleName, BOOL &f_refResetRequired) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ ModuleLaunchListIter l_ModuleListIter;
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ ESMPLThreadCommandIds l_PLCmd = ePLThrdCmd_NONE;
+ SS_String l_PLCmdStr = "";
+
+ f_refResetRequired = FALSE;
+
+ l_eStatus = GetModuleIterator(f_moduleName.c_str(), l_ModuleListIter);
+ if (l_eStatus != eFrameworkunifiedStatusOK) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error: Module %s not found in Group Launch Map", f_moduleName.c_str());
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return (eFrameworkunifiedStatusDbRecNotFound);
+ }
+
+ // LCOV_EXCL_BR_START 6: Because the condition cannot be set
+ if (eFrameworkunifiedStatusOK
+ != (l_eStatus = RemoveModuleEntryFromHB(f_hApp,
+ l_ModuleListIter->name.c_str()))) {
+ // LCOV_EXCL_BR_STOP
+ // LCOV_EXCL_START 6: Because the condition cannot be set
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error: RemoveModuleEntryFromHB(%s) errored: %d/'%s'",
+ l_ModuleListIter->name.c_str(), l_eStatus,
+ GetStr(l_eStatus).c_str());
+ // LCOV_EXCL_STOP
+ }
+
+ if (TRUE == l_ModuleListIter->critical
+ && (l_ModuleListIter->relaunch_count >= l_ModuleListIter->retry_cnt)) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error: Critical module '%s' re-launch counter exceeded limit (%d).",
+ l_ModuleListIter->name.c_str(), l_ModuleListIter->retry_cnt);
+
+ l_ModuleListIter->SetModuleState(MODULE_STATE_SKIPPED);
+
+ // Module has crossed re-launched limit and is not going to be re-launched.
+ // It must however still be terminated.
+ l_PLCmd = ePLThrdCmd_TERMINATE_MODULE_REQST;
+ l_PLCmdStr = "ePLThrdCmd_TERMINATE_MODULE_REQST";
+
+ // Module is critical. Restart system.
+ f_refResetRequired = TRUE;
+ // Restart required?
+ } else if (0 == std::strcmp(l_ModuleListIter->restart.c_str(), RestartModule)) { // LCOV_EXCL_BR_LINE 6: Because the condition cannot be set // NOLINT(whitespace/line_length)
+ // LCOV_EXCL_START 6: Because the condition cannot be set
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "Module: %s, relaunch_count: %d",
+ l_ModuleListIter->name.c_str(),
+ l_ModuleListIter->relaunch_count);
+
+ if (l_ModuleListIter->relaunch_count < l_ModuleListIter->retry_cnt) {
+ SS_String l_ModulePath = (m_BinaryFilesPath + l_ModuleListIter->path);
+
+ FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__,
+ " Requesting ReLaunch of '%s' '%s'",
+ l_ModuleListIter->name.c_str(), l_ModulePath.c_str());
+
+ l_PLCmd = ePLThrdCmd_RELAUNCH_MODULE_REQST;
+ l_PLCmdStr = "ePLThrdCmd_RELAUNCH_MODULE_REQST";
+ l_ModuleListIter->relaunch_count++;
+ l_ModuleListIter->relaunch_status = RelaunchErr;
+ } else if ((FALSE == l_ModuleListIter->critical)
+ && (l_ModuleListIter->relaunch_count
+ >= l_ModuleListIter->retry_cnt)) {
+ FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__,
+ " Warning: Skipping re-launch of non-critical %s module, "
+ "re-launch counter exceeded limit(%d). Terminating module.",
+ l_ModuleListIter->name.c_str(),
+ l_ModuleListIter->retry_cnt);
+
+ l_ModuleListIter->SetModuleState(MODULE_STATE_SKIPPED);
+
+ // non critical module has crossed re-launched limit and is not going to be re-launched.
+ // We must terminate the module in the event that it has become non responsive.
+ l_PLCmd = ePLThrdCmd_TERMINATE_MODULE_REQST;
+ l_PLCmdStr = "ePLThrdCmd_TERMINATE_MODULE_REQST";
+ }
+ // LCOV_EXCL_STOP
+ } else { // LCOV_EXCL_BR_LINE 6: Because the condition cannot be set
+ // LCOV_EXCL_START 6: Because the condition cannot be set
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__,
+ " Warning: %s is not required to be re-launched, "
+ "skipping re-launch and terminating module.",
+ l_ModuleListIter->name.c_str());
+
+ l_ModuleListIter->SetModuleState(MODULE_STATE_SKIPPED);
+
+ // Module restart not required.
+ // We must terminate the module in the event that it has become non responsive.
+ l_PLCmd = ePLThrdCmd_TERMINATE_MODULE_REQST;
+ l_PLCmdStr = "ePLThrdCmd_TERMINATE_MODULE_REQST";
+ // LCOV_EXCL_STOP
+ }
+
+
+ if (ePLThrdCmd_NONE != l_PLCmd) {
+ l_eStatus = SendRequestToLauncher(f_hApp, l_ModuleListIter, l_PLCmd, l_PLCmdStr); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+
+ LOG_ERROR_REC_HIST_IF_ERRORED(l_eStatus, "SendRequestToLauncher()"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h // NOLINT(whitespace/line_length)
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return (l_eStatus);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup ErrorEventCreateHmiDisplayString
+///
+/// \brief Create error event HMI colored square display string.
+///
+/// \return Error Display String.
+///////////////////////////////////////////////////////////////////////////////
+std::string CSystemManager::ErrorEventCreateHmiDisplayString(void) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ std::stringstream l_displayNamess; // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ std::stringstream l_pidss; // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ std::stringstream l_hmiDispStr; // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+
+ if (0 != strncmp("",
+ m_errorEventCurrentIter->m_loggingInfo.binaryFileName,
+ sizeof(m_errorEventCurrentIter->m_loggingInfo.binaryFileName))) {
+ l_displayNamess << m_errorEventCurrentIter->m_loggingInfo.binaryFileName; // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ } else {
+ l_displayNamess << m_errorEventCurrentIter->m_moduleQueueName;
+ }
+
+ if (m_errorEventCurrentIter->m_loggingInfo.pid != 0) {
+ l_pidss << " PID: " << m_errorEventCurrentIter->m_loggingInfo.pid;
+ }
+
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return (l_hmiDispStr.str());
+} // LCOV_EXCL_BR_LINE 10:The final line
+
Code Review / staging / basesystem.git / blobdiff