diff options
Diffstat (limited to 'systemservice/logger_service/server/include')
28 files changed, 2521 insertions, 0 deletions
diff --git a/systemservice/logger_service/server/include/loggerservicedebug_loggerservicelog.h b/systemservice/logger_service/server/include/loggerservicedebug_loggerservicelog.h new file mode 100644 index 00000000..5a2f56e8 --- /dev/null +++ b/systemservice/logger_service/server/include/loggerservicedebug_loggerservicelog.h @@ -0,0 +1,81 @@ +/* + * @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_NS_LogTraceSender +/// \brief This file supports AGL application logging. +/// +/////////////////////////////////////////////////////////////////////////////// +#ifndef LOGGER_SERVICE_SERVER_INCLUDE_LOGGERSERVICEDEBUG_LOGGERSERVICELOG_H_ +#define LOGGER_SERVICE_SERVER_INCLUDE_LOGGERSERVICEDEBUG_LOGGERSERVICELOG_H_ +#include <native_service/ns_logger_if.h> + +#define ZONE_INIT ZONEMASK(10) +#define ZONE_FUNC ZONEMASK(11) +#define ZONE_MEM ZONEMASK(12) +#define ZONE_13 ZONEMASK(13) +#define ZONE_14 ZONEMASK(14) +#define ZONE_15 ZONEMASK(15) +#define ZONE_16 ZONEMASK(16) +#define ZONE_17 ZONEMASK(17) +#define ZONE_18 ZONEMASK(18) +#define ZONE_19 ZONEMASK(19) +#define ZONE_20 ZONEMASK(20) +#define ZONE_21 ZONEMASK(21) +#define ZONE_22 ZONEMASK(22) +#define ZONE_23 ZONEMASK(23) +#define ZONE_24 ZONEMASK(24) +#define ZONE_25 ZONEMASK(25) +#define ZONE_PRD_INFO3 ZONEMASK(26) +#define ZONE_PRD_INFO2 ZONEMASK(27) +#define ZONE_PRD_INFO1 ZONEMASK(28) +#define ZONE_INFO ZONEMASK(29) +#define ZONE_WARN ZONEMASK(30) +#define ZONE_ERR ZONEMASK(31) + +#define ZONE_TEXT_10 "Init" +#define ZONE_TEXT_11 "Function" +#define ZONE_TEXT_12 "Memory" +#define ZONE_TEXT_13 "" +#define ZONE_TEXT_14 "" +#define ZONE_TEXT_15 "" +#define ZONE_TEXT_16 "" +#define ZONE_TEXT_17 "" +#define ZONE_TEXT_18 "" +#define ZONE_TEXT_19 "" +#define ZONE_TEXT_20 "" +#define ZONE_TEXT_21 "" +#define ZONE_TEXT_22 "" +#define ZONE_TEXT_23 "" +#define ZONE_TEXT_24 "" +#define ZONE_TEXT_25 "" +#define ZONE_TEXT_26 "Product Info3" +#define ZONE_TEXT_27 "Product Info2" +#define ZONE_TEXT_28 "Product Info1" +#define ZONE_TEXT_29 "Info" +#define ZONE_TEXT_30 "Warning" +#define ZONE_TEXT_31 "Error" + +#ifndef FRAMEWORKUNIFIEDLOGOPTIONS +#define FRAMEWORKUNIFIEDLOGOPTIONS(LMSGQ) // LPRINT , LMSGQ, LSLOGGER +#endif + +#ifndef FRAMEWORKUNIFIEDLOGAPPZONES +#define FRAMEWORKUNIFIEDLOGAPPZONES ZONE_INFO, ZONE_FUNC, ZONE_ERR, ZONE_WARN, ZONE_PRD_INFO1, ZONE_PRD_INFO2, ZONE_PRD_INFO3 +#endif + +extern const CHAR AppName[]; +#endif // LOGGER_SERVICE_SERVER_INCLUDE_LOGGERSERVICEDEBUG_LOGGERSERVICELOG_H_ diff --git a/systemservice/logger_service/server/include/loggerservicedebug_thread_if.h b/systemservice/logger_service/server/include/loggerservicedebug_thread_if.h new file mode 100644 index 00000000..8a435114 --- /dev/null +++ b/systemservice/logger_service/server/include/loggerservicedebug_thread_if.h @@ -0,0 +1,319 @@ +/* + * @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_NS_LogTraceSender +/// \brief This file supports the logging thread interface. +/// +/////////////////////////////////////////////////////////////////////////////// +#ifndef LOGGER_SERVICE_SERVER_INCLUDE_LOGGERSERVICEDEBUG_THREAD_IF_H_ +#define LOGGER_SERVICE_SERVER_INCLUDE_LOGGERSERVICEDEBUG_THREAD_IF_H_ + +#include <pthread.h> +#ifdef AGL_STUB +#else +#include <sys/neutrino.h> +#include <sys/dispatch.h> +#endif +#include <errno.h> +#include <sched.h> +#include <stdio.h> +#include <native_service/frameworkunified_types.h> +#include <native_service/frameworkunified_thread_priority.h> +#include <system_service/ss_logger_service.h> +#include <system_service/ss_logger_service_local.h> +#include <string> +#include "loggerservicedebug_loggerservicelog.h" + +typedef std::string ThreadName; //< service name + +typedef enum _EThreadCommandIds { + eThrdCmdUsbEject = 5463, ///< USB eject --> frameworkunifieddebug + eThrdCmdUsbCaptureLogs, ///< USB Capture log --> frameworkunifieddebug + eThrdCmdUsbStoreLogs, ///< USB Store log --> frameworkunifieddebug + eThrdCmdWriteFilesToUsb, ///< frameworkunifieddebug --> Writer + eThrdCmdWriteDataToFile, ///< Reader --> Writer + eThrdCmdWriterStop, ///< frameworkunifieddebug --> Writer (Stop writing to the file) + eThrdCmdWriterResume, ///< frameworkunifieddebug --> Writer (Continue writing to the file) + eThrdCmdCaptureLogScriptExit, ///< LogCaptureScript - > frameworkunifieddebug + eThrdCmdWriteEvntFilesToUsb, ///< Wreite Event files to USB + eThrdCmdcopytofile, + eThrdCmdClearEvntLogs, ///< Clear event logs + eThrdCmdStatisticalCounter, ///< Read statistical counter + eThrdCmdStatisticalCounterSuccessResp, ///< Statistical counter positiv Response from child thread + eThrdCmdStatisticalCounterErrorResp, ///< Statistical counter Negative Response from child thread + eThrdCmdResetStatisticalCntrs, + eThrdCmdCopyEventLogUSBResponse, ///< Copy event logs to usb response from child thread + eThrdCmdClearEventLogResponse, ///< Clear event logs response fromchild thread + eThrdCmdPersistLogs, ///< Statistical counter Response fromchild thread + eThrdCmdSetVINnumber, + eThrdCmdImmPersistEvtLog, + eThrdCmdMileageData, + eThrdCmdGetNumberOfEventsLogged, + eThrdCmdNumberOfEventsLoggedResponse, + eThrdCmdUploadEventLog, + eThrdCmdUploadEventLogResponse, + eThrdCmdCopyEvntLogToTmp, + eThrdCmdCopyEvntLogToTmpResponse +} EThreadCommandIds; + +typedef struct _TThrdWriteDataToFileEvt { + static const UI_32 LN_LEN = 1024; + CHAR line[LN_LEN]; + UI_32 length; +} TThrdWriteLogDataToFileEvt, TThrdWriteTransmitDataToFileEvt; + +typedef struct _TThrdWriteFilesToUsbEvt { + static const UI_32 LOC_PATH_LEN = 256; + CHAR location[LOC_PATH_LEN]; ///< full path where files should be copied too + UI_32 loc_len; +} TThrdWriteLogFilesToUsbEvt, TThrdWriteTransmitFilesToUsbEvt; + +typedef struct _TThrdCaptureLogsEvt { + static const UI_32 FN_LEN = 256; + CHAR location[FN_LEN]; + CHAR parse_fn[FN_LEN]; ///< full path an name of the file that should be parsed for event actions. +} TThrdCaptureLogsEvt; + +// Structure to hold the USB device informaton +typedef struct _TThrdEvtLogStore { + BOOL IsDeviceAvailable; + static const UI_32 FN_LEN = 256; + CHAR location[FN_LEN]; + CHAR parse_fn[FN_LEN]; ///< full path an name of the file that should be parsed for event actions. +} TThrdEvtLogStore; + +typedef struct _TInitFlag { + UI_8 mileage_flagbit :1; + UI_8 statcounter_flagbit :1; + UI_8 eventlog_flagbit :1; + UI_8 reghandlers_flagbit :1; +} TInitFlag; + +typedef struct _TSessionData { + std::string strSrcName; + UI_32 session_id; +} TSessionData; + +typedef struct _TEvntNumber { + TSessionData stSessiondata; + UI_16 u16numberofeventslogged; +} TEvntsLogged; + +typedef struct _TWriteFilesToUsbCmdData { + TSessionData stSessiondata; + EEvtLogUSBDevNumber eDevId; +} TWriteFilesToUsbCmdData; + +typedef struct _TWriteFilesToUsbCmdResponse { + TSessionData stSessiondata; + UI_8 u8Response; +} TWriteFilesToUsbCmdResponse; + +typedef struct _TClearEvntLogCmdResponse { + TSessionData stSessiondata; + UI_8 u8Response; +} TClearEvntLogCmdResponse; + +typedef struct _TStatisticalCountersCmd { + TSessionData stSessiondata; + EStatCounterGroupID eGroupId; +} TStatisticalCountersCmd; + +typedef struct _TStatisticalCntCmdSuccessResp { + TSessionData stSessiondata; + SStatisticalCounter stBuffer; +} TStatisticalCntCmdSuccessResp; + +typedef struct _TUploadEventLogResp { + TSessionData stSessiondata; + STEventLogPersistBuffer stEventLogBuffer; +} TUploadEventLogResp; + +typedef struct _TEventLogCopyStatus { + static const UI_8 FilePathSize = 64; + CHAR EventLogFilePath[FilePathSize]; + UI_8 status; +} TEventLogCopyStatus; + +typedef enum _ECaptureLogScriptResp { + ekCLSStatusCompleteSuccessful, + ekCLSStatusInitError, + ekCLSStatusExecuteError, + ekCLSStatusCopyError, + ekCLSStatusChmodError, +} ECaptureLogScriptResp; + +class ThreadWrapper { + public: + + ThreadWrapper(const char* t_name, void* (*routine)(void*), void* arg) { // LCOV_EXCL_START 8:ThreadWrapper class is never used + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + pthread_attr_t attr; + struct sched_param params; + + if (EOK != pthread_attr_init(&attr)) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Error: pthread_attr_init failed errno: %d", errno); + } + if (EOK != pthread_attr_getschedparam(&attr, ¶ms)) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Error: pthread_attr_getschedparam failed errno: %d", errno); + } + SI_32 prio = frameworkunified::framework::CFrameworkunifiedThreadPriorities::GetPriority( + std::string(t_name)); + if (-1 != prio) { + params.sched_priority = prio; + if (EOK != pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED)) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Error: pthread_attr_setinheritsched failed errno: %d", errno); + } + if (EOK != pthread_attr_setschedparam(&attr, ¶ms)) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Error: pthread_attr_setschedparam failed errno: %d", errno); + } + } + + if (EOK != pthread_create(&m_thread, &attr, routine, arg)) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error: pthread_create failed errno: %d", + errno); + } + } + // LCOV_EXCL_STOP + + + ~ThreadWrapper() { // LCOV_EXCL_START 8:ThreadWrapper class is never used + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert +// todo: Need a clean way to cleanup thread in case class closes + } + // LCOV_EXCL_STOP + + + operator pthread_t() const { // LCOV_EXCL_START 8:ThreadWrapper class is never used + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + return m_thread; + } + // LCOV_EXCL_STOP + + private: + pthread_t m_thread; +}; + + +class CChild { + public: + CChild(const char* parentsName, const char * sendDataToQue, + const char * clientsName, void* (*routine)(void*), + const char * sendToUdpQue = "") + : m_clientName(clientsName), + m_parentName(parentsName), + m_sendDataToQueuName(sendDataToQue), + m_sendDataToUdpQueName(sendToUdpQue), + m_barInit(InitBarrier()), + m_thread(clientsName, routine, reinterpret_cast<void*>(this)) { // LCOV_EXCL_START 7:debug code + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + } + // LCOV_EXCL_STOP + + void Join() { // LCOV_EXCL_START 7:debug code + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + if (EOK != pthread_join(m_thread, NULL)) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error: pthread_join failed errno: %d", + errno); + } + } + // LCOV_EXCL_STOP + + const char * ParentName() { // LCOV_EXCL_START 7:debug code + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + return m_parentName.c_str(); + } + // LCOV_EXCL_STOP + + const char * ClientName() { // LCOV_EXCL_START 7:debug code + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + return m_clientName.c_str(); + } + // LCOV_EXCL_STOP + + const char * SendDataToQue() { // LCOV_EXCL_START 7:debug code + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + return m_sendDataToQueuName.c_str(); + } + // LCOV_EXCL_STOP + + const char * SendDataToUdpQueue() { // LCOV_EXCL_START 7:debug code + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + return m_sendDataToUdpQueName.c_str(); + } + // LCOV_EXCL_STOP + + bool IsValidWaitBarrier() { // LCOV_EXCL_START 7:debug code + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + if (m_barInit) { + int wbret = pthread_barrier_wait(&m_barrier); + return ( PTHREAD_BARRIER_SERIAL_THREAD == wbret) || (0 == wbret); + } + + return false; + } + // LCOV_EXCL_STOP + + private: + bool InitBarrier() { // LCOV_EXCL_START 7:debug code + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + /// Note: the count value should match the number of threads that are readers and usb notifiers + return (EOK == pthread_barrier_init(&m_barrier, NULL, 2) ? true : false); + } + // LCOV_EXCL_STOP + + private: + ThreadName m_clientName; + ThreadName m_parentName; + ThreadName m_sendDataToQueuName; + ThreadName m_sendDataToUdpQueName; + bool m_barInit; + ThreadWrapper m_thread; + pthread_barrier_t m_barrier; +}; + +class LoggerserviceDebugChildThread { + public: + typedef enum e { + kLoggerserviceDebugLogQueReader, + kLoggerserviceDebugTransmitQueReader, + kLoggerservicePerformanceLogQueReader, + kLoggerserviceDebugCaptureLogScript, + kLoggerserviceDebugEventLogque, + kLoggerserviceDebugMax + } ELoggerserviceDebugThreads; + + LoggerserviceDebugChildThread(); + virtual ~LoggerserviceDebugChildThread(); + BOOL Start(ELoggerserviceDebugThreads id, const char* parentsName, + const char * sendDataToQue, void* (*routine)(void*), + const char * sendToUdpQue = ""); + void Stop(ELoggerserviceDebugThreads id); + void StopAll(); + const char * Name(ELoggerserviceDebugThreads id); + void LiftWaitBarrier(ELoggerserviceDebugThreads id); + BOOL Running(ELoggerserviceDebugThreads id) const; + private: + ThreadName names[kLoggerserviceDebugMax]; + CChild * threads[kLoggerserviceDebugMax]; +}; + +#endif // LOGGER_SERVICE_SERVER_INCLUDE_LOGGERSERVICEDEBUG_THREAD_IF_H_ diff --git a/systemservice/logger_service/server/include/loggerservicedebug_writer_Evntworker.h b/systemservice/logger_service/server/include/loggerservicedebug_writer_Evntworker.h new file mode 100644 index 00000000..cef5c183 --- /dev/null +++ b/systemservice/logger_service/server/include/loggerservicedebug_writer_Evntworker.h @@ -0,0 +1,211 @@ +/* + * @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_NS_LogTraceSender +/// \brief frameworkunifieddebug writer thread class, handles writing a log file +/// all really done by my_writer class. +/// +/////////////////////////////////////////////////////////////////////////////// +#ifndef LOGGER_SERVICE_SERVER_INCLUDE_LOGGERSERVICEDEBUG_WRITER_EVNTWORKER_H_ +#define LOGGER_SERVICE_SERVER_INCLUDE_LOGGERSERVICEDEBUG_WRITER_EVNTWORKER_H_ + +#include <stdlib.h> +#include <native_service/frameworkunified_types.h> +#include <native_service/frameworkunified_framework_if.h> +#include <native_service/frameworkunified_multithreading.h> +#include <system_service/ss_devicedetection_service_ifc.h> +#include <native_service/ns_logger_if.h> +#include <native_service/ns_eventlogger.h> +#include <map> +#include <iostream> +#include <deque> +#include "loggerservicedebug_thread_if.h" + + +// File path names for Evnet and counter logs +extern const CHAR DEBUG_EVNTLOG_PATH_FN[]; +extern const CHAR g_strEvntLogQueWorkerName[]; +extern const CHAR DEBUG_LOG_PATH_FN[]; +extern const CHAR Counter_LOG_PATH_FN[]; +extern const CHAR Counter_LOG_PATH_STARTFN[]; +extern const CHAR Counter_LOG_PATH_SHUTFN[]; +extern const CHAR Mileage_LOG_PATH_FN[]; + +typedef struct _TevntWriterInfo { + static const UI_32 FN_LEN = 256; + UI_32 max_filelen; + CHAR base_cnt_filename[FN_LEN]; + CHAR mileage_filename[FN_LEN]; +} TEvntWriterInfo; + +typedef enum _eDatatype_ { + COMMON_DATA, + EVENT_SPECIFIC_DATA +} EDatatype_SS; + +typedef enum _eSystemPhase_ { + STARTUP_SS = 0x21, + NORMAL_SS = 0x22, + SHUTDOWN_SS = 0x23 +} ESystemPhase_SS; + +#pragma pack(1) +typedef struct _stLogEventFull_ { + UI_32 ts; + UI_8 grp_ID; + UI_8 event_id; + UI_8 data[4]; + ESystemPhase_SS phase; + UI_16 cnt_ID; + EDatatype_SS typeofdata; +} st_LogEvent_full; +#pragma pack(0) + +// Deque to hold the Event information +typedef std::deque<st_LogEvent_ss> DEQUE_Event_Type; + +// Map to hold the Counter information on phase +typedef std::map<UI_16, UI_32> Counter; + +/*Map to hold the all the counter information */ +typedef std::map<EStatCounterGroupID, Counter> CounterInformation; + +class CEvntWriterWorker { + public: + CEvntWriterWorker(); + CEvntWriterWorker(TEvntWriterInfo & wi); // NOLINT (runtime/references) + virtual ~CEvntWriterWorker(); + // initialize the object + EFrameworkunifiedStatus Initialize(HANDLE hThread); + + /// Copy event logs to USB request from parent thread + EFrameworkunifiedStatus OnCmdWriteEventFilesToUsb(HANDLE hThread); + + /// Event logging request from NS logger + EFrameworkunifiedStatus OnCmdEventLog(UI_8* pbuf); + + /// Clear event logs request from parent thread + EFrameworkunifiedStatus OnCmdClearEventLogs(HANDLE hThread); + + /// Read statistical counter request from parent thread + EFrameworkunifiedStatus OnCmdReadStatisticalCounter(HANDLE hThread); + + /// Read statistical counter based on counter group ID + EFrameworkunifiedStatus ReadStatisticalCounter(EStatCounterGroupID eStatCounterGroupID, + SStatisticalCounter& buffer); // NOLINT (runtime/references) + + /// Reset statistical counter request from parent thread + EFrameworkunifiedStatus OnCmdResetStatisticalCounter(HANDLE hThread); + + /// Reset statistical counter based on counter group ID + EFrameworkunifiedStatus ResetStatisticalCounter(EStatCounterGroupID eStatCounterGroupID); + + EFrameworkunifiedStatus OnCmdStop(HANDLE hThread); + + EFrameworkunifiedStatus OnCmdStart(HANDLE hThread); + + /// Counter logging request from NS logger + EFrameworkunifiedStatus OnCmdIncrcount(UI_8* pbuf); + + /// Event and Counter logging request from NS logger + EFrameworkunifiedStatus OnCmdIncrwriteevent(UI_8* pbuf); + + /// Reading counter value from file based on phase + EFrameworkunifiedStatus readCountFromFile(PCSTR filename); + + /// Writing counter value from file based on phase + EFrameworkunifiedStatus writeCountToFile(PCSTR filename); + + /// Writing event value from file based on phase + EFrameworkunifiedStatus write_event_to_file(const CHAR* filename); + + /// Copy event files to USB based onUSB device number + UI_8 copy_event_files_to_usb(TThrdEvtLogStore *pStUSBIndo); + + /// Functioncall to populate the counter value to map + VOID OnCmdIncrcount_phase(st_LogCount *cnt); + + /// Function call to populate the event value to deque + VOID OnCmdWriteEventLogs(st_LogEvent_ss *ev); + + /// Set the VIN number + EFrameworkunifiedStatus OnCmdSetVIN(HANDLE hThread); + + /// Get the VIN number + VOID OnCmdGetVIN(STVIN_NUMBER& f_stVIN_Number); // NOLINT (runtime/references) + + /// Functional call to write events from deque to local buffer + VOID write_events_to_buffer(STEventLogPersistBuffer* f_stEvtLogBuf); + + /// Functional call to read events from buffer to deque + VOID read_events_from_buffer(STEventLogPersistBuffer* f_stEvtLogBuf); + + /// Functional call to immediate persist event log + EFrameworkunifiedStatus immediate_persist_event_log(HANDLE hThread); + + /// Functional call to set mileage information in Evt thread space + EFrameworkunifiedStatus EvtThd_SetMileage(HANDLE hThread); + + /// Functional call to write mileage data to file for persisting + EFrameworkunifiedStatus write_mileage_to_file(const CHAR* filename); + + /// Functional call to read mileage data from persistent file during startup + EFrameworkunifiedStatus read_mileage_from_file(const CHAR* filename); + + EFrameworkunifiedStatus OnCmdReadNumberOfEventsLogged(HANDLE hThread); + + EFrameworkunifiedStatus EventLogRegisterCbHandlers(HANDLE hThread); + + EFrameworkunifiedStatus OnCmdUploadEventLog(HANDLE hThread); + + EFrameworkunifiedStatus OnCmdCopyEvntLogToTmp(HANDLE hThread); + /// Static Members for Event and counter logging + static CounterInformation counter; + static DEQUE_Event_Type deque_event_info; + + private: + STVIN_NUMBER m_stVINnumber; + UI_32 m_u32MileageData; + UI_32 m_u32NumberEventsLogged; + TUploadEventLogResp m_stUploadEventLogResp; + EFrameworkunifiedStatus counterIncrementByValue(EStatCounterGroupID group, UI_16 id, + UI_32 value); + EFrameworkunifiedStatus writeGroupToFile(FILE *fp, EStatCounterGroupID group); +}; + +/// Event logging Child thread start and shut down functions +EFrameworkunifiedStatus EvntWriterWorkerOnStart(HANDLE hThread); +EFrameworkunifiedStatus EvntWriterWorkerOnStop(HANDLE hThread); + +/// USBdevice detectioncall backs +EFrameworkunifiedStatus DD_USBSrvDetectionCallBack(HANDLE hApp); +EFrameworkunifiedStatus DD_USBServiceAvailabilityCallBack(HANDLE hThread); +EFrameworkunifiedStatus DD_USBOpenSessionAckCallBack(HANDLE hThread); +EFrameworkunifiedStatus DD_USBCloseSessionAckCallBack(HANDLE hApp); + +inline void u16copy(PUI_8 pDest, UI_16 Source) { + *(pDest++) = (UI_8) (Source & 0x00FF); + *(pDest++) = (UI_8) ((Source & 0xFF00) >> 8); +} +inline void u32copy(PUI_8 pDest, UI_32 Source) { + *(pDest++) = (UI_8) (Source & 0x000000FF); + *(pDest++) = (UI_8) ((Source & 0x0000FF00) >> 8); + *(pDest++) = (UI_8) ((Source & 0x00FF0000) >> 16); + *(pDest++) = (UI_8) ((Source & 0xFF000000) >> 24); +} + +#endif // LOGGER_SERVICE_SERVER_INCLUDE_LOGGERSERVICEDEBUG_WRITER_EVNTWORKER_H_ diff --git a/systemservice/logger_service/server/include/readerWriter/reader/mem_reader.h b/systemservice/logger_service/server/include/readerWriter/reader/mem_reader.h new file mode 100644 index 00000000..a5c65ec0 --- /dev/null +++ b/systemservice/logger_service/server/include/readerWriter/reader/mem_reader.h @@ -0,0 +1,51 @@ +/* + * @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. + */ + +/* + * mem_reader.h + * + * Created on: Oct 22, 2013 + */ + +#ifndef LOGGER_SERVICE_SERVER_INCLUDE_READERWRITER_READER_MEM_READER_H_ +#define LOGGER_SERVICE_SERVER_INCLUDE_READERWRITER_READER_MEM_READER_H_ + +#include <native_service/ns_sharedmem.h> +#include <native_service/ns_sharedmem_reader.h> +#include <string> +#include "reader.h" + +namespace ReaderWriter { +class CMemReader : public ReaderWriter::CReader { + public: + CMemReader(); + virtual ~CMemReader(); + EFrameworkunifiedStatus Initialize(CLoggerCfg* f_pLoggerCfg, std::string f_name, + UI_32 f_maxSize); + EFrameworkunifiedStatus Read(UI_8* f_data, UI_32 f_length, SI_32& f_bytesRead); // NOLINT (runtime/references) + EFrameworkunifiedStatus ReadToFile(std::string f_fileName, UI_32& f_Written); // NOLINT (runtime/references) + EFrameworkunifiedStatus Open(void); + BOOL IsOpen(void); + void Close(); + EFrameworkunifiedStatus ResetPosition(void); + + private: + CNSSharedMemReader* m_pSharedBuf; + UI_32 m_sharedBufSize; +}; +} // namespace ReaderWriter + +#endif // LOGGER_SERVICE_SERVER_INCLUDE_READERWRITER_READER_MEM_READER_H_ diff --git a/systemservice/logger_service/server/include/readerWriter/reader/queue_reader.h b/systemservice/logger_service/server/include/readerWriter/reader/queue_reader.h new file mode 100644 index 00000000..139796a7 --- /dev/null +++ b/systemservice/logger_service/server/include/readerWriter/reader/queue_reader.h @@ -0,0 +1,49 @@ +/* + * @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_SS_LoggerService +/// \brief TODO +/// +/////////////////////////////////////////////////////////////////////////////// +#ifndef LOGGER_SERVICE_SERVER_INCLUDE_READERWRITER_READER_QUEUE_READER_H_ +#define LOGGER_SERVICE_SERVER_INCLUDE_READERWRITER_READER_QUEUE_READER_H_ + +#include <mqueue.h> +#include <native_service/frameworkunified_types.h> +#include <string> +#include "reader.h" + +namespace ReaderWriter { + +class CQueueReader : public CReader { + public: + CQueueReader(); + virtual ~CQueueReader(); + EFrameworkunifiedStatus Initialize(CLoggerCfg* f_pLoggerCfg, std::string f_name, + UI_32 f_maxSize); + EFrameworkunifiedStatus Read(UI_8 *f_data, UI_32 f_length, SI_32 &f_bytesRead); // NOLINT (runtime/references) + BOOL IsOpen(void); + EFrameworkunifiedStatus Open(void); + void Close(); + private: + mqd_t m_handle; + std::string m_queName; +}; + +} // namespace ReaderWriter + +#endif // LOGGER_SERVICE_SERVER_INCLUDE_READERWRITER_READER_QUEUE_READER_H_ diff --git a/systemservice/logger_service/server/include/readerWriter/reader/reader.h b/systemservice/logger_service/server/include/readerWriter/reader/reader.h new file mode 100644 index 00000000..7b0141de --- /dev/null +++ b/systemservice/logger_service/server/include/readerWriter/reader/reader.h @@ -0,0 +1,52 @@ +/* + * @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_SS_LoggerService +/// \brief TODO +/// +/////////////////////////////////////////////////////////////////////////////// +#ifndef LOGGER_SERVICE_SERVER_INCLUDE_READERWRITER_READER_READER_H_ +#define LOGGER_SERVICE_SERVER_INCLUDE_READERWRITER_READER_READER_H_ +#include <native_service/frameworkunified_types.h> +#include <string> +#include "readerWriter/reader_writer_cfg.h" +#include "ss_logger_cfg.h" + +namespace ReaderWriter { + +class CReader { + public: + CReader(); + virtual ~CReader(); + + static CReader* OpenReader(CLoggerCfg* f_pLoggerCfg, EReaderType f_type, + std::string f_name, UI_32 f_maxSize); + virtual EFrameworkunifiedStatus Initialize(CLoggerCfg* f_pLoggerCfg, std::string f_name, + UI_32 f_maxSize) = 0; + virtual BOOL IsOpen(void) = 0; + virtual EFrameworkunifiedStatus Open(void) = 0; + virtual EFrameworkunifiedStatus Read(UI_8* f_data, UI_32 f_length, SI_32& f_bytesRead) = 0; // NOLINT (runtime/references) + virtual EFrameworkunifiedStatus ReadToFile(std::string f_fileName, UI_32& f_Written); // NOLINT (runtime/references) + + virtual void Close() = 0; + virtual EFrameworkunifiedStatus ResetPosition(void); + + protected: + CLoggerCfg * m_pLoggerCfg; +}; +} // namespace ReaderWriter +#endif // LOGGER_SERVICE_SERVER_INCLUDE_READERWRITER_READER_READER_H_ diff --git a/systemservice/logger_service/server/include/readerWriter/reader_writer.h b/systemservice/logger_service/server/include/readerWriter/reader_writer.h new file mode 100644 index 00000000..b0754725 --- /dev/null +++ b/systemservice/logger_service/server/include/readerWriter/reader_writer.h @@ -0,0 +1,77 @@ +/* + * @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_SS_LoggerService +/// \brief TODO +/// +/////////////////////////////////////////////////////////////////////////////// +#ifndef LOGGER_SERVICE_SERVER_INCLUDE_READERWRITER_READER_WRITER_H_ +#define LOGGER_SERVICE_SERVER_INCLUDE_READERWRITER_READER_WRITER_H_ + +#include <pthread.h> +#include <native_service/frameworkunified_types.h> +#include <string> +#include "readerWriter/reader_writer_cfg.h" +#include "readerWriter/reader/reader.h" +#include "readerWriter/writer/writer.h" + +namespace ReaderWriter { + +class CReaderWriter { + public: + CReaderWriter(); + virtual ~CReaderWriter(); + + EFrameworkunifiedStatus Initialize(CLoggerCfg* f_pLoggerCfg, EReaderType f_readerType, + std::string f_readerName, UI_32 f_readerMaxSize, + EWriterType f_writerType, std::string f_writer1Name, + UI_32 f_writer1MaxSize); + EFrameworkunifiedStatus Initialize(CLoggerCfg* f_pLoggerCfg, EReaderType f_readerType, + std::string f_readerName, UI_32 f_readerMaxSize, + EWriterType f_writerType, std::string f_writer1Name, + UI_32 f_writer1MaxSize, std::string f_writer2Name, + UI_32 f_writer2MaxSize); + EFrameworkunifiedStatus Start(std::string f_readerName); + EFrameworkunifiedStatus Stop(); + void ThreadFunction(CReaderWriter* l_pObj); + void Cleanup(CReaderWriter* l_pObj); + EFrameworkunifiedStatus FlushCache(std::string f_filename); + EFrameworkunifiedStatus UpdateLoggingParameters(void); + + private: + void Pause(void); + void Resume(void); + static void* ThreadFunctionWrapper(void* param); + + static void CleanupWrapper(void* param); + CLoggerCfg* m_pLoggerCfg; + CReader* m_reader; + CWriter* m_writer; + BOOL m_running; + pthread_t m_thread; + pthread_barrier_t m_barrier; + std::string m_readerName; + + pthread_mutex_t m_writeMutex; + pthread_mutex_t m_pauseMutex; + pthread_cond_t m_condVariable; + BOOL m_paused; +}; + +} // namespace ReaderWriter + +#endif // LOGGER_SERVICE_SERVER_INCLUDE_READERWRITER_READER_WRITER_H_ diff --git a/systemservice/logger_service/server/include/readerWriter/reader_writer_cfg.h b/systemservice/logger_service/server/include/readerWriter/reader_writer_cfg.h new file mode 100644 index 00000000..b39353bc --- /dev/null +++ b/systemservice/logger_service/server/include/readerWriter/reader_writer_cfg.h @@ -0,0 +1,35 @@ +/* + * @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_SS_LoggerService +/// \brief TODO +/// +/////////////////////////////////////////////////////////////////////////////// +#ifndef LOGGER_SERVICE_SERVER_INCLUDE_READERWRITER_READER_WRITER_CFG_H_ +#define LOGGER_SERVICE_SERVER_INCLUDE_READERWRITER_READER_WRITER_CFG_H_ +namespace ReaderWriter { +typedef enum _ERWType { + eReaderWriterTypeFile, + eReaderWriterTypeQueue, + eReaderWriterTypeUdp, + eReaderWriterTypeUdpAndFile, // Only for writer | pass filename and queueName + eReaderWriterTypeMem, + eReaderWriterTypeInvalid +} EReaderType, EWriterType; +} + +#endif // LOGGER_SERVICE_SERVER_INCLUDE_READERWRITER_READER_WRITER_CFG_H_ diff --git a/systemservice/logger_service/server/include/readerWriter/writer/cached_file_writer.h b/systemservice/logger_service/server/include/readerWriter/writer/cached_file_writer.h new file mode 100644 index 00000000..ad286589 --- /dev/null +++ b/systemservice/logger_service/server/include/readerWriter/writer/cached_file_writer.h @@ -0,0 +1,45 @@ +/* + * @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_SS_LoggerService +/// \brief TODO +/// +/////////////////////////////////////////////////////////////////////////////// +#ifndef LOGGER_SERVICE_SERVER_INCLUDE_READERWRITER_WRITER_CACHED_FILE_WRITER_H_ +#define LOGGER_SERVICE_SERVER_INCLUDE_READERWRITER_WRITER_CACHED_FILE_WRITER_H_ + +#include <native_service/frameworkunified_types.h> +#include "file_writer.h" + +#define CACHED_BLOCK_SIZE (UI_32)(4*1024) + +namespace ReaderWriter { + +class CCachedFileWriter : public CFileWriter { + public: + CCachedFileWriter(); + virtual ~CCachedFileWriter(); + EFrameworkunifiedStatus Write(UI_8 *f_data, UI_32 f_length, SI_32 &f_bytesWritten); // NOLINT (runtime/references) + EFrameworkunifiedStatus FlushCache(void); + private: + UI_8 m_buffer[CACHED_BLOCK_SIZE ]; + UI_32 m_index; +}; + +} // namespace ReaderWriter + +#endif // LOGGER_SERVICE_SERVER_INCLUDE_READERWRITER_WRITER_CACHED_FILE_WRITER_H_ diff --git a/systemservice/logger_service/server/include/readerWriter/writer/file_writer.h b/systemservice/logger_service/server/include/readerWriter/writer/file_writer.h new file mode 100644 index 00000000..caf81c9b --- /dev/null +++ b/systemservice/logger_service/server/include/readerWriter/writer/file_writer.h @@ -0,0 +1,51 @@ +/* + * @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_SS_LoggerService +/// \brief TODO +/// +/////////////////////////////////////////////////////////////////////////////// +#ifndef LOGGER_SERVICE_SERVER_INCLUDE_READERWRITER_WRITER_FILE_WRITER_H_ +#define LOGGER_SERVICE_SERVER_INCLUDE_READERWRITER_WRITER_FILE_WRITER_H_ +#include <native_service/frameworkunified_types.h> +#include <string> +#include "writer.h" + +namespace ReaderWriter { + +class CFileWriter : public CWriter { + public: + CFileWriter(); + virtual ~CFileWriter(); + EFrameworkunifiedStatus Initialize(CLoggerCfg* f_pLoggerCfg, std::string f_Name1, + UI_32 f_size1, std::string f_Name2, UI_32 f_size2); + EFrameworkunifiedStatus Write(UI_8 *f_data, UI_32 f_length, SI_32 &f_bytesWritten); // NOLINT (runtime/references) + void Close(); + BOOL IsOpen(void); + EFrameworkunifiedStatus Open(void); + protected: + EFrameworkunifiedStatus WriteData(UI_8 *f_data, UI_32 f_length, SI_32 &f_bytesWritten); // NOLINT (runtime/references) + private: + int m_FileHandle; + off_t m_fileposn; + UI_32 m_maxFileSize; + std::string m_filename; +}; + +} // namespace ReaderWriter + +#endif // LOGGER_SERVICE_SERVER_INCLUDE_READERWRITER_WRITER_FILE_WRITER_H_ diff --git a/systemservice/logger_service/server/include/readerWriter/writer/udp_file_writer.h b/systemservice/logger_service/server/include/readerWriter/writer/udp_file_writer.h new file mode 100644 index 00000000..65e58e0e --- /dev/null +++ b/systemservice/logger_service/server/include/readerWriter/writer/udp_file_writer.h @@ -0,0 +1,54 @@ +/* + * @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_SS_LoggerService +/// \brief TODO +/// +/////////////////////////////////////////////////////////////////////////////// +#ifndef LOGGER_SERVICE_SERVER_INCLUDE_READERWRITER_WRITER_UDP_FILE_WRITER_H_ +#define LOGGER_SERVICE_SERVER_INCLUDE_READERWRITER_WRITER_UDP_FILE_WRITER_H_ +#include <native_service/frameworkunified_types.h> +#include <string> +#include "writer.h" +#include "udp_writer.h" +#include "file_writer.h" + +namespace ReaderWriter { + +class CUdpFileWriter : public CWriter { + public: + CUdpFileWriter(); + virtual ~CUdpFileWriter(); + EFrameworkunifiedStatus Initialize(CLoggerCfg* f_pLoggerCfg, std::string f_Name1, + UI_32 f_size1, std::string f_Name2, UI_32 f_size2); + EFrameworkunifiedStatus Write(UI_8 *f_data, UI_32 f_length, SI_32 &f_bytesWritten); // NOLINT (runtime/references) + void Close(); + BOOL IsOpen(void); + EFrameworkunifiedStatus Open(void); + EFrameworkunifiedStatus FlushCache(void); + EFrameworkunifiedStatus UpdateLoggingParameters(void); + private: + CUdpWriter *m_pUdpWriter; + CFileWriter *m_pFileWriter; + CLoggerCfg* m_pLoggerCfg; + std::string m_ipAddress; + UI_32 m_port; + std::string m_FileName; + UI_32 m_FileSize; +}; +} // namespace ReaderWriter +#endif // LOGGER_SERVICE_SERVER_INCLUDE_READERWRITER_WRITER_UDP_FILE_WRITER_H_ diff --git a/systemservice/logger_service/server/include/readerWriter/writer/udp_writer.h b/systemservice/logger_service/server/include/readerWriter/writer/udp_writer.h new file mode 100644 index 00000000..cf0944ad --- /dev/null +++ b/systemservice/logger_service/server/include/readerWriter/writer/udp_writer.h @@ -0,0 +1,63 @@ +/* + * @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_SS_LoggerService +/// \brief TODO +/// +/////////////////////////////////////////////////////////////////////////////// +#ifndef LOGGER_SERVICE_SERVER_INCLUDE_READERWRITER_WRITER_UDP_WRITER_H_ +#define LOGGER_SERVICE_SERVER_INCLUDE_READERWRITER_WRITER_UDP_WRITER_H_ + +#include <netinet/in.h> +#include <string> +#include "writer.h" + +#define REMOTE_IP_PORT 3500 +namespace ReaderWriter { +#define UDP_MAX_LENGTH (UI_32)1024*4 +#define UDP_CACHED_BLOCK_SIZE (UI_32)1024*4 +#define SEND_RETRY_VALUE (UI_8) 5 + +#define OWN_ADDRESS "169.254.80.8" +class CUdpWriter : public CWriter { + public: + CUdpWriter(); + virtual ~CUdpWriter(); + EFrameworkunifiedStatus Initialize(CLoggerCfg* f_pLoggerCfg, std::string f_Name1, + UI_32 f_size1, std::string f_Name2, UI_32 f_size2); + + EFrameworkunifiedStatus Write(UI_8 *f_data, UI_32 f_length, SI_32 &f_bytesWritten); // NOLINT (runtime/references) + void Close(); + EFrameworkunifiedStatus UpdateLoggingParameters(void); + BOOL IsOpen(void); + EFrameworkunifiedStatus Open(void); + EFrameworkunifiedStatus FlushCache(void); + private: + EFrameworkunifiedStatus WriteData(UI_8 *f_data, UI_32 f_length, SI_32 &f_bytesWritten); // NOLINT (runtime/references) + + int m_SocketHandle; + sockaddr_in m_oSAInfo; + std::string m_IPAddress; + UI_32 m_index; + UI_32 m_port; + BOOL m_InitialTimeElapsed; + UI_8 m_buffer[UDP_CACHED_BLOCK_SIZE]; +}; + +} // namespace ReaderWriter + +#endif // LOGGER_SERVICE_SERVER_INCLUDE_READERWRITER_WRITER_UDP_WRITER_H_ diff --git a/systemservice/logger_service/server/include/readerWriter/writer/writer.h b/systemservice/logger_service/server/include/readerWriter/writer/writer.h new file mode 100644 index 00000000..15d93aa6 --- /dev/null +++ b/systemservice/logger_service/server/include/readerWriter/writer/writer.h @@ -0,0 +1,56 @@ +/* + * @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_SS_LoggerService +/// \brief TODO +/// +/////////////////////////////////////////////////////////////////////////////// +#ifndef LOGGER_SERVICE_SERVER_INCLUDE_READERWRITER_WRITER_WRITER_H_ +#define LOGGER_SERVICE_SERVER_INCLUDE_READERWRITER_WRITER_WRITER_H_ +#include <native_service/frameworkunified_types.h> +#include <string> +#include "readerWriter/reader_writer_cfg.h" +#include "ss_logger_cfg.h" + +namespace ReaderWriter { + +class CWriter { + public: + CWriter(); + virtual ~CWriter(); + + static CWriter* OpenWriter(CLoggerCfg* f_pLoggerCfg, EReaderType f_type, + std::string f_Name1, UI_32 f_size1, + std::string f_Name2, UI_32 f_size2); + virtual EFrameworkunifiedStatus Initialize(CLoggerCfg* f_pLoggerCfg, std::string f_Name1, + UI_32 f_size1, std::string f_Name2, + UI_32 f_size2) = 0; + virtual EFrameworkunifiedStatus Write(UI_8 *f_data, UI_32 f_length, + SI_32 &f_bytesWritten) = 0; // NOLINT (runtime/references) + virtual void Close() = 0; + virtual EFrameworkunifiedStatus FlushCache(void); + virtual EFrameworkunifiedStatus UpdateLoggingParameters(void); + virtual BOOL IsOpen(void) = 0; + virtual EFrameworkunifiedStatus Open(void) = 0; + + protected: + CLoggerCfg * m_pLoggerCfg; +}; + +} // namespace ReaderWriter + +#endif // LOGGER_SERVICE_SERVER_INCLUDE_READERWRITER_WRITER_WRITER_H_ diff --git a/systemservice/logger_service/server/include/ss_logger_cfg.h b/systemservice/logger_service/server/include/ss_logger_cfg.h new file mode 100644 index 00000000..93aaef95 --- /dev/null +++ b/systemservice/logger_service/server/include/ss_logger_cfg.h @@ -0,0 +1,185 @@ +/* + * @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_SS_LoggerService +/// \brief Provide support for SS Logger module configuration. +/// +/////////////////////////////////////////////////////////////////////////////// +#ifndef LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_CFG_H_ +#define LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_CFG_H_ + +/////////////////////////////////////////////////////////////////////////////// +// INCLUDES +/////////////////////////////////////////////////////////////////////////////// + +#include <native_service/frameworkunified_types.h> +#include <native_service/ns_config_parser_if.h> +#include <native_service/ns_logger_if.h> +#include <system_service/ss_templates.h> +#include <system_service/ss_logger_service.h> +#include <system_service/ss_logger_service_local.h> +#include <string> +#include <vector> +#include "loggerservicedebug_loggerservicelog.h" + +/////////////////////////////////////////////////////////////////////////////// +// CONFIGURATION CLASS DEFINITION +/////////////////////////////////////////////////////////////////////////////// +/*Default values for the storage thread*/ +#define ERROR_EVENT_STORAGE_QUEUE_NAME "/SSLoggerStrage" +#define ERROR_EVENT_STORAGE_PRIORITY (UI_8)30 +#define ERROR_EVENT_STORAGE_SLEEP_TIME (useconds_t)50000 +#define ERROR_EVENT_STORAGE_SLEEP_AFTER (UI_8)5 + +#if ENABLE_PRODUCTION_BUILD == 1 +#define SS_LOGGER_DEFAULT_VALUE eDeactivate +#else +#define SS_LOGGER_DEFAULT_VALUE eActivate +#endif + +#define LOGGERSERVICELOG_EMMC_COUNTER_MAX 99999u + +struct SLoggerStorageInfo { + SLoggerStorageInfo() + : Name(ERROR_EVENT_STORAGE_QUEUE_NAME), + Priority(ERROR_EVENT_STORAGE_PRIORITY), + Timeout(ERROR_EVENT_STORAGE_SLEEP_TIME), + TimeoutAfter(ERROR_EVENT_STORAGE_SLEEP_AFTER) { // LCOV_EXCL_BR_LINE 11:Unexpected branch + } + std::string Name; + SI_32 Priority; + SI_32 Timeout; + SI_32 TimeoutAfter; +}; + +enum EInsertEventType { + eInsertEventEELStorage, + eInsertEventEELActive, + eInsertEventLoggerserviceEmmcLogs, + eInsertEventInvalid +}; + +struct ExternalLogInfo { + std::string dirname; + std::string path; + BOOL remove; +}; + +struct ExternalLogList { + SI_32 num; + SI_32 max; + ExternalLogInfo* p_info; +}; + +class CLoggerCfg { + public: + CLoggerCfg(void); + ~CLoggerCfg(void); + + EFrameworkunifiedStatus Initialize(HANDLE f_hApp); + + EFrameworkunifiedStatus Load(const std::string &f_filePathAndName); + EFrameworkunifiedStatus Validate(void); + void Print(void); + + EFrameworkunifiedStatus SetLoggingParams(HANDLE f_hApp, + STLoggerSetParams f_stLoggerSetParams); + + EFrameworkunifiedStatus SetUDPLogging(HANDLE f_hApp, const ELOGGER_STAT f_eUDPLoggingStatus); + + EFrameworkunifiedStatus PersistLoggingParam(HANDLE f_hApp); + std::string getEmmcOutputPath(void); + std::string getEmmcOutputNaviLogPath(void); + std::string getUsb0MountPath(void); + std::string getUsb1MountPath(void); + std::string getSdMountPath(void); + std::string getDeviceName(void); + void setUsb0MountPath(std::string &f_deviceMountpath); // NOLINT (runtime/references) + EFrameworkunifiedStatus GetUserInvokedDestination(std::string &f_dest); // NOLINT (runtime/references) + + EFrameworkunifiedStatus GetEmmcDestination(std::string &f_dest); // NOLINT (runtime/references) + EFrameworkunifiedStatus GetEmmcNaviLogDestination(std::string &f_dest); // NOLINT (runtime/references) + + UI_32 GetUserInvokedCounter(void); + EFrameworkunifiedStatus GetIncrementAndPersistUserInvokedCounter(HANDLE f_hApp, + UI_32 &f_counter); // NOLINT (runtime/references) + + EFrameworkunifiedStatus GetAndIncrementEmmcCounter(UI_32 &f_counter); // NOLINT (runtime/references) + EFrameworkunifiedStatus RefreshEmmcCounter(UI_32 &f_counter) const; // NOLINT (runtime/references) + + void ResetEmmcCounter(void); + + SI_32 m_logMaxFileSize; + UI_32 m_logMask[ZONE_MASK_ARRAY_ELTS]; + SI_32 m_performanceLogMaxFileSize; + SI_32 m_emmcOutputMax; + SI_32 m_emmcOutputErrMax; + SI_32 m_emmcOutputGrpRelaunchMax; + SI_32 m_emmcOutputNaviLogMax; + SI_32 m_emmcOutputNaviLogNmlMax; + SI_32 m_emmcOutputNaviLogErrMax; + ExternalLogList m_ExternalLogList; + + std::string m_emmcOutputPath; + std::string m_emmcOutputNaviLogPath; + std::string m_usb0MountPath; + std::string m_usb1MountPath; + std::string m_sdMountPath; + + EDEV_TYPE GetConnectedDevice(std::string f_devPath); + EInsertEventType GetInsertEventType(std::string f_relPath); + + std::string GetEELActivateRelPath(void); + std::string GetDebugFolderContentRelPath(void); + std::string GetEELExportRelPath(void); + + BOOL IsUDPLoggingEnabled(void); + void AddLoggingParamCB(CbFuncPtr f_fp); + + EFrameworkunifiedStatus GetLoggerStorageInfo(SLoggerStorageInfo &f_info); // NOLINT (runtime/references) + BOOL IsLoggingEnabled(void); + EFrameworkunifiedStatus EelActivateLogging(HANDLE f_hApp); + ExternalLogList GetExternalLogList(void); + + private: + void UpdateLoggingStatus(void); + std::vector<CbFuncPtr> m_LoggingCallBack; + void GetHighestEmmcCounterValue(UI_32 &f_counter); // NOLINT (runtime/references) + + EDEV_TYPE m_eDevType; + UI_32 m_UserInvokedLoggingNumber; + UI_32 m_EmmcCounter; + ELOGGER_STAT m_eLoggerUDPLoggingStatus; + BOOL m_udpEnvFlag; + ELOGGER_STAT m_eLoggerStatus; + + std::string m_EELStorageRelPath; + + std::string m_EELActivateRelPath; + + std::string m_LoggerserviceEmmcLogsRelPath; + + EFrameworkunifiedStatus SetandPersistLoggingParams(HANDLE f_hApp, + STLoggerSetAllParams f_Params, + BOOL f_InitCall); + SLoggerStorageInfo m_loggerStorageInfo; + + void RemoveCarriageReturn(std::string &f_str); // NOLINT (runtime/references) +}; + +#endif // LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_CFG_H_ + diff --git a/systemservice/logger_service/server/include/ss_logger_common.h b/systemservice/logger_service/server/include/ss_logger_common.h new file mode 100644 index 00000000..80a56af7 --- /dev/null +++ b/systemservice/logger_service/server/include/ss_logger_common.h @@ -0,0 +1,115 @@ +/* + * @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. + */ + +/////////////////////////////////////////////////////////////////////////////// +/// \brief This file contains the callback for Notifications and Protocol +/// commands. +/// +/////////////////////////////////////////////////////////////////////////////// + +/** @addtogroup BaseSystem + * @{ + */ +/** @addtogroup system_service + * @ingroup BaseSystem + * @{ + */ +/** @addtogroup logger_service + * @ingroup system_service + * @{ + */ + +#ifndef LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_COMMON_H_ +#define LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_COMMON_H_ + +#include <native_service/frameworkunified_types.h> +#include <native_service/frameworkunified_framework_types.h> + +const CHAR DEBUG_LOG_PATH_DIR[] = "/tmp/frameworkunifiedlog"; +const CHAR DEBUG_LOG_PATH_FN[] = "/tmp/frameworkunified_debug.log"; +const CHAR TRANSMIT_LOG_PATH_FN[] = "/tmp/interfaceunified_transmit.log"; +const CHAR PERFORMANCE_LOG_PATH_FN[] = "/tmp/frameworkunified_performance.log"; +const CHAR DRINITIAL_LOG_PATH_FN[] = "/tmp/loggerservice_drinitial.log"; +const CHAR DRLOCATION_LOG_PATH_FN[] = "/tmp/loggerservice_drlocation.log"; +const CHAR KERNEL_LOG_PATH_FN[] = "/tmp/kernel.log"; +const CHAR KERNEL_BOOT_LOG_PATH_FN[] = "/ramd/BS/ss/logger_service/rwdata/frameworkunifiedlog/kernelboot.log"; + +const UI_32 PERFORMANCELOG_FILE_SZ = 256 * 1024; + +#define CLEAR_LOG_PATH_FN "/nv/BS/ss/logger_service/rwdata/frameworkunifiedlog/" +#define NULLCHAR '\0' + +#define DEBUG_USB_PATH "/mnt/sda1" +#define KERNEL_LOG_PATH_DIR "kernellog" + +template<typename C, EFrameworkunifiedStatus (C::*M)(HANDLE)> +class cpp_callback { + public: + static CallbackFunctionPtr set(void* pInst) { + if (pInst == NULL) + throw; + ms_pInst = pInst; + return &cpp_callback::call; + } + static EFrameworkunifiedStatus call(HANDLE y) { + if (ms_pInst == NULL) + return eFrameworkunifiedStatusFault; + C* c = static_cast<C*>(ms_pInst); + return (c->*M)(y); + } + private: + static void* ms_pInst; +}; + +template<typename C, EFrameworkunifiedStatus (C::*M)(HANDLE)> +void* cpp_callback<C, M>::ms_pInst = NULL; + +typedef enum _LoggerServiceStatus { + eLSInit, + eLSStart, + eLSStop, +} ELOGGERSERVICESTATUS; + +typedef enum { + SS_LOGGER_KLOG_GET, /* type : get kernel.log */ + SS_LOGGER_KBOOTLOG_CREATE /* type : create kernelboot.log */ +} SS_LOGGER_KLOG_OPE_TYPE; + +//////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup StopLoggingFunction +/// \~english @par Summary +/// Stop the logging function. +/// \~english @param [in] hApp +/// HANDLE - Application handle +/// \~english @retval +/// None +/// \~english @par Detail +/// - The API stops the logging function.\n +/// \n +/// - Include ss_logger_common.h +/// - Library libSS_SystemIfUnified.so +/// \~english @par Classification +/// Public +/// \~english @see +/// None +//////////////////////////////////////////////////////////////////////////////////////////// +void StopLoggingFunction(HANDLE hApp); + +#endif // LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_COMMON_H_ + +/** @}*/ // end of LoggerService +/** @}*/ // end of SystemService +/** @}*/ // end of BaseSystem diff --git a/systemservice/logger_service/server/include/ss_logger_device_detection.h b/systemservice/logger_service/server/include/ss_logger_device_detection.h new file mode 100644 index 00000000..5ee67c0e --- /dev/null +++ b/systemservice/logger_service/server/include/ss_logger_device_detection.h @@ -0,0 +1,66 @@ +/* + * @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_NS_InterfaceunifiedLogCapture +/// \brief This file supports USB logging threads. +/// +/////////////////////////////////////////////////////////////////////////////// +#ifndef LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_DEVICE_DETECTION_H_ +#define LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_DEVICE_DETECTION_H_ + +#include <system_service/ss_devicedetection_service_notifications.h> +#include <system_service/ss_devicedetection_service_ifc.h> +#include "ss_logger_cfg.h" +#include "ss_logger_util.h" + +extern const char * USB_INSERTED_RULE; + +// USB device is ejected +extern const CHAR USB_EJECTED_RULE[]; + +// The trigger event file (/log/retrievelog.evt) file is found on USB +extern const CHAR USB_CAPTURE_LOG_EVENT_RULE[]; + +// When the command to update system with script is executed all the console +// output will be redirected to this file on /tmp folder. later it will be +// moved to USB stick +extern const CHAR CAPTURE_LOG_FILENAME[]; + +// +extern const SI_32 INVALID_FD; +class CLoggerDeviceDetection { + public: + CLoggerDeviceDetection(); + ~CLoggerDeviceDetection(); + + EFrameworkunifiedStatus Initialize(HANDLE hApp, CLoggerCfg *f_pLoggerCfg); + EFrameworkunifiedStatus DD_ServiceAvailabilityCallBack(HANDLE hApp); + EFrameworkunifiedStatus DD_OpenSessionAckCallBack(HANDLE hApp); + EFrameworkunifiedStatus DD_CloseSessionAckCallBack(HANDLE hApp); + EFrameworkunifiedStatus DD_CloseSessionWithDevDetectionSrv(HANDLE hApp); + EFrameworkunifiedStatus DD_MediaDetectCallBack(HANDLE hApp); + + EFrameworkunifiedStatus OnStop(void); + private: + CLoggerCfg *m_pLoggerCfg; + + /// Device Detection Class Instance + DeviceDetectionServiceIf m_devDetect; + + CLoggerUtil *m_loggerUtil; +}; +#endif // LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_DEVICE_DETECTION_H_ diff --git a/systemservice/logger_service/server/include/ss_logger_error_event.h b/systemservice/logger_service/server/include/ss_logger_error_event.h new file mode 100644 index 00000000..177c0745 --- /dev/null +++ b/systemservice/logger_service/server/include/ss_logger_error_event.h @@ -0,0 +1,156 @@ +/* + * @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_SS_LoggerService +/// \brief This file supports error event logging. +/// +/////////////////////////////////////////////////////////////////////////////// +#ifndef LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_ERROR_EVENT_H_ +#define LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_ERROR_EVENT_H_ + +#include <time.h> +#include <native_service/frameworkunified_types.h> +#include <native_service/frameworkunified_framework_if.h> +#include <system_service/ss_system_types.h> +#include <system_service/ss_system_timer.h> +#include <system_service/ss_system_manager_protocol.h> +#include <string> +#include <vector> +#include "ss_logger_popups.h" +#include "ss_logger_common.h" +#include "ss_logger_reader_writer_control.h" +#include "ss_logger_error_event_cfg.h" +#include "ss_logger_cfg.h" +#include "ss_logger_util.h" +#include "readerWriter/reader_writer.h" +#include "readerWriter/reader_writer_cfg.h" +#include "ss_logger_error_event_storage.h" +#include "ss_logger_error_event_can_evt_reply.h" + +class CErrorEvent { + public: + CErrorEvent(); + ~CErrorEvent(); + + EFrameworkunifiedStatus Initialize(HANDLE f_hApp, CLoggerCfg *f_pLoggerCfg, + CReaderWriterControl *f_pReaderWriterControl, + HANDLE f_thrdEvntLogWriter, + std::string f_strEvntLogQueWorkerName); + + EFrameworkunifiedStatus RegisterSessionErrorEvent(HANDLE f_hApp); + + EFrameworkunifiedStatus OnOpenSession(HANDLE f_hApp, PCSTR f_pRequesterName, + HANDLE f_hSession); + + EFrameworkunifiedStatus OnCloseSession(HANDLE f_hApp, PCSTR f_pRequesterName, + HANDLE f_hSession); + + EFrameworkunifiedStatus StartLogging(HANDLE f_hApp, EErrorEventType f_eventType); + + EFrameworkunifiedStatus sendDiagEventErrorResponse(EELL_ErrorCode f_errCode); + + EFrameworkunifiedStatus sendDiagEventErrorResponse(EELL_ErrorCode f_errCode, + std::string f_destName); + + EFrameworkunifiedStatus sendDiagEventResponse(void); + + EFrameworkunifiedStatus SetDiagEventSourceName(std::string f_serviceName); + + void SetMileage(UI_32 f_mileage); + + void SetDiagSessionHandle(HANDLE hSession); + + EFrameworkunifiedStatus SaveNaviLog(EPWR_SHUTDOWN_TRIGGER_TYPE errorType); + EFrameworkunifiedStatus CreateKernelLog(HANDLE f_hApp, SS_LOGGER_KLOG_OPE_TYPE type); + + private: + typedef enum { + kSSL_ERROR_EVENT_TIMER_LOGGING_START_RSPN, + kSSL_ERROR_EVENT_TIMER_ARTIFACT_RSPN, + kSSL_ERROR_EVENT_TIMER_END + } ESSLErrorEventTimers; + + // Logging Protocol Function Prototypes + EFrameworkunifiedStatus OnStartLogging(HANDLE f_hApp); + EFrameworkunifiedStatus OnLogStartResponse(HANDLE f_hApp); + EFrameworkunifiedStatus OnLogStartResponseTimeout(HANDLE f_hApp); + EFrameworkunifiedStatus RequestNextArtifact(HANDLE f_hApp); + EFrameworkunifiedStatus OnArtifactResponse(HANDLE f_hApp); + EFrameworkunifiedStatus OnArtifactResponseTimeout(HANDLE f_hApp); + + // Protocol functions sent to self. + EFrameworkunifiedStatus OnArtifactRequest(HANDLE f_hApp); + + // Error Event Artifact Request Function Prototypes + EFrameworkunifiedStatus SendLogArtifactResponseToSelf( + HANDLE f_hApp, EArtifactId f_artifactId, + std::string f_artifactFilePathAndName); + + EFrameworkunifiedStatus OnObtainLoggerserviceLogRequest(HANDLE f_hApp); + EFrameworkunifiedStatus OnObtainTransmitLogRequest(HANDLE f_hApp); + EFrameworkunifiedStatus OnObtainPerformanceLogRequest(HANDLE f_hApp); + EFrameworkunifiedStatus OnObtainScreenShotRequest(HANDLE f_hApp); + EFrameworkunifiedStatus OnObtainScreenShotResponse(HANDLE f_hApp); + EFrameworkunifiedStatus OnObtainKernelLogInfoRequest(HANDLE f_hApp); + EFrameworkunifiedStatus OnObtainDRInitialLogRequest(HANDLE f_hApp); + EFrameworkunifiedStatus OnObtainDRLocationLogRequest(HANDLE f_hApp); + EFrameworkunifiedStatus OnStorageResponseOk(HANDLE f_hApp); + EFrameworkunifiedStatus OnStorageResponseWriteFailed(HANDLE f_hApp); + EFrameworkunifiedStatus OnStorageResponseNotFound(HANDLE f_hApp); + EFrameworkunifiedStatus OnStorageResponseNoWritten(HANDLE f_hApp); + EFrameworkunifiedStatus CheckPathForArtifact(HANDLE f_hApp, TLoggingArtifact f_artifact); + EFrameworkunifiedStatus OnClearAllLogRequest(HANDLE f_hApp); + EFrameworkunifiedStatus OnNaviLogRequest(HANDLE f_hApp); + + // verify function for external storage + EFrameworkunifiedStatus VerifyExtStorage(TLoggerErrorEvent event); + bool IsNeedVerify(EErrorEventType type); + + HANDLE m_hApp; + bool m_bIsPrevEventCompleted; + CErrorEventCfg m_errorEventCfg; + TLoggerErrorEvent m_errorEventNtfData; + Timer m_errorEventTimers[kSSL_ERROR_EVENT_TIMER_END]; + std::vector<TLoggingArtifact> m_artifactRequestVec; + TArtifactResponseVec m_artifactResponseVec; + std::vector<FrameworkunifiedProtocolCallbackHandler> m_requesterCallbacksVec; + std::string m_archiveDestination; + CLoggerUtil m_loggerUtil; + CLoggerPopups m_loggerPopups; + CLoggerCfg* m_pLoggerCfg; + CLoggerErrorEventStorage m_loggerStorage; + CLoggerErrorEventCANEvtReply m_loggerCanEvent; + static const UI_32 m_loggingStartRspnToSec = 1; + static const UI_32 m_screenShotRspnToSec = 2; + CReaderWriterControl* m_pReaderWriterControl; + + std::string m_ServiceName; + uint32_t m_time; + UI_32 m_currentEventTriggerNumber; + HANDLE m_diagsessionhandle; + + HANDLE m_thrdEvntLogWriter; + + public: + int m_sfd; +}; + +EFrameworkunifiedStatus SSLogger_SendtoSM(HANDLE f_hApp, TLoggingArtifact f_artifact); +EFrameworkunifiedStatus SSLogger_SendtoSelf(HANDLE f_hApp, TLoggingArtifact f_artifact); + +#endif // LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_ERROR_EVENT_H_ + diff --git a/systemservice/logger_service/server/include/ss_logger_error_event_archive.h b/systemservice/logger_service/server/include/ss_logger_error_event_archive.h new file mode 100644 index 00000000..2b5212dc --- /dev/null +++ b/systemservice/logger_service/server/include/ss_logger_error_event_archive.h @@ -0,0 +1,77 @@ +/* + * @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_SS_LoggerService +/// \brief This file supports error event logging. +/// +/////////////////////////////////////////////////////////////////////////////// +#ifndef LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_ERROR_EVENT_ARCHIVE_H_ +#define LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_ERROR_EVENT_ARCHIVE_H_ + +#include <native_service/frameworkunified_types.h> +#include <native_service/frameworkunified_framework_if.h> + +#include <libtar_listhash.h> +#include <libtar.h> + +#include <system_service/ss_system_types.h> +#include <string> +#include <vector> + +class CErrorEventArchive { + public: + CErrorEventArchive(); + ~CErrorEventArchive(); + + EFrameworkunifiedStatus openArchive(std::string f_pathAndName); + + EFrameworkunifiedStatus addToArchive(std::vector<std::string> f_filePathAndNameList); + + EFrameworkunifiedStatus addToArchive(std::string f_filePathAndName, + std::string f_destinationName, UI_8 f_depth = + CErrorEventArchive::MAX_DIRECTORY_DEPTH); + + EFrameworkunifiedStatus closeArchive(void); + + static SI_32 gzOpenArchive(PCHAR f_pcPathname, SI_32 f_siOflags, + SI_32 f_siMode); + + static SI_32 gzCloseArchive(); + + static ssize_t gzWriteArchive(int fd, const void* buf, size_t count); + + static ssize_t gzReadArchive(int fd, void* buf, size_t count); + + static const UI_8 MAX_DIRECTORY_DEPTH = 4; + + private: + EFrameworkunifiedStatus addFileToArchive(std::string f_filename, + std::string f_destinationName); + + EFrameworkunifiedStatus addDirectoryToArchive(std::string f_path, + std::string f_destinationName, UI_8 f_depth = + CErrorEventArchive::MAX_DIRECTORY_DEPTH); + + tartype_t m_gztype; + TAR *m_pTarInfo; + std::string m_pathAndName; + std::string m_tmpName; + + static const UI_32 TARMODE = 0644; +}; + +#endif // LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_ERROR_EVENT_ARCHIVE_H_ diff --git a/systemservice/logger_service/server/include/ss_logger_error_event_can_evt_reply.h b/systemservice/logger_service/server/include/ss_logger_error_event_can_evt_reply.h new file mode 100644 index 00000000..b976cdbb --- /dev/null +++ b/systemservice/logger_service/server/include/ss_logger_error_event_can_evt_reply.h @@ -0,0 +1,48 @@ +/* + * @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_SS_LoggerService +/// \brief This file supports notifying CAN abou HK and CAN error events +/// +/////////////////////////////////////////////////////////////////////////////// +#ifndef LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_ERROR_EVENT_CAN_EVT_REPLY_H_ +#define LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_ERROR_EVENT_CAN_EVT_REPLY_H_ + +#include <native_service/frameworkunified_types.h> +#include <system_service/ss_logger_service_protocol.h> + +#include "ss_logger_cfg.h" +#include "ss_logger_error_event_cfg.h" +#include "ss_logger_common.h" +class CLoggerErrorEventCANEvtReply { + public: + CLoggerErrorEventCANEvtReply(); + virtual ~CLoggerErrorEventCANEvtReply(); + EFrameworkunifiedStatus Initialize(CLoggerCfg* f_pLoggerCfg); + + BOOL IsEventNeeded(TLoggerErrorEvent f_event); + EFrameworkunifiedStatus PublishStartEvent(HANDLE f_hApp, TLoggerErrorEvent f_event); + EFrameworkunifiedStatus PublishEndEvent(HANDLE f_hApp, TLoggerErrorEvent f_event, + UI_32 f_triggerNumber, uint32_t f_time); + + EFrameworkunifiedStatus PublishErrorEvent(HANDLE f_hApp, TLoggerErrorEvent f_event, + BOOL f_isValid, UI_32 f_triggerNumber, + uint32_t f_time); + private: +}; + +#endif // LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_ERROR_EVENT_CAN_EVT_REPLY_H_ diff --git a/systemservice/logger_service/server/include/ss_logger_error_event_cfg.h b/systemservice/logger_service/server/include/ss_logger_error_event_cfg.h new file mode 100644 index 00000000..1a0e39ef --- /dev/null +++ b/systemservice/logger_service/server/include/ss_logger_error_event_cfg.h @@ -0,0 +1,135 @@ +/* + * @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_SS_LoggerService +/// \brief This file supports error event logging configuration. +/// +/////////////////////////////////////////////////////////////////////////////// +#ifndef LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_ERROR_EVENT_CFG_H_ +#define LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_ERROR_EVENT_CFG_H_ +#include <system_service/ss_system_manager_if.h> +#include <vector> +#include <map> +#include <string> + +#include "ss_logger_cfg.h" + +typedef UI_32 ARTIFACT_BIT_MASK; +typedef UI_32 EVENT_BIT_MASK; + +#define NBR_ARTIFACT_BITS (sizeof(ARTIFACT_BIT_MASK) * 8) + +enum EVENT_BIT { + EVENT_BIT_NONE = 0x00000000, + EVENT_BIT_POPUP = 1 << (UI_32) 1, + EVENT_BIT_CAN_NOTIFICATION = 1 << (UI_32) 2, + EVENT_BIT_DIAG = 1 << (UI_32) 3, +}; + +struct TLoggingErrorEventInformation { + ARTIFACT_BIT_MASK ArtifactBitMask; + EVENT_BIT_MASK EventBitMask; +}; +struct TLoggingArtifactCfg { + EErrorEventType ErrorType; + TLoggingErrorEventInformation Information; +}; +struct TLoggerErrorEvent { + TLoggerErrorEvent() + : EventType(eErrorEventTypeMaxValue), + ModuleName(""), + isNeedReboot(FALSE), + EventBitMask(EVENT_BIT_NONE) { // LCOV_EXCL_BR_LINE 11:Unexpected branch + } + TLoggerErrorEvent(SMErrorEventNtfData l_SMErrorEvent) { // NOLINT (runtime/explicit) + EventType = l_SMErrorEvent.EventType; + ModuleName = l_SMErrorEvent.ModuleName; + isNeedReboot = l_SMErrorEvent.isNeedReboot; + EventBitMask = EVENT_BIT_NONE; + } + EErrorEventType EventType; + std::string ModuleName; + BOOL isNeedReboot; + EVENT_BIT_MASK EventBitMask; +}; +struct TLoggingArtifact; + +typedef EFrameworkunifiedStatus (*TLoggingCbFunction)(HANDLE, TLoggingArtifact); + +enum ECallbackType { + eCbTypePath = 0, + eCbTypeFunction, + eCbTypeInvalid +}; + +struct TLoggingArtifactCallback { + ECallbackType Type; + std::string Path; + TLoggingCbFunction Function; +}; + +struct TLoggingArtifactInformation { + std::string OwnerServiceName; + UI_32 RequestTimeoutMs; + TLoggingArtifactCallback Cb; + BOOL Remove; +}; +struct TLoggingArtifact { + EArtifactId ArtifactId; + TLoggingArtifactInformation Information; +}; + +struct TLoggingArtifactResponse { + EArtifactId ArtifactId; + std::string Filepath; + BOOL Remove; +}; + +////////////////////////////////////////////////////////////////////////////////////////// +///// External function definition for Logger callbacks +////////////////////////////////////////////////////////////////////////////////////////// +extern EFrameworkunifiedStatus SSLogger_SendtoSM(HANDLE f_hApp, TLoggingArtifact f_artifact); +extern EFrameworkunifiedStatus SSLogger_SendtoSelf(HANDLE f_hApp, + TLoggingArtifact f_artifact); + +typedef std::map<EErrorEventType, TLoggingErrorEventInformation> TArtifactBitMaskMap; +typedef std::map<EArtifactId, TLoggingArtifactInformation> TArtifactMap; +typedef std::vector<TLoggingArtifactResponse> TArtifactResponseVec; + +class CErrorEventCfg { + public: + CErrorEventCfg(void); + + ~CErrorEventCfg(void); + + EFrameworkunifiedStatus Initialize(CLoggerCfg* p_logger_cfg); + + void GetArtifactRequestVec( + EErrorEventType f_eventType, + std::vector<TLoggingArtifact> &f_refArtifactRequestVec); // NOLINT (runtime/references) + EVENT_BIT_MASK GetEventsForErrorEvent(EErrorEventType f_eventType); + private: + UI_32 ValidateConfiguration(); + TArtifactBitMaskMap m_errorEventTypeToArtifactBitMaskMap; + TArtifactMap m_errorArtifactMap; + UI_32 m_ext_log_num; + + static TLoggingArtifactCfg m_loggerErrorEventCfgTbl[eErrorEventTypeMaxValue]; + static TLoggingArtifact m_loggerErrorArtifactCfgTbl[eArtifactIdMaxValue]; +}; + +#endif // LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_ERROR_EVENT_CFG_H_ diff --git a/systemservice/logger_service/server/include/ss_logger_error_event_storage.h b/systemservice/logger_service/server/include/ss_logger_error_event_storage.h new file mode 100644 index 00000000..8a2cbd46 --- /dev/null +++ b/systemservice/logger_service/server/include/ss_logger_error_event_storage.h @@ -0,0 +1,82 @@ +/* + * @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_SS_LoggerService +/// \brief This file supports error event logging. +/// +/////////////////////////////////////////////////////////////////////////////// +#ifndef LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_ERROR_EVENT_STORAGE_H_ +#define LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_ERROR_EVENT_STORAGE_H_ + +#include <sys/types.h> +#include <pthread.h> +#include <mqueue.h> +#include <time.h> +#include <native_service/frameworkunified_types.h> +#include <ss_logger_error_event_cfg.h> +#include <stub/Clock_API.h> +#include <string> +#include "ss_logger_cfg.h" + +enum ELoggerStorageThreadCommands { + eLoggerStorageThreadCmdOK = 0xAFFE, + eLoggerStorageThreadCmdWriteFailed, + eLoggerStorageThreadCmdNotFound, + eLoggerStorageThreadCmdNoWritten +}; + +class CLoggerErrorEventStorage { + public: + CLoggerErrorEventStorage(); + virtual ~CLoggerErrorEventStorage(); + + EFrameworkunifiedStatus Initialize(HANDLE f_hApp, std::string f_ParentName, + CLoggerCfg *f_pLoggerCfg); + + EFrameworkunifiedStatus Start(std::string f_target, TArtifactResponseVec f_responseVector, + uint32_t f_time); + + void ThreadFunction(void); + void Cleanup(void); + + private: + static void* ThreadFunctionWrapper(void* param); + static void CleanupWrapper(void* param); + + EFrameworkunifiedStatus PackageAndPlaceArtifacts(std::string f_archiveDestination, + TArtifactResponseVec &f_responseVector, // NOLINT (runtime/references) + uint32_t l_logTime); + + SI_32 CopyFiles(std::string f_archiveDestination, + TArtifactResponseVec &f_responseVector, BOOL isDeleteFiles); // NOLINT (runtime/references) + + EFrameworkunifiedStatus RemoveDeprecatedArtifacts(TArtifactResponseVec &f_responseVector); // NOLINT (runtime/references) + HANDLE m_parentMcQueue; + pthread_t m_thread; + pthread_mutex_t m_mutex; + mqd_t m_sendQueue; + mqd_t m_receiveQueue; + std::string m_destination; + TArtifactResponseVec m_responseVec; + struct mq_attr m_mqattr; + SI_32 m_mutexInit; + CLoggerCfg *m_pLoggerCfg; + SLoggerStorageInfo m_loggerStorageInfo; + uint32_t m_logTime; +}; + +#endif // LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_ERROR_EVENT_STORAGE_H_ diff --git a/systemservice/logger_service/server/include/ss_logger_fs_directory.h b/systemservice/logger_service/server/include/ss_logger_fs_directory.h new file mode 100644 index 00000000..7e8da15c --- /dev/null +++ b/systemservice/logger_service/server/include/ss_logger_fs_directory.h @@ -0,0 +1,108 @@ +/* + * @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_SS_LoggerService +/// \brief This file contains declaration of class CFSDirectory. +/// +/////////////////////////////////////////////////////////////////////////////// +#ifndef LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_FS_DIRECTORY_H_ +#define LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_FS_DIRECTORY_H_ +#include <native_service/frameworkunified_types.h> +#include<string> + +// Class to provide file system directory operations like create,delete etc. +class CFSDirectory { + public: + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CFSDirectory + /// Constructor of CFSDirectory class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + CFSDirectory(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ~CFSDirectory + /// Destructor of CFSDirectory class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + ~CFSDirectory(); + + //////////////////////////////////////////////////////////////////////////////////////////// + /// This method is used to check if the directory exists. + /// + /// \param [in] f_cDirPath + /// std::string - Path of the directory to delete. + /// + /// \return status + /// EFrameworkunifiedStatus - success or error + //////////////////////////////////////////////////////////////////////////////////////////// + static BOOL DoesDirectoryExist(std::string &f_cDirPath); // NOLINT (runtime/references) + + //////////////////////////////////////////////////////////////////////////////////////////// + /// This method is used to create a directory. + /// + /// \param [in] f_cDirPath + /// std::string - Path of the directory to delete. + /// + /// \return status + /// EFrameworkunifiedStatus - success or error + //////////////////////////////////////////////////////////////////////////////////////////// + static EFrameworkunifiedStatus CreateDirectory(std::string &f_cDirPath); // NOLINT (runtime/references) + + //////////////////////////////////////////////////////////////////////////////////////////// + /// This method is used to verify directory. + /// + /// \param [in] f_cPath + /// std::string - Path of the directory to delete. + /// + /// \return status + /// EFrameworkunifiedStatus - success or error + //////////////////////////////////////////////////////////////////////////////////////////// + static BOOL IsDirectory(std::string &f_cPath); // NOLINT (runtime/references) + + //////////////////////////////////////////////////////////////////////////////////////////// + /// This method is used to delete directory. + /// + /// \param [in] f_cPath + /// std::string - Path of the directory to delete. + /// + /// \return status + /// EFrameworkunifiedStatus - success or error + //////////////////////////////////////////////////////////////////////////////////////////// + static BOOL RemoveDirectory(std::string &f_cPath); // NOLINT (runtime/references) + + //////////////////////////////////////////////////////////////////////////////////////////// + /// This method is used to delete file in direcotry. + /// + /// \param [in] f_cPath + /// std::string - Path of the directory to delete. + /// + /// \return status + /// EFrameworkunifiedStatus - success or error + //////////////////////////////////////////////////////////////////////////////////////////// + static BOOL RemoveSubDirectory(std::string &f_cPath); // NOLINT (runtime/references) +}; + +#endif // LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_FS_DIRECTORY_H_ diff --git a/systemservice/logger_service/server/include/ss_logger_popups.h b/systemservice/logger_service/server/include/ss_logger_popups.h new file mode 100644 index 00000000..b5b50e89 --- /dev/null +++ b/systemservice/logger_service/server/include/ss_logger_popups.h @@ -0,0 +1,51 @@ +/* + * @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_SS_LoggerService +/// \brief This file supports error event logging. +/// +/////////////////////////////////////////////////////////////////////////////// +#ifndef LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_POPUPS_H_ +#define LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_POPUPS_H_ +#include <native_service/frameworkunified_types.h> +#include <system_service/ss_logger_service_protocol.h> +#include <string> +#include <vector> + +#include "ss_logger_cfg.h" +#include "ss_logger_error_event_cfg.h" +class CLoggerPopups { + public: + CLoggerPopups(); + virtual ~CLoggerPopups(); + EFrameworkunifiedStatus Initialize(CLoggerCfg* f_pLoggerCfg); + BOOL IsPopupNeeded(TLoggerErrorEvent f_event); + BOOL CanShowStartPopup(std::vector<TLoggingArtifact>* f_remainingArtifact); + EFrameworkunifiedStatus ShowStartPopup(HANDLE f_hApp, TLoggerErrorEvent f_event, + std::vector<TLoggingArtifact>* f_remainingArtifact, + std::string f_dest); + EFrameworkunifiedStatus ShowEndPopup(HANDLE f_hApp, TLoggerErrorEvent f_event, + std::string f_dest); + EFrameworkunifiedStatus ShowErrorPopup(HANDLE f_hApp, TLoggerErrorEvent f_event, + UI_16 f_errCode); + std::string getDeviceName(std::string f_dest); + private: + CLoggerCfg *m_pLoggerCfg; + BOOL m_startShown; +}; + +#endif // LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_POPUPS_H_ diff --git a/systemservice/logger_service/server/include/ss_logger_reader_writer_control.h b/systemservice/logger_service/server/include/ss_logger_reader_writer_control.h new file mode 100644 index 00000000..04d19374 --- /dev/null +++ b/systemservice/logger_service/server/include/ss_logger_reader_writer_control.h @@ -0,0 +1,49 @@ +/* + * @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. + */ + +/* + * ss_logger_reader_writer_control.h + */ + +#ifndef LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_READER_WRITER_CONTROL_H_ +#define LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_READER_WRITER_CONTROL_H_ + +#include <native_service/frameworkunified_types.h> +#include <string> +#include "readerWriter/reader_writer.h" +#include "ss_logger_cfg.h" + +enum EReaderWriterType { + eReaderWriterLogDebug, + eReaderWriterLogTransmit, + eReaderWriterLogPerformance, + eReaderWriterLogInvalid +}; +class CReaderWriterControl { + public: + CReaderWriterControl(); + virtual ~CReaderWriterControl(); + EFrameworkunifiedStatus Initialize(CLoggerCfg* f_pLoggerCfg); + EFrameworkunifiedStatus UpdateLoggingParams(void* param); + EFrameworkunifiedStatus FlushCache(EReaderWriterType f_type); + private: + CLoggerCfg * m_pLoggerCfg; + ReaderWriter::CReaderWriter m_debugReaderWriter; + ReaderWriter::CReaderWriter m_transmitReaderWriter; + ReaderWriter::CReaderWriter m_performanceReaderWriter; +}; + +#endif // LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_READER_WRITER_CONTROL_H_ diff --git a/systemservice/logger_service/server/include/ss_logger_scrshot.h b/systemservice/logger_service/server/include/ss_logger_scrshot.h new file mode 100644 index 00000000..5cc9dd9b --- /dev/null +++ b/systemservice/logger_service/server/include/ss_logger_scrshot.h @@ -0,0 +1,30 @@ +/* + * @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_SS_LoggerService +/// \brief +/// +/////////////////////////////////////////////////////////////////////////////// +#ifndef LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_SCRSHOT_H_ +#define LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_SCRSHOT_H_ + +#define JPEG_PATH_CH0 "/nv/BS/ss/logger_service/rwdata/screenShot/screen_shot_Ch0.jpeg" +#define JPEG_PATH_CH1 "/nv/BS/ss/logger_service/rwdata/screenShot/screen_shot_Ch1.jpeg" +#define SCRSHOT_EXE_PATH "/usr/agl/bin/SS_ScrShot" +#define SCREEN_SHOT_PATH "/nv/BS/ss/logger_service/rwdata/screenShot" + +#endif // LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_SCRSHOT_H_ diff --git a/systemservice/logger_service/server/include/ss_logger_service_callbacks.h b/systemservice/logger_service/server/include/ss_logger_service_callbacks.h new file mode 100644 index 00000000..786054c3 --- /dev/null +++ b/systemservice/logger_service/server/include/ss_logger_service_callbacks.h @@ -0,0 +1,96 @@ +/* + * @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_SS_LoggerService +/// \brief This file contains the callback for Notifications and Protocol +/// commands. +/// +/////////////////////////////////////////////////////////////////////////////// +#ifndef LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_SERVICE_CALLBACKS_H_ +#define LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_SERVICE_CALLBACKS_H_ + +#include <stdlib.h> +#include <stdio.h> +#include <native_service/frameworkunified_framework_types.h> +#include <system_service/ss_error_event_common.h> +#include "ss_logger_error_event.h" +#include "ss_logger_reader_writer_control.h" +#include "ss_logger_cfg.h" + +class CLoggerServiceCallbacks { + private: + static const UI_32 kNUMBER_PROTOCOL_HANDLERS = 17u; + FrameworkunifiedProtocolCallbackHandler m_protocolHandlers[kNUMBER_PROTOCOL_HANDLERS]; + CLoggerCfg *m_pLoggerCfg; + CErrorEvent *m_pErrorEvent; + + public: + CLoggerServiceCallbacks(); + ~CLoggerServiceCallbacks(); + + EFrameworkunifiedStatus Initialize(HANDLE f_hApp, CLoggerCfg *f_pLoggerCfg, + CErrorEvent *f_pErrorEvent); + + EFrameworkunifiedStatus LoggerServerOnOpenSession(HANDLE hApp); + + EFrameworkunifiedStatus LoggerServerOnCloseSession(HANDLE hApp); + + EFrameworkunifiedStatus LoggerServer_SetMileageData(HANDLE hApp); + + EFrameworkunifiedStatus LoggerServer_SetLoggerParams(HANDLE hApp); + + EFrameworkunifiedStatus LoggerServer_UDPLogging(HANDLE hApp); + + EFrameworkunifiedStatus LoggerServer_SetCurrentDateTime(HANDLE hApp); + + EFrameworkunifiedStatus LoggerServer_UpdateCommonInfo(HANDLE hApp); + + EFrameworkunifiedStatus LoggerServer_Handle_CWORD56_Events(HANDLE hApp); + + EFrameworkunifiedStatus LoggerServer_LogResetEvents(HANDLE hApp); + + EFrameworkunifiedStatus LoggerServer_OnCopyEmergencyLog(HANDLE hApp); + + EFrameworkunifiedStatus LoggerServer_OnCANTrigger(HANDLE f_hApp); + + EFrameworkunifiedStatus LoggerServer_OnDTCTrigger(HANDLE f_hApp); + + EFrameworkunifiedStatus LoggerServer_On_SHTDWN_Complete(HANDLE f_hApp); + + EFrameworkunifiedStatus LoggerServer_OnSetVIN(HANDLE hApp); + + EFrameworkunifiedStatus LoggerServer_OnCopyEvntLog(HANDLE hApp); + + EFrameworkunifiedStatus LoggerServer_OnClearEvntLog(HANDLE hApp); + + EFrameworkunifiedStatus LoggerServer_OnReadNumberOfEvents(HANDLE hApp); + + EFrameworkunifiedStatus LoggerServer_OnReadStatCounter(HANDLE hApp); + + EFrameworkunifiedStatus LoggerServer_OnResetStatCounter(HANDLE hApp); + + EFrameworkunifiedStatus LoggerServer_OnSetDiagID(HANDLE hApp); + + EFrameworkunifiedStatus LoggerServer_UploadEventLog(HANDLE hApp); + + HANDLE RetrieveRegisteredClientHandle(HANDLE hApp, PCSTR pRequester); +}; + +EFrameworkunifiedStatus LoggerService_OnStop(HANDLE hApp); + +#endif // LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_SERVICE_CALLBACKS_H_ + diff --git a/systemservice/logger_service/server/include/ss_logger_types.h b/systemservice/logger_service/server/include/ss_logger_types.h new file mode 100644 index 00000000..11542a58 --- /dev/null +++ b/systemservice/logger_service/server/include/ss_logger_types.h @@ -0,0 +1,52 @@ +/* + * @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_SS_LoggerService +/// \brief This file supports shared internal logger module data types. +/// +/////////////////////////////////////////////////////////////////////////////// +#ifndef LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_TYPES_H_ +#define LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_TYPES_H_ + +#include <native_service/frameworkunified_sm_eventdata.h> + +typedef enum _ENPS_Archivetype { + ARCHTYPE_COMPRESSION = 0, // Compression + ARCHTYPE_DECOMPRESSION = 1 // DeCompression +} ENPS_Archivetype; + +typedef CHAR CopyInfoStr[MAX_PATH_LENGTH]; ///< Information passed via the framework + +typedef enum _LOGGERSERVICE_COMPRESSION_TYPE { + eLoggerserviceNone = 0, // No Compression before file persistence + eLoggerserviceDefaultCompression, // Compress file before persistence using default compression method + eLoggerserviceCompressUsingLibz // Compress file before persistence using libz +} LOGGERSERVICE_COMPRESSION_TYPE; + +typedef struct _NPS_CopyInfoMsg { + CopyInfoStr m_cSourcePath; // Source path + CopyInfoStr m_cDestinationPath; // Destination path + ENPS_Archivetype m_eArchiveType; // Compression or DeCompression + LOGGERSERVICE_COMPRESSION_TYPE m_eCompressionType; // Check for Compression of the file +} NSP_CopyInfoCmd; + +typedef struct _NPS_CopyStatus { + BOOL m_bPersistenceChk; // Persistence Success or Failure + LOGGERSERVICE_COMPRESSION_TYPE m_eCompressionType; // Check for Compression of the file +} NSP_CopyStatusResponse, NSP_CopyCancel; + +#endif // LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_TYPES_H_ diff --git a/systemservice/logger_service/server/include/ss_logger_util.h b/systemservice/logger_service/server/include/ss_logger_util.h new file mode 100644 index 00000000..a49e0229 --- /dev/null +++ b/systemservice/logger_service/server/include/ss_logger_util.h @@ -0,0 +1,127 @@ +/* + * @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_SS_LoggerService +/// \brief Provide support for SS Logger module utility functions. +/// +/////////////////////////////////////////////////////////////////////////////// +#ifndef LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_UTIL_H_ +#define LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_UTIL_H_ + +/////////////////////////////////////////////////////////////////////////////// +// INCLUDES +/////////////////////////////////////////////////////////////////////////////// + +#include <time.h> +#include <native_service/frameworkunified_types.h> +#include <system_service/ss_templates.h> +#include <system_service/ss_system_manager_if.h> +#include <string> +#include <vector> +#include "ss_logger_error_event_cfg.h" +#include "loggerservicedebug_loggerservicelog.h" +#include "ss_logger_cfg.h" +/////////////////////////////////////////////////////////////////////////////// +// DEFINE +/////////////////////////////////////////////////////////////////////////////// +// If you changed BUF_MAX_SIZE, To contact the secure team. +// Because There is impact for decrypt tool. +#define BUF_MAX_SIZE (1024*8) +#define USB_PATH_SIZE 64 +#ifdef RELEASE_BUILD +#define DEV_ENC_EXTENSION ".enc1" +#define REL_ENC_EXTENSION ".enc2" +#define ALIGNMENT_SIZE 4 +#endif // RELEASE_BUILD +#define LOGGER_TMP_FN "__LOGGER.tmp" + +/////////////////////////////////////////////////////////////////////////////// +// CONFIGURATION CLASS DEFINITION +/////////////////////////////////////////////////////////////////////////////// +typedef enum _ELoggerserviceLogType { + eLoggerservicelogTypeNormal, + eLoggerservicelogTypeAbnormal, + eLoggerservicelogTypeGrpRelaunch, + eLoggerservicelogTypeOther, +} ELOGGERSERVICELOGTYPE; + +class CLoggerUtil { + public: + CLoggerUtil(void); + + ~CLoggerUtil(void); + + EFrameworkunifiedStatus Initialize(CLoggerCfg *f_pLoggerCfg); + + EFrameworkunifiedStatus checkDestinationAvailable(TLoggerErrorEvent &f_eventNtfData); // NOLINT (runtime/references) + std::string getDestination(TLoggerErrorEvent &f_eventNtfData); // NOLINT (runtime/references) + EFrameworkunifiedStatus getFilePathAndName(HANDLE f_hApp, + TLoggerErrorEvent &f_eventNtfData, // NOLINT (runtime/references) + uint32_t f_time, std::string &f_pathAndName); // NOLINT (runtime/references) + void SetMilage(UI_32 f_milage); + + EFrameworkunifiedStatus getEmmcNaviLogParams(uint32_t f_time, + EPWR_SHUTDOWN_TRIGGER_TYPE errorType, + std::string &f_pathAndName, UI_32 &f_logMax); // NOLINT (runtime/references) + + EFrameworkunifiedStatus deleteOldLog(std::string log_path, + std::vector<std::string> &l_vector, // NOLINT (runtime/references) + std::string &f_archive_destination, UI_32 max_num); // NOLINT (runtime/references) + EFrameworkunifiedStatus deleteOldEmmcLog(std::string &f_archive_destination, // NOLINT (runtime/references) + EErrorEventType type); + static EFrameworkunifiedStatus forceDeleteOldLog(std::string f_archive_destination, + size_t f_req_size); + static size_t deleteRequestLogs(std::string f_emmcpath, ELOGGERSERVICELOGTYPE f_reqtype, + size_t f_reqsize, ELOGGERSERVICELOGTYPE f_deltype); + static EFrameworkunifiedStatus CopyFile(std::string f_source, std::string f_destination); + static EFrameworkunifiedStatus CopyUntyped(std::string f_source, + std::string f_destination); + static EFrameworkunifiedStatus CopyDirectory(std::string f_source, + std::string f_destination); + + static EFrameworkunifiedStatus MoveFile(std::string f_source, std::string f_destination); + static EFrameworkunifiedStatus MoveUntyped(std::string f_source, + std::string f_destination); + static EFrameworkunifiedStatus MoveDirectory(std::string f_source, + std::string f_destination); + + static ELOGGERSERVICELOGTYPE QueryLoggerservicelogType(std::string f_logname); + static void SyncDir(std::string f_dir_path); +#ifdef RELEASE_BUILD + static EFrameworkunifiedStatus PathCheckAndCopyFile(std::string f_source, + std::string f_destination); +#endif // RELEASE_BUILD + void SetUsbMountPath(std::string usbpath); + + private: + std::string GetUserInvokedFilename(HANDLE f_hApp, uint32_t f_time); + std::string GetEmmcFilename(uint32_t f_time); + std::string GetEmmcErrorFilename(uint32_t f_time); + std::string GetEmmcNaviLogFilename(uint32_t f_time); + std::string GetTimeString(uint32_t f_time); + + EFrameworkunifiedStatus getNaviLogFilePathAndName(std::string &f_prefix, uint32_t f_time, // NOLINT (runtime/references) + std::string &f_pathAndName); // NOLINT (runtime/references) + + CLoggerCfg *m_pCfg; + UI_32 m_Milage; + UI_32 m_bootCount; + static char m_usbpath[USB_PATH_SIZE]; +}; + +#endif // LOGGER_SERVICE_SERVER_INCLUDE_SS_LOGGER_UTIL_H_ + |