diff options
Diffstat (limited to 'nsframework/framework_unified/client/NS_Logger/src/ns_logger.cpp')
| -rw-r--r-- | nsframework/framework_unified/client/NS_Logger/src/ns_logger.cpp | 2260 |
1 files changed, 2260 insertions, 0 deletions
diff --git a/nsframework/framework_unified/client/NS_Logger/src/ns_logger.cpp b/nsframework/framework_unified/client/NS_Logger/src/ns_logger.cpp new file mode 100644 index 00000000..94f775ce --- /dev/null +++ b/nsframework/framework_unified/client/NS_Logger/src/ns_logger.cpp @@ -0,0 +1,2260 @@ +/* + * @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_NSLogger +/// \brief +/// +/// Frameworkunified Framework Handlers Logging to log services. +/////////////////////////////////////////////////////////////////////////////// +#include <unistd.h> +#include <errno.h> +#include <string.h> +#include <stdlib.h> +#include <stdio.h> +#include <sys/timeb.h> +#include <time.h> +#include <sys/syscall.h> +#include <sys/prctl.h> +#include <syslog.h> +#include <boost/algorithm/string.hpp> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <aglpath.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <netinet/ip.h> +#include <arpa/inet.h> + +#include <native_service/ns_message_center_if.h> +#include <native_service/ns_plogger_if.h> +#include <native_service/ns_ringbuffer.h> +#include <native_service/ns_config_parser_if.h> +#include <native_service/ns_logger_if.h> +#include <native_service/ns_eventlogger.h> +#include <native_service/cl_lockid.h> + +#ifdef AGL_STUB +#include <other_service/strlcat.h> +#include <other_service/strlcpy.h> +#include <other_service/PosixBasedOS001ClockCycleApi.h> +#include "frameworkunified_stub.h" +#else +#include <sys/neutrino.h> +#include <sys/trace.h> // trace_nlogf +#include <sys/slog.h> +#include <sys/slogcodes.h> +#include <sys/syspage.h> +#endif + +#include <map> +#include <vector> +#include <sstream> +#include <utility> +#include <string> + +#include "ns_logger_internal.h" +#include "ns_msg_queue.h" +#include "mqueue.h" + +static HANDLE g_hSSEventLogQ = INVALID_HANDLE; +#ifndef AGL_STUB +static HANDLE g_hNSplogMsgQ = INVALID_HANDLE; +#endif +static HANDLE g_hNSSysEventLogQ = INVALID_HANDLE; +static __thread CHAR tls_strProcessName[MAX_NAME_SIZE_APP]; +static __thread pid_t tid = 0; +static UI_32 g_msgcounter = 0; +static FRAMEWORKUNIFIEDLOGPARAM g_LocalFrameworkunifiedLogParams; +static UI_32 syslogopened; +static int shm_fd = -1; +static const unsigned int default_log_cfgtbl[] = { + // realTimeLog + FRAMEWORKUNIFIEDLOG_REALTIMELOG_MODE_OFF, + // flagIdNum + 1, + // logLevel + FRAMEWORKUNIFIEDLOG_FLAG_MODE_RELEASE, +}; +static void *shm_pmap = reinterpret_cast<void *>(const_cast<unsigned int*>(default_log_cfgtbl)); +#define EXE_STR_LEN 64 +static char exe_link_path[EXE_STR_LEN] = {0}; + +/// For PLog +#define PLOG_GAP_FILE "/dev/shmem/Plog.gap" +#define MAX_GAP_BUFFER_LEN 80 +#define MAX_PLOG_STRING_SIZE 1024 +#define MAX_TIME_FORMATSTR_LEN 3 +#define RETRY_COUNT 5 +FRAMEWORKUNIFIEDLOGPPARAM g_FrameworkunifiedLogPParams = {FALSE, EPLOG_TIME_FORMAT_USEC, 0, EPLOG_MSGQ}; // default values for PLog +FRAMEWORKUNIFIEDLOGSYSEVENTPARAM g_FrameworkunifiedLogSysEventParams = {FALSE}; // default values for System event log + +#define ZONEMASK_MAX BITS_IN_TZONE // ((UI_32)(BITS_IN_TZONE * TZONE_COUNT)) + +#define FRAMEWORKUNIFIEDLOG_DEFAULT_FLAG_ID (0) +#define FRAMEWORKUNIFIEDLOG_CONFIG__CWORD84__FN "/usr/agl/conf/BS/ns/framework_unified/rodata/ns_logger_frameworkunifiedlog__CWORD84_.cfg" +#define FRAMEWORKUNIFIEDLOG_CONFIG__CWORD84__TMP "ns_logger_frameworkunifiedlog__CWORD84_.tmp" +#define FRAMEWORKUNIFIEDLOG_CONFIG__CWORD84__NV "ns_logger_frameworkunifiedlog__CWORD84_.cfg" + +#define FRAMEWORKUNIFIEDLOG_CONFIG_NV "/nv/BS/ns/framework_unified/rwdata/" + +#define FRAMEWORKUNIFIEDLOG_CONFIG_TMP_NV "ns_logger_frameworkunifiedlog_tmp.cfg" +#ifndef TN_LOGGERRTIME +#define TN_LOGGERRTIME "LoggerRtime" +#define PR_LOGGERRTIME_S PR_TSS_S +#define PR_LOGGERRTIME PR_TSS +#endif // TN_LOGGERRTIME +#define USB_REALTIME_MSGMAX 256 +#define USB_REALTIME_SIZMAX 4096 +#define USB_REALTIME_QNAME "/PlRtLogger" +#define USB_REALTIME_RTRYMAX 10 +static mqd_t g_qid = (mqd_t)(-1); + +unsigned int g_FlagIdNum; +std::vector<std::string> g_flag_name; + +typedef struct { + CNSRingBuffer *ring_buffer; + std::string file_name; + UI_32 size; + BOOL force_output; + + BOOL real_time_log; +} FrameworkunifiedLogMapTbl; + +typedef struct { + TFrameworkunifiedZone zone; + FrameworkunifiedLogMapTbl info; +} FrameworkunifiedLogTbl; + +typedef std::map<TFrameworkunifiedZone, FrameworkunifiedLogMapTbl> TFrameworkunifiedLogMap; +static TFrameworkunifiedLogMap g_FrameworkunifiedLogMap; +static TFrameworkunifiedLogMap g_FrameworkunifiedLogFlagMap; +static UI_32 g_FrameworkunifiedLogFlagId = FRAMEWORKUNIFIEDLOG_DEFAULT_FLAG_ID; + +static bool g_FrameworkunifiedLogFlagRealTimeLog = TRUE; +pthread_mutex_t FrameworkunifiedLogMtx = PTHREAD_MUTEX_INITIALIZER; + +#ifdef ENABLE_DEBUG_SYSLOG // for FRAMEWORKUNIFIED_SET_ZONES() error +#define DEB_SYSLOG(fmt, ...) {openlog(0, LOG_PID, LOG_USER); \ + syslog(LOG_ERR, "[FRAMEWORKUNIFIEDLOG][ERR]EXE_LINK_PATH(%s)[%s:L%d] " fmt, exe_link_path, \ + __FUNCTION__, __LINE__, ## __VA_ARGS__); \ + closelog();} +#else +#define DEB_SYSLOG(fmt, ...) +#endif + +static UI_32 +GetFrameworkunifiedLogRealtimeUartOutput(CNSConfigReader *cfg_reader) { + if (cfg_reader == NULL) { + return -1; + } + + std::string output_str = cfg_reader->GetString("REALTIME_LOG.Output"); // LCOV_EXCL_BR_LINE 11:expect branch + + if (output_str.compare("UART") == 0) { + return FRAMEWORKUNIFIEDLOG_REALTIMELOG_MODE_UART; + } else if (output_str.compare("USB") == 0) { + return FRAMEWORKUNIFIEDLOG_REALTIMELOG_MODE_USB; + } else { + return FRAMEWORKUNIFIEDLOG_REALTIMELOG_MODE_OFF; + } +} + +static EFrameworkunifiedStatus +GetFrameworkunifiedLogZoneFileInfo(CNSConfigReader *cfg_reader, std::string &name, // NOLINT (readability/nolint) + FrameworkunifiedLogMapTbl &tbl, UI_32 &zone) { // NOLINT (readability/nolint) + std::string zone_key = name; + zone_key.append(".Zone"); + std::string zone_filename_key = name; // LCOV_EXCL_BR_LINE 11:expect branch + zone_filename_key.append(".FileName"); + std::string zone_filesize_key = name; // LCOV_EXCL_BR_LINE 11:expect branch + zone_filesize_key.append(".FileSizeMax"); + std::string zone_force_output_key = name; // LCOV_EXCL_BR_LINE 11:expect branch + zone_force_output_key.append(".ForceOutput"); + + if (cfg_reader == NULL) { + return eFrameworkunifiedStatusNullPointer; + } + + tbl.ring_buffer = NULL; + tbl.file_name = cfg_reader->GetString(zone_filename_key); + tbl.size = static_cast<UI_32>(cfg_reader->GetInt(zone_filesize_key)); + tbl.force_output + = (cfg_reader->GetString(zone_force_output_key) == "True") ? TRUE : FALSE; + + tbl.real_time_log = TRUE; + zone = ZONEMASK(static_cast<UI_32>(cfg_reader->GetInt(zone_key))); + return eFrameworkunifiedStatusOK; +} + +static EFrameworkunifiedStatus +GetFrameworkunifiedLogFlagFileInfo(CNSConfigReader *cfg_reader, std::string &name, // NOLINT (readability/nolint) + FrameworkunifiedLogMapTbl &tbl, UI_32 &loglevel) { // NOLINT (readability/nolint) + std::string flag_loglevel_key = name; + flag_loglevel_key.append(".LogLevel"); + std::string flag_filename_key = name; // LCOV_EXCL_BR_LINE 11:expect branch + flag_filename_key.append(".FileName"); + std::string flag_filesize_key = name; // LCOV_EXCL_BR_LINE 11:expect branch + flag_filesize_key.append(".FileSizeMax"); + + std::string flag_real_time_log_key = name; + flag_real_time_log_key.append(".Realtimelog"); + + if (cfg_reader == NULL) { + return eFrameworkunifiedStatusNullPointer; + } + + tbl.ring_buffer = NULL; + tbl.file_name = cfg_reader->GetString(flag_filename_key); // LCOV_EXCL_BR_LINE 11:expect branch + tbl.size = static_cast<UI_32>(cfg_reader->GetInt(flag_filesize_key)); // LCOV_EXCL_BR_LINE 11:expect branch + tbl.force_output = FALSE; + + tbl.real_time_log + = (cfg_reader->GetString(flag_real_time_log_key) == "False") ? FALSE : TRUE; + + + std::string loglevel_str = cfg_reader->GetString(flag_loglevel_key); // LCOV_EXCL_BR_LINE 11:expect branch + + if (loglevel_str.compare("Debug") == 0) { + loglevel = FRAMEWORKUNIFIEDLOG_FLAG_MODE_DEBUG; + } else { + loglevel = FRAMEWORKUNIFIEDLOG_FLAG_MODE_RELEASE; + } + + if ((tbl.file_name.empty()) || (tbl.size == 0)) { + return eFrameworkunifiedStatusFail; + } + return eFrameworkunifiedStatusOK; +} + +static VOID +GetFrameworkunifiedLogList(CNSConfigReader *cfg_reader, std::vector<std::string> &list, // NOLINT (readability/nolint) + std::string req_list) { + if (cfg_reader == NULL) { + return; + } + + std::string list_str = cfg_reader->GetString(req_list); + if (!list_str.empty()) { + try { + boost::algorithm::split(list, list_str, boost::is_any_of(", ")); + } + /* + * @todo + * Even if throw is executed by the process called by 'try', it cannot be captured by catch(). + */ + catch (...) { + fprintf(stderr, "occured exception handling by boost::algorithm::split in ns_logger\n"); + } + } +} + +static BOOL +CheckMatchFrameworkunifiedLogFlagMap(TFrameworkunifiedLogMap &map, FrameworkunifiedLogMapTbl &check_tbl, // NOLINT (readability/nolint) + FrameworkunifiedLogMapTbl &out_tbl) { // NOLINT (readability/nolint) + TFrameworkunifiedLogMap::iterator itr; + for (itr = map.begin(); itr != map.end(); itr++) { + if (itr->second.file_name.compare(check_tbl.file_name) == 0) { + out_tbl = itr->second; + return TRUE; + } + } + return FALSE; +} + +static BOOL +IsDefinedFrameworkunifiedLogFlag(CNSConfigReader *cfg_reader, std::string &flag_name, // NOLINT (readability/nolint) + std::string &exe_name) { // NOLINT (readability/nolint) + UI_32 cnt = 1; + size_t pos1; + + if (cfg_reader == NULL) { + return FALSE; + } + + while (1) { + std::string service_key = flag_name; + std::ostringstream service_num; // LCOV_EXCL_BR_LINE 11:expect branch + service_num << ".Service" << cnt; + service_key.append(service_num.str()); + std::string service_name = cfg_reader->GetString(service_key); + if (service_name.empty()) { + break; + } + pos1 = exe_name.find(service_name); + if ((pos1 != std::string::npos) + && (exe_name.length() - pos1) == service_name.length()) { + return TRUE; + } + cnt++; + } + return FALSE; +} + +static VOID +CreateFrameworkunifiedLogFileTbl(CNSConfigReader *cfg_reader, std::string &exe_str, // NOLINT (readability/nolint) + int *realTimeLog, int **logLevelArray) { + int *logLevel; + + std::vector<std::string> zone_vector; + GetFrameworkunifiedLogList(cfg_reader, zone_vector, "ZONE_LIST.List"); + for (UI_32 i = 0; i < zone_vector.size(); i++) { + FrameworkunifiedLogMapTbl zone_tbl; + UI_32 zone; + if (GetFrameworkunifiedLogZoneFileInfo(cfg_reader, zone_vector.at(i), zone_tbl, zone) + == eFrameworkunifiedStatusOK) { + g_FrameworkunifiedLogMap.insert(std::make_pair(zone, zone_tbl)); + } + } + + *realTimeLog = static_cast<int>(GetFrameworkunifiedLogRealtimeUartOutput(cfg_reader)); + + FrameworkunifiedLogMapTbl default_tbl; + UI_32 default_id = FRAMEWORKUNIFIEDLOG_DEFAULT_FLAG_ID; + std::string default_flag = "FLAG_DEFAULT"; // LCOV_EXCL_BR_LINE 11:expect branch + UI_32 default_loglevel; + if (GetFrameworkunifiedLogFlagFileInfo(cfg_reader, default_flag, default_tbl, default_loglevel) + != eFrameworkunifiedStatusOK) { + fprintf(stderr, "<WARNING>FRAMEWORKUNIFIEDLOG[%s:L%d]FLAG_DEFAULT is not definition into ns_logger_frameworkunifiedlog.cfg.\n", + __FUNCTION__, __LINE__); + + DEB_SYSLOG("<WARNING>FLAG_DEFAULT is not definition into ns_logger_frameworkunifiedlog.cfg.)"); + default_tbl.ring_buffer = NULL; + default_tbl.file_name = "frameworkunified_debug.log"; + default_tbl.size = 100; // 100bytes + + default_tbl.real_time_log = TRUE; + } + std::vector<std::string> flag_vector; + UI_32 flag_id = FRAMEWORKUNIFIEDLOG_DEFAULT_FLAG_ID + 1; + GetFrameworkunifiedLogList(cfg_reader, flag_vector, "FLAG_LIST.List"); // LCOV_EXCL_BR_LINE 11:expect branch + if (g_FlagIdNum != (flag_vector.size() + 1)) { + if (!g_FrameworkunifiedLogFlagMap.empty()) { + TFrameworkunifiedLogMap::iterator delitr; + unsigned int delflag_id; + for (delflag_id = 0; delflag_id < g_FlagIdNum; delflag_id++) { + delitr = g_FrameworkunifiedLogFlagMap.find(delflag_id); + if (delitr->second.ring_buffer != NULL) { + delete delitr->second.ring_buffer; + delitr->second.ring_buffer = NULL; + } + } + g_FrameworkunifiedLogFlagMap.clear(); + if (!g_flag_name.empty()) { + g_flag_name.clear(); + } + } + g_FlagIdNum = static_cast<unsigned int>(flag_vector.size() + 1); // +1: [Add Default Flag] + g_flag_name.push_back(default_flag); // LCOV_EXCL_BR_LINE 11:expect branch + g_FrameworkunifiedLogFlagMap.insert(std::make_pair(default_id, default_tbl)); // LCOV_EXCL_BR_LINE 11:expect branch + } + logLevel = reinterpret_cast<int *>(malloc(sizeof(int) * g_FlagIdNum)); + logLevel[0] = default_loglevel; + + for (UI_32 i = 0; i < flag_vector.size(); i++) { + FrameworkunifiedLogMapTbl flag_tbl; + UI_32 loglevel; + if (GetFrameworkunifiedLogFlagFileInfo(cfg_reader, flag_vector.at(i), flag_tbl, loglevel) + == eFrameworkunifiedStatusOK) { + FrameworkunifiedLogMapTbl check_result_tbl; + if (CheckMatchFrameworkunifiedLogFlagMap(g_FrameworkunifiedLogFlagMap, flag_tbl, check_result_tbl) + == TRUE) { + flag_tbl.file_name = check_result_tbl.file_name; + flag_tbl.size = check_result_tbl.size; + } + if (g_FrameworkunifiedLogFlagMap.find(flag_id) == g_FrameworkunifiedLogFlagMap.end()) { + if (IsDefinedFrameworkunifiedLogFlag(cfg_reader, flag_vector.at(i), exe_str) + == TRUE) { + g_FrameworkunifiedLogFlagId = flag_id; + + g_FrameworkunifiedLogFlagRealTimeLog = flag_tbl.real_time_log; + } + g_flag_name.push_back(flag_vector.at(i)); + g_FrameworkunifiedLogFlagMap.insert(std::make_pair(flag_id, flag_tbl)); + } + } + logLevel[flag_id] = loglevel; + flag_id++; + } + *logLevelArray = logLevel; +} + +static VOID +GetFrameworkunifiedLogRingBuffer(const UI_16 zone, CNSRingBuffer **ring_buf) { + TFrameworkunifiedLogMap::iterator itr = g_FrameworkunifiedLogMap.find(zone); + + if (ring_buf == NULL) { + return; + } + + if (itr == g_FrameworkunifiedLogMap.end()) { + itr = g_FrameworkunifiedLogFlagMap.find(g_FrameworkunifiedLogFlagId); + if (itr == g_FrameworkunifiedLogFlagMap.end()) { + // ASSERT + *ring_buf = NULL; + return; + } + } + + pthread_mutex_lock(&FrameworkunifiedLogMtx); + + if (itr->second.ring_buffer == NULL) { + std::string file_path; + int index; + + file_path = FRAMEWORKUNIFIEDLOG_RAMDISC_PATH; + file_path.append("/"); // LCOV_EXCL_BR_LINE 11:expect branch + file_path.append(itr->second.file_name); + + index = NSLogGetFrameworkunifiedlogIndex(file_path.c_str()); + itr->second.ring_buffer = new(std::nothrow) CNSRingBuffer(file_path, itr->second.size, + index + LOCK_NSLOG_ACCES_IF_1); // LCOV_EXCL_BR_LINE 11:expect branch + if (itr->second.ring_buffer != NULL) { + itr->second.ring_buffer->Open(); + } + } + pthread_mutex_unlock(&FrameworkunifiedLogMtx); + + *ring_buf = itr->second.ring_buffer; +} + +static int +MapShmInfo(int flagId) { + int size; + void *pmap; + + if (shm_fd != -1) { + return -1; + } + shm_fd = shm_open(FRAMEWORKUNIFIEDLOG_SHARED_MEM_NAME, O_RDONLY, S_IRWXU | S_IRWXO); + if (shm_fd == -1) { + + DEB_SYSLOG("shm_open error errno:%d", errno); + return -1; + } + size = static_cast<int>(sizeof(int) * 2); // realTimeLog + flagIdNum + size += static_cast<int>(sizeof(int) * (flagId + 1)); // g_FrameworkunifiedLogFlagId + DefaultFlagId + + pmap = reinterpret_cast<int *>(mmap(NULL, size, PROT_READ, MAP_SHARED, shm_fd, 0)); + if (pmap == MAP_FAILED) { + + DEB_SYSLOG("mmap error errno:%d", errno); + close(shm_fd); + shm_fd = -1; + return -1; + } + shm_pmap = pmap; + + return 0; +} + +static inline void +GetShmInfo(int flagId, int *realTimeLog, int *logLevel) { + volatile ssize_t *p; + + if ((realTimeLog == NULL) || (logLevel == NULL)) { + return; + } + + p = static_cast<ssize_t *>(shm_pmap); + *realTimeLog = static_cast<int>(p[0]); + p += 2; + *logLevel = static_cast<int>(p[flagId]); +} + +static BOOL +IsExistFrameworkunifiedLogCfgShmem(void) { + if (shm_pmap == reinterpret_cast<void *>(const_cast<unsigned int*>(default_log_cfgtbl))) { + return FALSE; + } + return TRUE; +} + +static BOOL +NsLogIsZonePrintEnable(const UI_16 zone, UI_8 *mode) { + int l_realTimeLog = FRAMEWORKUNIFIEDLOG_REALTIMELOG_MODE_OFF; + int l_loglevel = FRAMEWORKUNIFIEDLOG_FLAG_MODE_RELEASE; + + if (mode == NULL) { + return FALSE; + } + + GetShmInfo(g_FrameworkunifiedLogFlagId, &l_realTimeLog, &l_loglevel); + *mode = static_cast<UI_8>(l_realTimeLog); + if (l_realTimeLog == FRAMEWORKUNIFIEDLOG_REALTIMELOG_MODE_OFF) { + return FALSE; + } + + if ((ZONEMASK(96) <= (TFrameworkunifiedZone)zone) + && ((TFrameworkunifiedZone)zone <= ZONEMASK(127))) { + return FALSE; + } + + + if (g_FrameworkunifiedLogFlagRealTimeLog == FALSE) { + return FALSE; + } + + return TRUE; +} + + +static int +copyFrameworkunifiedLogCfgFile(const char *l_cSrcPath, const char *l_cDestPath) { + int fd_in = -1; + int fd_ot = -1; + char l_buf[8*1024]; + ssize_t l_nrd, l_nwr; + + fd_in = open(l_cSrcPath, O_RDONLY | O_CLOEXEC); + if (fd_in == -1) { + return -1; + } + + fd_ot = open(l_cDestPath, O_WRONLY | O_CREAT | O_CLOEXEC, 0640); + if (fd_ot == -1) { + close(fd_in); + return -1; + } + + while (1) { + l_nrd = read(fd_in, l_buf, sizeof(l_buf)); + if (l_nrd == 0) { + break; + } + if (l_nrd < 0) { + close(fd_in); + close(fd_ot); + return -1; + } + + l_nwr = write(fd_ot, l_buf, l_nrd); + if (l_nwr < 0) { + close(fd_in); + close(fd_ot); + return -1; + } + } + + if (fsync(fd_ot) != 0) { + close(fd_in); + close(fd_ot); + return -1; + } + + close(fd_in); + close(fd_ot); + + return 0; +} + + +static VOID +copyFrameworkunifiedLogCfgFileToNv(void) { + int fd_in = -1; + int fd_ot = -1; + int fd_dr = -1; + char c[1]; + ssize_t len; + + // LCOV_EXCL_BR_START 11:Excluded due to gcov constraints (others) + std::string config_dirpath = FRAMEWORKUNIFIEDLOG_CONFIG_NV; + std::string config_tempname = FRAMEWORKUNIFIEDLOG_CONFIG_NV; + std::string config_filename = FRAMEWORKUNIFIEDLOG_CONFIG_NV; + fd_in = open(FRAMEWORKUNIFIEDLOG_CONFIG__CWORD84__FN, O_RDONLY); + config_tempname.append(FRAMEWORKUNIFIEDLOG_CONFIG__CWORD84__TMP); + config_filename.append(FRAMEWORKUNIFIEDLOG_CONFIG__CWORD84__NV); + // LCOV_EXCL_BR_STOP 11:Excluded due to gcov constraints (others) + + if (fd_in == -1) { + return; + } + + unlink(config_tempname.c_str()); + + fd_ot = open(config_tempname.c_str(), O_WRONLY | O_CREAT, 0640); // LCOV_EXCL_BR_LINE 11:expect branch + if (fd_ot == -1) { + DEB_SYSLOG("open error errno:%d", errno); + close(fd_in); // LCOV_EXCL_BR_LINE 11:expect branch + return; + } + + while (1) { + len = read(fd_in, c, sizeof(c)); + if (len == 0) { + break; + } + if (len < 0) { + close(fd_in); + close(fd_ot); + return; + } + len = write(fd_ot, c, sizeof(c)); + if (len < 0) { + close(fd_in); + close(fd_ot); + return; + } + } + + if (fsync(fd_ot) != 0) { + close(fd_in); + close(fd_ot); + return; + } + + close(fd_in); + close(fd_ot); + + if (rename(config_tempname.c_str(), config_filename.c_str()) != 0) { + + DEB_SYSLOG("rename error errno:%d", errno); + return; + } + + fd_dr = open(config_dirpath.c_str(), O_RDONLY); + if (fd_dr == -1) { + + DEB_SYSLOG("mmap error errno:%d", errno); + return; + } + + fsync(fd_dr); + + close(fd_dr); +} + +#define WTYPE_NORMAL 0 +#define WTYPE_RTIMELOG 1 +static int +WriteSharedMem(int flag, int realTimeLog, unsigned int flagIdNum, int *logLevelArray) { + int fd; + ssize_t *pp; + volatile ssize_t *p; + int size; + + if ((flag == WTYPE_NORMAL) + && (logLevelArray == NULL)) { + return -1; + } + + size = static_cast<int>(sizeof(int) * 2); // realTimeLog + flagIdNum + size += static_cast<int>(sizeof(int) * flagIdNum); + + fd = shm_open(FRAMEWORKUNIFIEDLOG_SHARED_MEM_NAME, O_RDWR | O_CREAT, S_IRWXU | S_IRWXO); + if (fd == -1) { + + DEB_SYSLOG("shm_open error errno:%d", errno); + return -1; + } + + if (ftruncate(fd, size) == -1) { + + DEB_SYSLOG("ftruncate error errno:%d", errno); + close(fd); + return -1; + } + +// pp = (int *)mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); + pp = static_cast<ssize_t *>(mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)); + if (pp == MAP_FAILED) { + + DEB_SYSLOG("mmap error errno:%d", errno); + close(fd); + return -1; + } + + p = pp; + p[0] = realTimeLog; + + if (flag == WTYPE_NORMAL) { + // flagIdNum + p[1] = flagIdNum; + + // log level + p += 2; + for (unsigned int i = 0; i < flagIdNum; i++) { + *p = logLevelArray[i]; + p++; + } + } + close(fd); + munmap(pp, size); + + return 0; +} + +static int +WriteSharedMemForFlagId(int realTimeLog, unsigned int flagIdNum, int flagId, + int logLevel) { + int fd; + volatile ssize_t *p; + ssize_t *pp; + int size; + + size = static_cast<int>(sizeof(int) * 2); // realTimeLog + flagIdNum + size += static_cast<int>(sizeof(int) * flagIdNum); + + fd = shm_open(FRAMEWORKUNIFIEDLOG_SHARED_MEM_NAME, O_RDWR | O_CREAT, S_IRWXU | S_IRWXO); + if (fd == -1) { + + DEB_SYSLOG("shm_open error errno:%d", errno); + return -1; + } + + if (ftruncate(fd, size) == -1) { + + DEB_SYSLOG("ftruncate error errno:%d", errno); + close(fd); + return -1; + } + + pp = static_cast<ssize_t *>(mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)); + if (pp == MAP_FAILED) { + + DEB_SYSLOG("mmap error errno:%d", errno); + close(fd); + return -1; + } + + p = pp; + p[0] = realTimeLog; + + // flagIdNum + p[1] = flagIdNum; + + // log level + p += 2; + p[flagId] = logLevel; + + close(fd); + munmap(pp, size); + + return 0; +} + +static BOOL +IsExistFrameworkunifiedLogCfgNv(void) { + FILE *fp; + // LCOV_EXCL_BR_START 11:Excluded due to gcov constraints (others) + std::string config_filename = FRAMEWORKUNIFIEDLOG_CONFIG_NV; + config_filename.append(FRAMEWORKUNIFIEDLOG_CONFIG__CWORD84__NV); + // LCOV_EXCL_BR_STOP 11:Excluded due to gcov constraints (others) + + fp = fopen(config_filename.c_str(), "re"); + if (fp == NULL) { + return FALSE; + } + + fclose(fp); + return TRUE; +} + +static int +get_readlink_path(char *path) { + CHAR exe_path[EXE_STR_LEN]; + CHAR buf[EXE_STR_LEN]; + ssize_t len; + + if (path == NULL) { + return -1; + } + + path[0] = 0; + if (exe_link_path[0] == 0) { + pid_t pid = static_cast<pid_t>(syscall(__NR_getpid)); + sprintf(exe_path, "/proc/%d/exe", pid); // NOLINT (readability/nolint) + memset(buf, 0, sizeof(buf)); + len = readlink(exe_path, buf, (sizeof(buf) - 1)); + if (len != -1) { // LCOV_EXCL_BR_LINE 200: exe_path can not non-existent + strcpy(exe_link_path, buf); // NOLINT (readability/nolint) + } else { + // LCOV_EXCL_START 200 + AGL_ASSERT_NOT_TESTED(); + fprintf(stderr, "<WARNING>FRAMEWORKUNIFIEDLOG[%s:L%d]Can't get readlink path(%s). errno(%d)\n", __FUNCTION__, __LINE__, + exe_path, errno); + DEB_SYSLOG("<WARNING>Can't get readlink path(%s)(errno:%d)", exe_path, errno); + return 0; + // LCOV_EXCL_STOP 200 + } + } + strcpy(path, exe_link_path); // NOLINT (readability/nolint) + return 1; // OK +} + +static void +readConfig(int *realTimeLog, int **logLevelArray) { + CHAR buf[EXE_STR_LEN]; + + if (get_readlink_path(buf)) { // LCOV_EXCL_BR_LINE 200:get_readlink_path can not return false + std::string config_filename; + std::string exe_str = buf; // LCOV_EXCL_BR_LINE 11:expect branch + + // LCOV_EXCL_BR_START 11:Excluded due to gcov constraints (others) + if (IsExistFrameworkunifiedLogCfgNv()) { + config_filename = FRAMEWORKUNIFIEDLOG_CONFIG_NV; + config_filename.append(FRAMEWORKUNIFIEDLOG_CONFIG__CWORD84__NV); + } else { + config_filename = FRAMEWORKUNIFIEDLOG_CONFIG__CWORD84__FN; + } + // LCOV_EXCL_BR_STOP 11:Excluded due to gcov constraints (others) + CNSConfigReader *config_reader = new CNSConfigReader(); // LCOV_EXCL_BR_LINE 11:expect branch + if (config_reader != NULL) { // LCOV_EXCL_BR_LINE 5: new's error case + if (config_reader->Parse(config_filename) + == eFrameworkunifiedStatusOK) { + CreateFrameworkunifiedLogFileTbl(config_reader, exe_str, realTimeLog, logLevelArray); // LCOV_EXCL_BR_LINE 11:expect branch + MapShmInfo(g_FrameworkunifiedLogFlagId); // LCOV_EXCL_BR_LINE 11:expect branch + } else { + DEB_SYSLOG("Parseg error %s", config_filename.c_str()); + } + } else { + // LCOV_EXCL_START 5: new's error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + DEB_SYSLOG("new CNSConfigReader error"); + // LCOV_EXCL_STOP 5 + } + delete config_reader; // LCOV_EXCL_BR_LINE 11:expect branch1 + } else { + // LCOV_EXCL_START 5: get_readlink_path can not return false + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + DEB_SYSLOG("get_readlink_path error"); + // LCOV_EXCL_STOP 5 + } +} + +////////////////////////////////////////// +// NSLogGetFrameworkunifiedlogFileTotalNum +////////////////////////////////////////// +UI_32 +NSLogGetFrameworkunifiedlogFileTotalNum(void) { + return static_cast<UI_32>((g_FrameworkunifiedLogMap.size() + g_FrameworkunifiedLogFlagMap.size())); +} + +////////////////////////////////////////// +// NSLogGetFrameworkunifiedlogFileName +////////////////////////////////////////// +PCSTR +NSLogGetFrameworkunifiedlogFileName(UI_32 index) { + PCSTR name = NULL; + + if ((g_FrameworkunifiedLogMap.size() + g_FrameworkunifiedLogFlagMap.size()) <= index) { + return NULL; + } + + TFrameworkunifiedLogMap::iterator itr; + TFrameworkunifiedLogMap::iterator itr_end; + UI_32 cnt; + + if (index < g_FrameworkunifiedLogMap.size()) { + cnt = 0; + itr = g_FrameworkunifiedLogMap.begin(); + itr_end = g_FrameworkunifiedLogMap.end(); + } else { + cnt = static_cast<UI_32>(g_FrameworkunifiedLogMap.size()); + itr = g_FrameworkunifiedLogFlagMap.begin(); + itr_end = g_FrameworkunifiedLogFlagMap.end(); + } + + for (; itr != itr_end; itr++, cnt++) { + if (cnt == index) { + name = itr->second.file_name.c_str(); + break; + } + } + return name; +} + +////////////////////////////////////////// +// NSLogGetFrameworkunifiedlogIndex +////////////////////////////////////////// +int +NSLogGetFrameworkunifiedlogIndex(PCSTR filename) { + TFrameworkunifiedLogMap::iterator itr; + TFrameworkunifiedLogMap::iterator itr_end; + UI_32 i = 0; + /** + * @todo + * Defining a NULL for arguments results in exceptions. + */ + std::string fname = filename; + + itr = g_FrameworkunifiedLogFlagMap.begin(); + itr_end = g_FrameworkunifiedLogFlagMap.end(); + for (; itr != itr_end; itr++, i++) { + if (fname.find(itr->second.file_name) != std::string::npos) { + return i; + } + } + + itr = g_FrameworkunifiedLogMap.begin(); + itr_end = g_FrameworkunifiedLogMap.end(); + for (; itr != itr_end; itr++, i++) { + if (fname.find(itr->second.file_name) != std::string::npos) { + return i; + } + } + return 0; +} + +UI_32 +ConvertEndian(UI_32 *pvar) { + UI_32 retVal = (UI_32)0; + + if (pvar == NULL) { + return retVal; + } + + UI_32 var = *pvar; + retVal = (((var & 0xFF000000) >> 24) | + ((var & 0x00FF0000) >> 8) | + ((var & 0x0000FF00) << 8) | + ((var & 0x000000FF) << 24)); + return (retVal); +} + +static void +check_syslog_opened(void) { + if (!syslogopened) { + openlog(0, LOG_CONS | LOG_NDELAY | LOG_PID, LOG_USER); + syslogopened = 1; + } +} + +static time_t +tick_msec_get(void) { + struct timespec tp; + + if (clock_gettime(CLOCK_MONOTONIC, &tp) != 0) { // LCOV_EXCL_BR_LINE 5: clock_gettime's error case + // LCOV_EXCL_START 5: clock_gettime's error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + return 0; /* NG */ + // LCOV_EXCL_STOP 5 + } + return tp.tv_sec * 1000 + tp.tv_nsec / 1000000; +} + +static inline int +num2string(PSTR buf, int digits, UI_32 num) { + PSTR p = NULL; + char c; + + switch (digits) { + case 5: + p = buf; + if (num >= 100000) { + *p++ = '0'; + *p++ = '0'; + *p++ = '0'; + *p++ = '0'; + *p = '0'; + break; + } + c = static_cast<char>(num / 10000); + *p++ = static_cast<char>(c + '0'); + num = num - (c * 10000); + c = static_cast<char>(num / 1000); + *p++ = static_cast<char>(c + '0'); + num = num - (c * 1000); + case 3: + if (p == NULL) { + p = buf; + } + if (num >= 1000) { + *p++ = '0'; + *p++ = '0'; + *p = '0'; + break; + } + c = static_cast<char>(num / 100); + *p++ = static_cast<char>(c + '0'); + num = num - (c * 100); + case 2: + if (p == NULL) { + p = buf; + } + if (num >= 100) { + *p++ = '0'; + *p = '0'; + break; + } + c = static_cast<char>(num / 10); + *p++ = static_cast<char>(c + '0'); + *p = static_cast<char>(num - (c * 10) + '0'); + break; + default: { + int dig = 1; + int n = num; + p = buf; + while (n >= 10) { + n /= 10; + dig *= 10; + } + while (dig > 1) { + c = static_cast<char>(num / dig); + *p++ = static_cast<char>(c + '0'); + num = num - (c * dig); + dig /= 10; + } + *p = static_cast<char>(num + '0'); + } + break; + } + return static_cast<int>(p - buf + 1); +} + +static void +_GetTimeString2(PSTR format) { + time_t tick; + UI_32 hh, mm, ss, ms; + + // "%02d:%02d:%02d.%03d/" + tick = tick_msec_get(); + + ms = static_cast<UI_32>(tick % 1000); + format[8] = '.'; + num2string(&format[9], 3, ms); + format[12] = '/'; + + tick /= 1000; + ss = static_cast<UI_32>(tick % 60); + format[5] = ':'; + num2string(&format[6], 2, ss); + + tick /= 60; + mm = static_cast<UI_32>(tick % 60); + format[2] = ':'; + num2string(&format[3], 2, mm); + + tick /= 60; + hh = static_cast<UI_32>(tick); + num2string(&format[0], 2, hh); +} + +// LCOV_EXCL_START 8: dead code +void +_GetTimeString(PSTR format, UI_16 length) { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 8: dead code + time_t tick; + UI_32 hh, mm, ss, ms; + + tick = tick_msec_get(); + ms = static_cast<UI_32>(tick % 1000); + tick /= 1000; + ss = static_cast<UI_32>(tick % 60); + tick /= 60; + mm = static_cast<UI_32>(tick % 60); + tick /= 60; + hh = static_cast<UI_32>(tick); + + snprintf(format, (length - 1), "%02d:%02d:%02d.%03d/", hh, mm, ss, ms); +} +// LCOV_EXCL_STOP 8 + +static UI_64 +ClockCyclesToMs(void) { + return ClockCycle() / 1000; +} + +static CHAR * +_in_NsLog_part1(const UI_16 p_lLine_i, const UI_16 f_uiZoneIndex, + PCSTR p_pstrClassName_i, CHAR *format) { + CHAR t_name[16]; // thread name (not more than 15 characters) + int len; + CHAR *p = format; + + if (format == NULL) { + return NULL; + } + + // fixed format : "%s%ld/%d/%s/%05d/%s/%d/=%s\r\n" + // time_string + _GetTimeString2(p); + p += 13; + + // g_msgcounter + g_msgcounter++; + len = num2string(p, 0, g_msgcounter); + p += len; + *p++ = '/'; + + // f_uiZoneIndex + len = num2string(p, 0, f_uiZoneIndex); + p += len; + *p++ = '/'; + + // Check whether thread name has previously been set + t_name[0] = 0; + if (tls_strProcessName[0] != 0) { + tls_strProcessName[sizeof(t_name) - 1] = '\0'; + strcpy(t_name, tls_strProcessName); // NOLINT (readability/nolint) + } else { + if (prctl(PR_GET_NAME, t_name) != 0) { + strcpy(t_name, "UNKNOWN"); // NOLINT (readability/nolint) + } + NsLogSetProcessName(t_name); + } + + // t_name + strcpy(p, t_name); // NOLINT (readability/nolint) + p += strlen(t_name); + *p++ = '/'; + + // t_id + if (tid == 0) { + tid = static_cast<pid_t>(syscall(__NR_gettid)); + } + len = num2string(p, 5, tid); + p += len; + *p++ = '/'; + + // p_pstrClassName_i + if (p_pstrClassName_i) { + strcpy(p, p_pstrClassName_i); // NOLINT (readability/nolint) + } else { + strcpy(p, "(null)"); // NOLINT (readability/nolint) + } + p += strlen(p); + *p++ = '/'; + + // p_lLine_i + len = num2string(p, 0, p_lLine_i); + p += len; + *p++ = '/'; + *p++ = '='; + + return p; +} + +static void +_in_NsLog_part2(const UI_16 f_uiZoneIndex, CHAR *p, CHAR *format) { + UI_32 l_uiLength; + + if (p == NULL) { + return; + } + + *p++ = '\r'; + *p++ = '\n'; + *p = '\0'; + + if (format == NULL) { + return; + } + + l_uiLength = static_cast<UI_32>(p - format); + + // Write log message + if (l_uiLength > 0) { + UI_8 l_realTimeLog = FRAMEWORKUNIFIEDLOG_REALTIMELOG_MODE_OFF; + BOOL IsZonePrintEnable = NsLogIsZonePrintEnable(f_uiZoneIndex, &l_realTimeLog); + if (l_realTimeLog == FRAMEWORKUNIFIEDLOG_REALTIMELOG_MODE_FREEZE) { + if (g_qid != (mqd_t)(-1)) { + mq_close(g_qid); + g_qid = (mqd_t)(-1); + } + return; + } + if (g_LocalFrameworkunifiedLogParams.uiLogOptions & LPRINT) { + ssize_t l_writtenbyte; + std::string usb_realtime_filename; + std::string ownAdrr; + std::string writeAdrr; + if (IsZonePrintEnable == TRUE) { + switch (l_realTimeLog) { + case FRAMEWORKUNIFIEDLOG_REALTIMELOG_MODE_OFF: + // Nothing + break; + case FRAMEWORKUNIFIEDLOG_REALTIMELOG_MODE_UART: + // Write console + fwrite(format, 1, l_uiLength, stdout); + break; + case FRAMEWORKUNIFIEDLOG_REALTIMELOG_MODE_USB: + if (g_qid == (mqd_t)(-1)) { + struct mq_attr qattr; + + qattr.mq_flags = 0; + qattr.mq_maxmsg = USB_REALTIME_MSGMAX; + qattr.mq_msgsize = USB_REALTIME_SIZMAX; + qattr.mq_curmsgs = 0; + if ((g_qid = mq_open(USB_REALTIME_QNAME, O_WRONLY | O_CREAT, 0666, &qattr)) == (mqd_t)(-1)) { + fprintf(stderr, "Failed to create Message Queue %s, errno=%d\n", USB_REALTIME_QNAME, errno); + break; + } + } + l_writtenbyte = mq_send(g_qid, format, l_uiLength, 1); + if (l_writtenbyte == -1) { + fprintf(stderr, "mq_send ERROR, errno=%d\n", errno); + mq_close(g_qid); + g_qid = (mqd_t)(-1); + } + break; + case FRAMEWORKUNIFIEDLOG_REALTIMELOG_MODE_USB_DISABLE: + if (g_qid != (mqd_t)(-1)) { + mq_close(g_qid); + g_qid = (mqd_t)(-1); + } + break; + default: + break; + } + } + } + if (g_LocalFrameworkunifiedLogParams.uiLogOptions & LSLOGGER) { + check_syslog_opened(); + syslog(LOG_ERR, "%s", format); + } + + { + CNSRingBuffer *ring_buffer = NULL; + GetFrameworkunifiedLogRingBuffer(f_uiZoneIndex, &ring_buffer); + + if (ring_buffer != NULL) { + if (ring_buffer->IsOpen()) { + ring_buffer->Write(format, l_uiLength); + } + } + } + } +} + +void +NsLogTime(const UI_16 f_uiZoneIndex, PCSTR lpszFormat) { + CHAR format[MAX_QUEUE_MSG_SIZE]; + CHAR *p = format; + CHAR *q = reinterpret_cast<CHAR *>(const_cast<char *>(lpszFormat)); + int i; + + // fixed format : "%s/=%s\r\n" + // time_string + _GetTimeString2(p); + p += 13; + *p++ = '='; + + /** + * @todo + * Defining a NULL for the lpszFormat causes a segmentation fault. + */ + for (i = 0; *q && i < MAX_QUEUE_MSG_SIZE - (p - format) - 3; i++) { // '3': '\r''\n''\0' + *p++ = *q++; + } + _in_NsLog_part2(f_uiZoneIndex, p, format); +} + +void +NsLogData(const UI_16 f_uiZoneIndex, PCSTR data, UI_32 size) { + int l_realTimeLog; + int l_logLevel; + + GetShmInfo(g_FrameworkunifiedLogFlagId, &l_realTimeLog, &l_logLevel); + if (l_realTimeLog == FRAMEWORKUNIFIEDLOG_REALTIMELOG_MODE_FREEZE) { + return; + } + + if (size > 0) { + CNSRingBuffer *ring_buffer = NULL; + GetFrameworkunifiedLogRingBuffer(f_uiZoneIndex, &ring_buffer); // LCOV_EXCL_BR_LINE 11:expect branch + if (ring_buffer != NULL) { + if (ring_buffer->IsOpen()) { + ring_buffer->Write(data, size); + } + } + } +} + +void +NsLog0(const UI_16 p_lLine_i, // Line number where message was generated + const UI_16 f_uiZoneIndex, + PCSTR p_pstrClassName_i, + PCSTR lpszFormat) { + CHAR format[MAX_QUEUE_MSG_SIZE]; + CHAR *p; + CHAR *q = reinterpret_cast<CHAR *>(const_cast<char *>(lpszFormat)); + int i; + + p = _in_NsLog_part1(p_lLine_i, f_uiZoneIndex, p_pstrClassName_i, format); + /** + * @todo + * Setting p_pstrClassName_i to NULL results in a segmentation fault. + */ + for (i = 0; *q && i < MAX_QUEUE_MSG_SIZE - (p - format) - 3; i++) { // '3': '\r''\n''\0' + *p++ = *q++; + } + _in_NsLog_part2(f_uiZoneIndex, p, format); +} + +void +NsLog(const UI_16 p_lLine_i, // Line number where message was generated + const UI_16 f_uiZoneIndex, + PCSTR p_pstrClassName_i, + PCSTR lpszFormat, + ...) { + va_list argList; + CHAR format[MAX_QUEUE_MSG_SIZE]; + CHAR *p; + int num; + int size; + + va_start(argList, lpszFormat); + + p = _in_NsLog_part1(p_lLine_i, f_uiZoneIndex, p_pstrClassName_i, format); + size = static_cast<int>(MAX_QUEUE_MSG_SIZE - (p - format) - 3); + num = vsnprintf(p, size, lpszFormat, argList); + if (num >= size) { + num = size - 1; + } else if (num < 0) { + num = 0; + } + p += num; + _in_NsLog_part2(f_uiZoneIndex, p, format); + + va_end(argList); +} + +void +NsLogSetFrameworkunifiedLogParams(FRAMEWORKUNIFIEDLOGPARAM *p_FrameworkunifiedLogParams) { + int l_realTimeLog = 0; + int *l_logLevelArray = NULL; + CHAR buf[EXE_STR_LEN]; + + if (p_FrameworkunifiedLogParams == NULL) { + return; + } + + get_readlink_path(buf); + if (g_flag_name.empty()) { // LCOV_EXCL_BR_LINE 200:get_readlink_path can not return false + std::string config_filename; + CHAR buf[EXE_STR_LEN]; + + if (IsExistFrameworkunifiedLogCfgNv()) { // LCOV_EXCL_BR_LINE 11:Excluded due to gcov constraints (others) + config_filename = FRAMEWORKUNIFIEDLOG_CONFIG_NV; // LCOV_EXCL_BR_LINE 11:Excluded due to gcov constraints (others) + config_filename.append(FRAMEWORKUNIFIEDLOG_CONFIG__CWORD84__NV); // LCOV_EXCL_BR_LINE 11:Excluded due to gcov constraints (others) + } else { + config_filename = FRAMEWORKUNIFIEDLOG_CONFIG__CWORD84__FN; // LCOV_EXCL_BR_LINE 11:Excluded due to gcov constraints (others) + } + if (get_readlink_path(buf)) { + std::string exe_str = buf; // LCOV_EXCL_BR_LINE 11:expect branch + CNSConfigReader *config_reader = new CNSConfigReader(); // LCOV_EXCL_BR_LINE 11:expect branch + if (config_reader != NULL) { // LCOV_EXCL_BR_LINE 5: new's error case + if (config_reader->Parse(config_filename) + == eFrameworkunifiedStatusOK) { + CreateFrameworkunifiedLogFileTbl(config_reader, exe_str, &l_realTimeLog, &l_logLevelArray); // LCOV_EXCL_BR_LINE 11:expect branch + MapShmInfo(g_FrameworkunifiedLogFlagId); // LCOV_EXCL_BR_LINE 11:expect branch + } else { + DEB_SYSLOG("Parse error %s", config_filename.c_str()); + } + } else { + // LCOV_EXCL_START 5: new's error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + DEB_SYSLOG("new CNSConfigReader error"); + // LCOV_EXCL_STOP 5 + } + delete config_reader; // LCOV_EXCL_BR_LINE 11:expect branch + } else { + // LCOV_EXCL_START 5: get_readlink_path can not return false + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + DEB_SYSLOG("get_readlink_path error"); + // LCOV_EXCL_STOP 5 + } + } else { + // already read + // do nothing + } + + if (!IsExistFrameworkunifiedLogCfgShmem()) { + if (l_logLevelArray == NULL) { + readConfig(&l_realTimeLog, &l_logLevelArray); + } + WriteSharedMem(WTYPE_NORMAL, l_realTimeLog, g_FlagIdNum, l_logLevelArray); + MapShmInfo(g_FrameworkunifiedLogFlagId); + } + if (l_logLevelArray != NULL) { + free(l_logLevelArray); + } + + /** + * @tood + * Segmentation faults occur when NULL is defined as arguments. + */ + memcpy(&g_LocalFrameworkunifiedLogParams, p_FrameworkunifiedLogParams, sizeof(FRAMEWORKUNIFIEDLOGPARAM)); + + // Force Output ZONE_NS_WAR(8),ZONE_NS_ERR(9) + TFrameworkunifiedZone l_uiZoneMask = g_LocalFrameworkunifiedLogParams.uiZoneMask[0]; + l_uiZoneMask = l_uiZoneMask | GET_ZONE_BIT_MASK(ZONE_NS_WAR) | GET_ZONE_BIT_MASK(ZONE_NS_ERR); + g_LocalFrameworkunifiedLogParams.uiZoneMask[0] = l_uiZoneMask; + + // Force Output Zones + { + TFrameworkunifiedLogMap::iterator itr = g_FrameworkunifiedLogMap.begin(); + TFrameworkunifiedLogMap::iterator itr_end = g_FrameworkunifiedLogMap.end(); + for (; itr != itr_end; itr++) { + if (itr->second.force_output) { + UI_16 zone = static_cast<UI_16>(itr->first); + TFrameworkunifiedZone *pl_uiZoneMask = &g_LocalFrameworkunifiedLogParams.uiZoneMask[GET_ZONE_INDEX(zone)]; + *pl_uiZoneMask |= GET_ZONE_BIT_MASK(zone); + } + } + } +} + +void +NsLogSetProcessName(PCSTR p_strProcessName_i) { + if ((p_strProcessName_i != NULL) && (strlen(p_strProcessName_i) < _countof(tls_strProcessName))) { + strcpy(tls_strProcessName, p_strProcessName_i); // NOLINT (readability/nolint) + } +} + +void +NsLogSetControlMask(TFrameworkunifiedZoneMask p_NSLogControl_i) { + for (UI_32 zoneIndex = 0; zoneIndex < ZONE_MASK_ARRAY_ELTS; zoneIndex++) { + /** + * @todo + * Setting NULL to arguments terminates abnormally + */ + g_LocalFrameworkunifiedLogParams.uiZoneMask[zoneIndex] = p_NSLogControl_i[zoneIndex]; + } +} + +void +NsLogGetControlMask(TFrameworkunifiedZoneMask p_Zonemask_i) { + for (UI_32 zoneIndex = 0; zoneIndex < ZONE_MASK_ARRAY_ELTS; zoneIndex++) { + /** + * @todo + * Setting NULL to arguments terminates abnormally + */ + p_Zonemask_i[zoneIndex] = g_LocalFrameworkunifiedLogParams.uiZoneMask[zoneIndex]; + } +} + +BOOL +NsLogIsZoneSet(UI_32 set_zone) { + int realTimeLog; + int logLevel = 0; + + GetShmInfo(g_FrameworkunifiedLogFlagId, &realTimeLog, &logLevel); + + if (logLevel == FRAMEWORKUNIFIEDLOG_FLAG_MODE_DEBUG) + { + return TRUE; + } + + if (set_zone >= BITS_IN_ZONE_MASK) { + return FALSE; + } + + if (0 != (g_LocalFrameworkunifiedLogParams.uiZoneMask[ GET_ZONE_INDEX(set_zone) ] & GET_ZONE_BIT_MASK(set_zone))) { + return TRUE; + } + + return FALSE; +} + +void +NsLogSetLogMethod(UI_8 p_eMethod_i) { + g_LocalFrameworkunifiedLogParams.uiLogOptions = p_eMethod_i; +} + +UI_8 +NsLogGetLogMethod(void) { + return g_LocalFrameworkunifiedLogParams.uiLogOptions; +} + +void +NsLogSetSeverity(TFrameworkunifiedLoggerSeverity p_eLogSeverity_i) { + g_LocalFrameworkunifiedLogParams.eSeverity = p_eLogSeverity_i; +} + +TFrameworkunifiedLoggerSeverity +NsLogGetSeverity(void) { + return g_LocalFrameworkunifiedLogParams.eSeverity; +} + +UI_8 +NsLogDetermineLogMethod(PCSTR output_type) { + PSTR p = NULL; + const CHAR delims[] = "|"; + UI_8 outmask = 0; + PSTR parse = NULL; + PSTR saveptr = NULL; + + if (output_type != NULL) { + // since strtok modifies the var. we + // must create a copy of the string. + parse = strdup(output_type); + p = strtok_r (parse, delims, &saveptr); // NOLINT (readability/nolint) + while (p != NULL) { + // slogger|msgq|console +#ifdef AGL_STUB + if (!strcasecmp(p, "slogger")) { +#else + if (!strcmpi(p, "slogger")) { +#endif + outmask |= LSLOGGER; +#ifdef AGL_STUB + } else if (!strcasecmp(p, "msgq")) { +#else + } else if (!strcmpi(p, "msgq")) { +#endif + outmask |= LMSGQ; +#ifdef AGL_STUB + } else if (!strcasecmp(p, "console")) { +#else + } else if (!strcmpi(p, "console")) { +#endif + outmask |= LPRINT; +#ifdef AGL_STUB + } else if (!strcasecmp(p, "shmem")) { +#else + } else if (!strcmpi(p, "shmem")) { +#endif + outmask |= LSHAREDMEM; + } else { + // do nothing + } + + p = strtok_r (NULL, delims, &saveptr); // NOLINT (readability/nolint) + } + + // since we made dup of the char * passed we need to free it! + if (parse != NULL) { + free(parse); + parse = NULL; + } + } + return outmask; +} + +void +NsLogSetZones(UI_32 f_uiZoneCount, ...) { + va_list l_tArguments; + + // Initialize the variable argument list + va_start(l_tArguments, f_uiZoneCount); + + // Iterate the variable argument list + for (UI_32 l_uiArgumentCount = 0; l_uiArgumentCount < f_uiZoneCount; l_uiArgumentCount++) { + // get zone value + UI_32 l_uiZone = va_arg(l_tArguments, UI_32); // LCOV_EXCL_BR_LINE 11:expect branch + + if (l_uiZone < BITS_IN_ZONE_MASK) { + // add zone value to existing mask + UI_32 l_uiZoneMask = g_LocalFrameworkunifiedLogParams.uiZoneMask[GET_ZONE_INDEX(l_uiZone)]; + l_uiZoneMask = l_uiZoneMask | GET_ZONE_BIT_MASK(l_uiZone); + g_LocalFrameworkunifiedLogParams.uiZoneMask[GET_ZONE_INDEX(l_uiZone)] = l_uiZoneMask; + } + } + + va_end(l_tArguments); +} + +void +NsLogParseZones(FRAMEWORKUNIFIEDLOGPARAM *p_FrameworkunifiedLogParams, UI_32 f_uiZoneCount, ...) { + va_list l_tArguments; + + if (p_FrameworkunifiedLogParams == NULL) { + return; + } + + // Initialize the variable argument list + va_start(l_tArguments, f_uiZoneCount); + + // Iterate the variable argument list + for (UI_32 l_uiArgumentCount = 0; l_uiArgumentCount < f_uiZoneCount; l_uiArgumentCount++) { + // get zone value + UI_32 l_uiZone = va_arg(l_tArguments, UI_32); // LCOV_EXCL_BR_LINE 11:expect branch + + if (l_uiZone < BITS_IN_ZONE_MASK) { + // add zone + UI_32 l_uiZoneMask = p_FrameworkunifiedLogParams->uiZoneMask[GET_ZONE_INDEX(l_uiZone)]; + l_uiZoneMask = l_uiZoneMask | GET_ZONE_BIT_MASK(l_uiZone); + p_FrameworkunifiedLogParams->uiZoneMask[GET_ZONE_INDEX(l_uiZone)] = l_uiZoneMask; + } + } + + va_end(l_tArguments); +} + +void +NsLog_EvtCnt(UI_16 Cnt_Id, UI_16 Evt_Id, UI_8 nu, ...) { + st_LogEvent log; + va_list EC_list; + va_start(EC_list, nu); + UI_8 i = 0; + UI_32 ts = (UI_32)ClockCyclesToMs(); + + memset(&log, 0, sizeof(log)); + + log.ts = ConvertEndian(&ts); + log.event_id = (UI_8)Evt_Id; + log.grp_ID = (UI_8)(Evt_Id >> 8); + log.cnt_ID = Cnt_Id; + + switch (nu) { + case 1: + log.data[0] = (UI_8)va_arg(EC_list, int); + log.phase = NORMAL; + log.typeofdata = COMMON; + break; + case 2: + log.data[0] = (UI_8)va_arg(EC_list, int);; + log.phase = (SystemPhase)va_arg(EC_list, int); + log.typeofdata = COMMON; + break; + case 4: + for (i = 0; i < nu; i++) { + log.data[i] = (UI_8)va_arg(EC_list, int); + } + log.phase = NORMAL; + log.typeofdata = EVENT_SPECIFIC; + break; + case 5: + for (i = 0; i < (nu - 1); i++) { + log.data[i] = (UI_8)va_arg(EC_list, int); + } + log.phase = (SystemPhase)va_arg(EC_list, int); + log.typeofdata = EVENT_SPECIFIC; + break; + default: + memset(&log, 0, sizeof(log)); + break; + } + + if (log.cnt_ID != 0 && log.grp_ID != 0) { + if (g_hSSEventLogQ == INVALID_HANDLE) { + g_hSSEventLogQ = McOpenSender(EVENTLOG_MSGQ_NAME); + } + McSend(g_hSSEventLogQ, tls_strProcessName, SS_MSG_LOGGER_CNT_EVTLOG, sizeof(log), &log); + } + va_end(EC_list); +} + + +void +NsLog_Evt(UI_16 Evt_Id, UI_8 nu, ...) { + st_LogEvent log_Evt; + va_list E_list; + va_start(E_list, nu); + UI_32 ts = (UI_32)ClockCyclesToMs(); + + memset(&log_Evt, 0, sizeof(st_LogEvent)); + + log_Evt.ts = ConvertEndian(&ts); + log_Evt.grp_ID = (UI_8)(Evt_Id >> 8); + log_Evt.event_id = (UI_8)Evt_Id; + + UI_8 i; + switch (nu) { + case 1: + log_Evt.data[0] = (UI_8)va_arg(E_list, int); // LCOV_EXCL_BR_LINE 11:expect branch + log_Evt.typeofdata = COMMON; + break; + case 4: + for (i = 0; i < nu; i++) { + log_Evt.data[i] = (UI_8)va_arg(E_list, int); // LCOV_EXCL_BR_LINE 11:expect branch + } + log_Evt.typeofdata = EVENT_SPECIFIC; + break; + default: + memset(&log_Evt, 0, sizeof(st_LogEvent)); + break; + } + if (log_Evt.grp_ID != 0) { + if (g_hSSEventLogQ == INVALID_HANDLE) { + g_hSSEventLogQ = McOpenSender(EVENTLOG_MSGQ_NAME); + } + + McSend(g_hSSEventLogQ, tls_strProcessName, SS_MSG_EVTLOG, sizeof(log_Evt), &log_Evt); + } + va_end(E_list); +} + + +void +NsLog_Cnt(UI_16 Cnt_Id, UI_8 nu, ...) { + st_LogCount log_Cnt; + va_list C_list; + va_start(C_list, nu); + + memset(&log_Cnt, 0, sizeof(st_LogCount)); + log_Cnt.cnt_id = Cnt_Id; + + switch (nu) { + case 0: + log_Cnt.phase = NORMAL; + break; + case 1: + log_Cnt.phase = (SystemPhase)va_arg(C_list, int); // LCOV_EXCL_BR_LINE 11:expect branch + break; + default: + memset(&log_Cnt, 0, sizeof(st_LogCount)); + break; + } + if (log_Cnt.cnt_id != 0) { + if (g_hSSEventLogQ == INVALID_HANDLE) { + g_hSSEventLogQ = McOpenSender(EVENTLOG_MSGQ_NAME); + } + McSend(g_hSSEventLogQ, tls_strProcessName, SS_MSG_LOGGERCNT, sizeof(log_Cnt), &log_Cnt); + } + va_end(C_list); +} + +////////////////////////////////////////// +// NSPrintPerformanceLog +////////////////////////////////////////// +VOID +NSLogPrintPerformanceLog(const UI_16 f_ui16Line, PCSTR f_cFuncName, PCSTR __format, ...) { +#ifndef AGL_STUB + va_list arg; + CHAR l_cFormat[MAX_PLOG_STRING_SIZE] = {}; + CHAR l_cTimeFormat[MAX_TIME_FORMATSTR_LEN] = {}; + UI_64 l_ui64CurrentTime = 0; + + if (g_hNSplogMsgQ == INVALID_HANDLE) { + g_hNSplogMsgQ = OpenSender(NS_PLOGQ); + } + + if (g_FrameworkunifiedLogPParams.ui64GapInuS == 0) { + FILE *l_fpPLogGap = NULL; + l_fpPLogGap = fopen(PLOG_GAP_FILE, "re"); + if (l_fpPLogGap != NULL) { + CHAR l_cBuffer[MAX_GAP_BUFFER_LEN] = {}; + if (fgets(l_cBuffer, MAX_GAP_BUFFER_LEN, l_fpPLogGap) != NULL) { + g_FrameworkunifiedLogPParams.ui64GapInuS = (unsigned)atoll(l_cBuffer); + } + fclose(l_fpPLogGap); + } + } + + if (g_FrameworkunifiedLogPParams.eTimeFormat == EPLOG_TIME_FORMAT_USEC) { +#ifdef AGL_PosixBasedOS001LEGACY_USED + l_ui64CurrentTime = ClockCycle() + g_FrameworkunifiedLogPParams.ui64GapInuS; +#endif + snprintf(l_cTimeFormat, MAX_TIME_FORMATSTR_LEN, "%s", "us"); + } else if (g_FrameworkunifiedLogPParams.eTimeFormat == EPLOG_TIME_FORMAT_MSEC) { + l_ui64CurrentTime = ClockCyclesToMs() + (g_FrameworkunifiedLogPParams.ui64GapInuS / 1000); + snprintf(l_cTimeFormat, MAX_TIME_FORMATSTR_LEN, "%s", "ms"); + } else if (g_FrameworkunifiedLogPParams.eTimeFormat == EPLOG_TIME_FORMAT_SEC) { +#ifdef AGL_PosixBasedOS001LEGACY_USED + l_ui64CurrentTime = (ClockCycle() / 1000000) + (g_FrameworkunifiedLogPParams.ui64GapInuS / 1000000); +#endif + snprintf(l_cTimeFormat, MAX_TIME_FORMATSTR_LEN, "%s", "s"); + } else { + // do nothing + } + + va_start(arg, __format); + vsnprintf(l_cFormat, MAX_PLOG_STRING_SIZE - 1, __format, arg); + l_cFormat[MAX_PLOG_STRING_SIZE - 1] = '\0'; + va_end(arg); + + CHAR l_cMsg[MAX_QUEUE_MSG_SIZE] = {}; + snprintf(l_cMsg, MAX_QUEUE_MSG_SIZE - 1, "PLog: %12llu[%s]:%s %s: %s: %s", + l_ui64CurrentTime, l_cTimeFormat, (g_FrameworkunifiedLogPParams.ui64GapInuS > 0) ? ("o") : ("x"), + tls_strProcessName, f_cFuncName, l_cFormat); + + if (g_FrameworkunifiedLogPParams.uiLogOutputOptions & EPLOG_SLOG) { + // send to system logger + check_syslog_opened(); + syslog(LOG_INFO, "%s", l_cMsg); + } + + if (g_FrameworkunifiedLogPParams.uiLogOutputOptions & EPLOG_TRACEEVENT) { +#ifdef AGL_PosixBasedOS001LEGACY_USED + (VOID)trace_nlogf(_NTO_TRACE_USERFIRST, MAX_QUEUE_MSG_SIZE - 1, l_cMsg); +#endif + } + + if (g_FrameworkunifiedLogPParams.uiLogOutputOptions & EPLOG_MSGQ) { + // send to message queue /NSplog + if (g_hNSplogMsgQ != INVALID_HANDLE) { +#ifdef AGL_PosixBasedOS001LEGACY_USED + strlcat(l_cMsg, "\n", sizeof(l_cMsg)); // insert new line... user may not have. +#endif + if (SendMessage(g_hNSplogMsgQ, strlen(l_cMsg), + reinterpret_cast<void *>(const_cast<char *>(l_cMsg))) != eFrameworkunifiedStatusOK) { + // Note: Nothing will be printed on a failure. + } + } + } +#endif +} + +////////////////////////////////////////// +// NSLogEnablePLog +////////////////////////////////////////// +VOID +NSLogEnablePLog(BOOL f_bEnable) { + g_FrameworkunifiedLogPParams.bIsPLogEnabled = f_bEnable; +} + +////////////////////////////////////////// +// NsLogIsPLogEnabled +////////////////////////////////////////// +BOOL +NsLogIsPLogEnabled(void) { + return g_FrameworkunifiedLogPParams.bIsPLogEnabled; +} + +////////////////////////////////////////// +// NSLogSetPlogTimeFormat +////////////////////////////////////////// +VOID +NSLogSetPlogTimeFormat(EPLOG_TIME_FORMAT f_ePlogTimeFormat) { + g_FrameworkunifiedLogPParams.eTimeFormat = f_ePlogTimeFormat; +} + +////////////////////////////////////////// +// NSLogSetPlogOutputOptions +////////////////////////////////////////// +VOID +NSLogSetPlogOutputOptions(UI_8 f_uiPlogOutputOption) { + g_FrameworkunifiedLogPParams.uiLogOutputOptions = f_uiPlogOutputOption; +} + +////////////////////////////////////////// +// NsLogInitialize for Diag Method +////////////////////////////////////////// +VOID +NsLogInitialize(void) { + std::string config_filename = FRAMEWORKUNIFIEDLOG_CONFIG_NV; // LCOV_EXCL_BR_LINE 11:Excluded due to gcov constraints (others) + config_filename.append(FRAMEWORKUNIFIEDLOG_CONFIG__CWORD84__NV); // LCOV_EXCL_BR_LINE 11:expect branch + + int l_realTimelog; + int *l_logLevelArray = NULL; + + if (unlink(config_filename.c_str()) != 0) { + // error TODO wirte log, bit, not use frameworkunifiedlog + } + + readConfig(&l_realTimelog, &l_logLevelArray); // LCOV_EXCL_BR_LINE 11:expect branch + if (l_logLevelArray == NULL) { + return; + } + WriteSharedMem(WTYPE_NORMAL, l_realTimelog, g_FlagIdNum, l_logLevelArray); // LCOV_EXCL_BR_LINE 11:expect branch + if (l_logLevelArray != NULL) { + free(l_logLevelArray); + } +} + +static void writeUpdateConfigForString(std::string &name, // NOLINT (readability/nolint) + std::string set_key, + std::string value) { + std::string flag_loglevel_key = name; + flag_loglevel_key.append(set_key); + + std::string config_filename = FRAMEWORKUNIFIEDLOG_CONFIG_NV; // LCOV_EXCL_BR_LINE 11:expect branch + std::string config_tmpfilename = FRAMEWORKUNIFIEDLOG_CONFIG_NV; // LCOV_EXCL_BR_LINE 11:Excluded due to gcov constraints (others) + config_filename.append(FRAMEWORKUNIFIEDLOG_CONFIG__CWORD84__NV); // LCOV_EXCL_BR_LINE 11:expect branch + + config_tmpfilename.append(FRAMEWORKUNIFIEDLOG_CONFIG_TMP_NV); + + unlink(config_tmpfilename.c_str()); + if (copyFrameworkunifiedLogCfgFile(config_filename.c_str(), config_tmpfilename.c_str()) != 0) { + DEB_SYSLOG("fail to copy file. no update config."); + return; + } + +// CNSConfigWriter *l_pConfigWriter = new(std::nothrow) CNSConfigWriter(config_filename.c_str()); + CNSConfigWriter *l_pConfigWriter = new(std::nothrow) CNSConfigWriter(config_tmpfilename.c_str()); // LCOV_EXCL_BR_LINE 11:expect branch + + if (l_pConfigWriter != NULL) { + try { + // l_iReturnState = ConfigWriterUpdateValue(l_hHandle, l_sKeyValue.c_str(), actualOutput.c_str()); + l_pConfigWriter->Set(flag_loglevel_key, value); + } catch (...) { + // error TODO + } + // ConfigWriterClose(l_hHandle); + l_pConfigWriter->Save(); + delete l_pConfigWriter; + l_pConfigWriter = NULL; + + if (rename(config_tmpfilename.c_str(), config_filename.c_str()) != 0) { + DEB_SYSLOG("rename error errno:%d", errno); + } + + } +} + +static void +writeUpdateConfig(std::string set_key, std::string value) { + std::string config_filename = FRAMEWORKUNIFIEDLOG_CONFIG_NV; // LCOV_EXCL_BR_LINE 11:Excluded due to gcov constraints (others) + std::string config_tmpfilename = FRAMEWORKUNIFIEDLOG_CONFIG_NV; // LCOV_EXCL_BR_LINE 11:Excluded due to gcov constraints (others) + config_filename.append(FRAMEWORKUNIFIEDLOG_CONFIG__CWORD84__NV); // LCOV_EXCL_BR_LINE 11:Excluded due to gcov constraints (others) + config_tmpfilename.append(FRAMEWORKUNIFIEDLOG_CONFIG_TMP_NV); + + unlink(config_tmpfilename.c_str()); + if (copyFrameworkunifiedLogCfgFile(config_filename.c_str(), config_tmpfilename.c_str())) { + DEB_SYSLOG("fail to copy file. no update config."); + return; + } + +// CNSConfigWriter *l_pConfigWriter = new(std::nothrow) CNSConfigWriter(config_filename.c_str()); + CNSConfigWriter *l_pConfigWriter = new(std::nothrow) CNSConfigWriter(config_tmpfilename.c_str()); // LCOV_EXCL_BR_LINE 11:expect branch + + + if (l_pConfigWriter != NULL) { + l_pConfigWriter->Set(set_key.c_str(), value); // LCOV_EXCL_BR_LINE 11:expect branch + l_pConfigWriter->Save(); // LCOV_EXCL_BR_LINE 11:expect branch + delete l_pConfigWriter; // LCOV_EXCL_BR_LINE 11:expect branch + + if (rename(config_tmpfilename.c_str(), config_filename.c_str()) != 0) { + DEB_SYSLOG("rename error errno:%d", errno); + } + } +} + +////////////////////////////////////////// +// NsLogSetFrameworkunifiedLogFlag for Diag Method +////////////////////////////////////////// +VOID +NsLogSetFrameworkunifiedLogFlag(UI_8 flag_id, UI_8 mode) { + std::string l_key = ".LogLevel"; + int l_realTimelog; + int *l_logLevelArray; + std::string l_value; + + if (mode != FRAMEWORKUNIFIEDLOG_FLAG_MODE_DEBUG + && mode != FRAMEWORKUNIFIEDLOG_FLAG_MODE_RELEASE) { + return; + } + + if (!IsExistFrameworkunifiedLogCfgNv()) { // LCOV_EXCL_BR_LINE 11:Excluded due to gcov constraints (others) + copyFrameworkunifiedLogCfgFileToNv(); // LCOV_EXCL_BR_LINE 11:expect branch + } + + l_realTimelog = FRAMEWORKUNIFIEDLOG_REALTIMELOG_MODE_OFF; + l_logLevelArray = NULL; + + readConfig(&l_realTimelog, &l_logLevelArray); // for make ramd data + if (l_logLevelArray == NULL) { + return; + } + + if (!IsExistFrameworkunifiedLogCfgShmem()) { + WriteSharedMem(WTYPE_NORMAL, l_realTimelog, g_FlagIdNum, l_logLevelArray); + MapShmInfo(g_FrameworkunifiedLogFlagId); + } + + if (flag_id >= g_FlagIdNum) { + if (l_logLevelArray != NULL) { + free(l_logLevelArray); + } + return; + } + + if (mode == FRAMEWORKUNIFIEDLOG_FLAG_MODE_DEBUG) { + l_value = "Debug"; + l_logLevelArray[flag_id] = FRAMEWORKUNIFIEDLOG_FLAG_MODE_DEBUG; + } else { + l_value = "Release"; + l_logLevelArray[flag_id] = FRAMEWORKUNIFIEDLOG_FLAG_MODE_RELEASE; + } + writeUpdateConfigForString(g_flag_name[flag_id], l_key, l_value); // LCOV_EXCL_BR_LINE 11:expect branch + WriteSharedMemForFlagId(l_realTimelog, g_FlagIdNum, flag_id, l_logLevelArray[flag_id]); // LCOV_EXCL_BR_LINE 11:expect branch + + free(l_logLevelArray); +} + +////////////////////////////////////////// +// NsLogGetFrameworkunifiedLogFlag for Diag Method +////////////////////////////////////////// +EFrameworkunifiedStatus +NsLogGetFrameworkunifiedLogFlag(UI_8 flag_id, UI_8 *mode) { + int l_realTimeLog; + int l_logLevel = 0; + int *l_logLevelArray; + + if (mode == NULL) { + return eFrameworkunifiedStatusFail; + } + + l_realTimeLog = FRAMEWORKUNIFIEDLOG_REALTIMELOG_MODE_OFF; + l_logLevelArray = NULL; + + readConfig(&l_realTimeLog, &l_logLevelArray); // for make ramd data + if (l_logLevelArray == NULL) { + *mode = FRAMEWORKUNIFIEDLOG_FLAG_MODE_RELEASE; + return eFrameworkunifiedStatusFail; + } + + if (!IsExistFrameworkunifiedLogCfgShmem()) { + WriteSharedMem(WTYPE_NORMAL, l_realTimeLog, g_FlagIdNum, l_logLevelArray); + MapShmInfo(g_FrameworkunifiedLogFlagId); + } + + if (l_logLevelArray != NULL) { + free(l_logLevelArray); + } + + if ((flag_id >= g_FlagIdNum)) { + return eFrameworkunifiedStatusFail; + } + + GetShmInfo(flag_id, &l_realTimeLog, &l_logLevel); + *mode = static_cast<UI_8>(l_logLevel); + + return eFrameworkunifiedStatusOK; +} + +////////////////////////////////////////// +// NsLogSetRealtimeLog for Diag Method +////////////////////////////////////////// +VOID +NsLogSetRealtimeLog(UI_8 mode) { + int l_realTimelog = FRAMEWORKUNIFIEDLOG_REALTIMELOG_MODE_OFF; + int *l_logLevelArray; + std::string l_key = "REALTIME_LOG.Output"; + std::string l_value = "OFF"; // LCOV_EXCL_BR_LINE 11:expect branch + + if (mode == FRAMEWORKUNIFIEDLOG_REALTIMELOG_MODE_FREEZE) { + WriteSharedMem(WTYPE_RTIMELOG, FRAMEWORKUNIFIEDLOG_REALTIMELOG_MODE_FREEZE, g_FlagIdNum, NULL); // LCOV_EXCL_BR_LINE 11:expect branch + return; + } + + if ((mode >= FRAMEWORKUNIFIEDLOG_REALTIMELOG_MODE_MAX) + && (mode != FRAMEWORKUNIFIEDLOG_REALTIMELOG_MODE_USB_DISABLE)) { + return; + } + + if (!IsExistFrameworkunifiedLogCfgNv()) { // LCOV_EXCL_BR_LINE 11:Excluded due to gcov constraints (others) + copyFrameworkunifiedLogCfgFileToNv(); // LCOV_EXCL_BR_LINE 11:expect branch + } + + l_logLevelArray = NULL; + readConfig(&l_realTimelog, &l_logLevelArray); // LCOV_EXCL_BR_LINE 11:expect branch + if (l_logLevelArray == NULL) { + return; + } + + if (!IsExistFrameworkunifiedLogCfgShmem()) { + WriteSharedMem(WTYPE_NORMAL, l_realTimelog, g_FlagIdNum, l_logLevelArray); + MapShmInfo(g_FrameworkunifiedLogFlagId); + } + + if (mode == FRAMEWORKUNIFIEDLOG_REALTIMELOG_MODE_UART) { + l_value = "UART"; + l_realTimelog = FRAMEWORKUNIFIEDLOG_REALTIMELOG_MODE_UART; + } else if ((mode == FRAMEWORKUNIFIEDLOG_REALTIMELOG_MODE_USB) + || (mode == FRAMEWORKUNIFIEDLOG_REALTIMELOG_MODE_USB_DISABLE)) { + l_value = "USB"; + l_realTimelog = mode; + } else { + l_value = "OFF"; + l_realTimelog = FRAMEWORKUNIFIEDLOG_REALTIMELOG_MODE_OFF; + } + + writeUpdateConfig(l_key, l_value); // LCOV_EXCL_BR_LINE 11:expect branch + if (l_logLevelArray != NULL) { + WriteSharedMemForFlagId(l_realTimelog, g_FlagIdNum, FRAMEWORKUNIFIEDLOG_DEFAULT_FLAG_ID, + l_logLevelArray[FRAMEWORKUNIFIEDLOG_DEFAULT_FLAG_ID]); // LCOV_EXCL_BR_LINE 11:expect branch + free(l_logLevelArray); + } +} + +////////////////////////////////////////// +// NsLogGetRealtimeLog for Diag +////////////////////////////////////////// +VOID +NsLogGetRealtimeLog(UI_8 *mode) { + int l_realTimelog; + int l_logLevel; + int *l_logLevelArray; + + if (mode == NULL) { + return; + } + l_realTimelog = FRAMEWORKUNIFIEDLOG_REALTIMELOG_MODE_OFF; + l_logLevelArray = NULL; + + readConfig(&l_realTimelog, &l_logLevelArray); // for make ramd data + if (l_logLevelArray == NULL) { + *mode = FRAMEWORKUNIFIEDLOG_REALTIMELOG_MODE_OFF; + return; + } + if (!IsExistFrameworkunifiedLogCfgShmem()) { + WriteSharedMem(WTYPE_NORMAL, l_realTimelog, g_FlagIdNum, l_logLevelArray); + MapShmInfo(g_FrameworkunifiedLogFlagId); + } + if (l_logLevelArray != NULL) { + free(l_logLevelArray); + } + + GetShmInfo(g_FrameworkunifiedLogFlagId, &l_realTimelog, &l_logLevel); + *mode = static_cast<UI_8>(l_realTimelog); +} + +////////////////////////////////////////// +// NSLogPrintSysEventLog +////////////////////////////////////////// +VOID NSLogSysEvent(const UI_16 f_ui16Line, PCSTR f_cFuncName, PCSTR __format, ...) { + va_list arg; + CHAR l_cFormat[MAX_QUEUE_MSG_SIZE] = {}; + CHAR l_cTimeFormat[MAX_TIME_FORMATSTR_LEN] = {}; + UI_64 l_ui64CurrentTime = 0; + static UI_64 cps = 0; + static UI_64 l_ui64GapInUS = 0; + + if (cps == 0) { + cps = SYSPAGE_ENTRY(qtime)->cycles_per_sec; + } + if (g_hNSSysEventLogQ == INVALID_HANDLE) { + g_hNSSysEventLogQ = OpenSender(NS_SYSEVENTLOGQ); + } + if (l_ui64GapInUS == 0) { + FILE *l_fpPLogGap = NULL; + l_fpPLogGap = fopen(PLOG_GAP_FILE, "re"); + if (l_fpPLogGap != NULL) { + CHAR l_cBuffer[MAX_GAP_BUFFER_LEN] = {}; + if (fgets(l_cBuffer, MAX_GAP_BUFFER_LEN, l_fpPLogGap) != NULL) { + l_ui64GapInUS = static_cast<UI_64>(atoll(l_cBuffer)); + } + fclose(l_fpPLogGap); + } + } + + if (g_hNSSysEventLogQ != INVALID_HANDLE) { + CHAR l_cMsg[MAX_QUEUE_MSG_SIZE] = {}; + // build a format string +#ifdef AGL_PosixBasedOS001LEGACY_USED + l_ui64CurrentTime = (ClockCycle() / (cps / 1000000)) + l_ui64GapInUS; +#endif + snprintf(l_cTimeFormat, MAX_TIME_FORMATSTR_LEN, "%s", "us"); + + va_start(arg, __format); + vsnprintf(l_cFormat, MAX_PLOG_STRING_SIZE - 1, __format, arg); + l_cFormat[MAX_PLOG_STRING_SIZE - 1] = '\0'; + va_end(arg); + UI_32 l_uiCharsWritten = + snprintf(l_cMsg, MAX_QUEUE_MSG_SIZE - 1, + "%12llu[%s]:%s %s: %s: %s\n", + static_cast<long long unsigned int>(l_ui64CurrentTime), // NOLINT (readability/nolint) + l_cTimeFormat, + (l_ui64GapInUS > 0) ? ("o") : ("x"), + tls_strProcessName != 0 ? tls_strProcessName : NULL, + f_cFuncName != 0 ? f_cFuncName : NULL, l_cFormat); + + if (SendMessage(g_hNSSysEventLogQ, l_uiCharsWritten + 1, + reinterpret_cast<void *>(const_cast<char *>(l_cMsg))) + != eFrameworkunifiedStatusOK) { + // Note: Nothing will be printed on a failure. + } + } +} + +///////////////////////////////////////// +// NSLogEnableSysEventLog +////////////////////////////////////////// +VOID +NSLogEnableSysEventLog(BOOL f_bEnable) { + g_FrameworkunifiedLogSysEventParams.bIsSysEventLogEnabled = f_bEnable; +} + +////////////////////////////////////////// +// NSLogIsSysEventLogEnabled +////////////////////////////////////////// +BOOL +NSLogIsSysEventLogEnabled(void) { + return g_FrameworkunifiedLogSysEventParams.bIsSysEventLogEnabled; +} + +////////////////////////////////////////// +// NsLogGetZoneTextList +////////////////////////////////////////// +VOID +NsLogGetZoneTextList(CHAR f_cZoneList[][ZONE_TEXT_SIZE]) { + if (f_cZoneList != NULL) { + UI_32 l_ui32CharsToWrite = ZONE_TEXT_SIZE - 1; + // first fill ns zone text list + strncpy(f_cZoneList[0], ZONE_TEXT_0, l_ui32CharsToWrite); + strncpy(f_cZoneList[1], ZONE_TEXT_1, l_ui32CharsToWrite); + strncpy(f_cZoneList[2], ZONE_TEXT_2, l_ui32CharsToWrite); + strncpy(f_cZoneList[3], ZONE_TEXT_3, l_ui32CharsToWrite); + strncpy(f_cZoneList[4], ZONE_TEXT_4, l_ui32CharsToWrite); + strncpy(f_cZoneList[5], ZONE_TEXT_5, l_ui32CharsToWrite); + strncpy(f_cZoneList[6], ZONE_TEXT_6, l_ui32CharsToWrite); + strncpy(f_cZoneList[7], ZONE_TEXT_7, l_ui32CharsToWrite); + strncpy(f_cZoneList[8], ZONE_TEXT_8, l_ui32CharsToWrite); + strncpy(f_cZoneList[9], ZONE_TEXT_9, l_ui32CharsToWrite); + + // fill user zone text list + UI_32 l_ui32Count = 10; // start of user zones + UI_32 l_ui32ZoneListCount = 0; + for (; l_ui32Count < BITS_IN_ZONE_MASK; l_ui32Count++, l_ui32ZoneListCount++) { + strncpy(f_cZoneList[l_ui32Count], g_LocalFrameworkunifiedLogParams.cZones[l_ui32ZoneListCount], l_ui32CharsToWrite); + } + } +} + +VOID +NsForceClose(void) { + if (!syslogopened) { + closelog(); + syslogopened = 0; + } + + if (shm_pmap != reinterpret_cast<void *>(const_cast<unsigned int*>(default_log_cfgtbl))) { + int size; + size = static_cast<int>(sizeof(int) * 2); // realTimeLog + flagIdNum + size += static_cast<int>(sizeof(int) * g_FlagIdNum); + munmap(shm_pmap, size); + shm_pmap = reinterpret_cast<void *>(const_cast<unsigned int*>(default_log_cfgtbl)); + } + + if (shm_fd != -1) { + close(shm_fd); + shm_fd = -1; + } + + if (g_qid != (mqd_t)(-1)) { + mq_close(g_qid); + g_qid = (mqd_t)(-1); + } + + TFrameworkunifiedLogMap::iterator itr; + TFrameworkunifiedLogMap::iterator itr_end; + UI_32 i = 0; + unsigned int flag_id; + if (!g_FrameworkunifiedLogMap.empty()) { + itr = g_FrameworkunifiedLogMap.begin(); + itr_end = g_FrameworkunifiedLogMap.end(); + for (; itr != itr_end; itr++, i++) { + if (itr->second.ring_buffer != NULL) { + delete itr->second.ring_buffer; // LCOV_EXCL_BR_LINE 11:expect branch + itr->second.ring_buffer = NULL; + } + } + g_FrameworkunifiedLogMap.clear(); + } + + if (!g_FrameworkunifiedLogFlagMap.empty()) { + for (flag_id = 0; flag_id < g_FlagIdNum; flag_id++) { + itr = g_FrameworkunifiedLogFlagMap.find(flag_id); + if (itr->second.ring_buffer != NULL) { + delete itr->second.ring_buffer; // LCOV_EXCL_BR_LINE 11:expect branch + itr->second.ring_buffer = NULL; + } + } + g_FrameworkunifiedLogFlagMap.clear(); + } + + if (!g_flag_name.empty()) { + g_flag_name.clear(); + } + g_FrameworkunifiedLogFlagId = FRAMEWORKUNIFIEDLOG_DEFAULT_FLAG_ID; + g_FlagIdNum = 0; +} // LCOV_EXCL_BR_LINE 10:The final line |