You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
419 lines
11 KiB
419 lines
11 KiB
/*
|
|
* Copyright (c) Hisilicon Technologies Co., Ltd.. 2020-2020. All rights reserved.
|
|
* Description: Logcat version of the slog function implementation
|
|
* Author: Hisilicon
|
|
* Create: 2020-10-9
|
|
*/
|
|
|
|
#include <android/log.h>
|
|
#include <cstdarg>
|
|
#include <cutils/properties.h>
|
|
|
|
#include "securec.h"
|
|
#include "android_slog.h"
|
|
|
|
#define UNUSED(x) ((void)(x))
|
|
|
|
#ifdef __cplusplus
|
|
#ifndef LOG_CPP
|
|
extern "C" {
|
|
#endif
|
|
#endif // __cplusplus
|
|
|
|
|
|
#define ONE_ACT_NO_LOG(expr, action) \
|
|
if (expr) { \
|
|
action; \
|
|
} \
|
|
|
|
static int g_isInited = NO_INITED;
|
|
__attribute__ ((constructor)) void dlog_init();
|
|
|
|
static const ModuleInfo *GetModuleInfos()
|
|
{
|
|
return (const ModuleInfo *)g_moduleInfo;
|
|
}
|
|
|
|
static int GetLevelByModuleId(const int moduleId)
|
|
{
|
|
const ModuleInfo *set = g_moduleInfo;
|
|
if (moduleId >= 0 && moduleId < INVLID_MOUDLE_ID) {
|
|
return set[moduleId].moduleLevel;
|
|
}
|
|
return MODULE_DEFAULT_LOG_LEVEL;
|
|
}
|
|
|
|
/**
|
|
* @brief dlog_init: libslog.so initialize
|
|
* @return: void
|
|
*/
|
|
void dlog_init(void)
|
|
{
|
|
char globalLevel[PROPERTY_VALUE_MAX] = {0};
|
|
property_get("persist.vendor.slog.global.level", globalLevel, "3");
|
|
g_globalLogLevel = atoi(globalLevel);
|
|
|
|
char eventValue[PROPERTY_VALUE_MAX] = {0};
|
|
property_get("persist.vendor.slog.event", eventValue, "1");
|
|
g_enableEvent = atoi(eventValue);
|
|
|
|
g_isInited = INITED;
|
|
}
|
|
|
|
/**
|
|
* @brief dlog_getlevel: get module loglevel
|
|
* @param [in]moduleId: moudule Id eg: CCE
|
|
* @param [in/out]enableEvent: point to enableEvent to record enableEvent
|
|
* @return: module level(0: debug, 1: info, 2: warning, 3: error, 4: null output)
|
|
*/
|
|
int dlog_getlevel(int moduleId, int *enableEvent)
|
|
{
|
|
if (enableEvent != NULL) {
|
|
*enableEvent = g_enableEvent;
|
|
}
|
|
|
|
int moduleLevel = GetLevelByModuleId(moduleId);
|
|
if (moduleLevel < LOG_MIN_LEVEL || moduleLevel > LOG_MAX_LEVEL) {
|
|
moduleLevel = g_globalLogLevel;
|
|
}
|
|
return moduleLevel;
|
|
}
|
|
|
|
/**
|
|
* @brief dlog_setlevel: set module loglevel and enableEvent
|
|
* @param [in]moduleId: moudule id(see slog.h, eg: CCE), -1: all modules, others: invalid
|
|
* @param [in]level: log level(0: debug, 1: info, 2: warning, 3: error, 4: null output)
|
|
* @param [in]enableEvent: 1: enable; 0: disable, others:invalid
|
|
* @return: 0: SUCCEED, others: FAILED
|
|
*/
|
|
int dlog_setlevel(int moduleId, int level, int enableEvent)
|
|
{
|
|
int ret = SYS_OK;
|
|
if ((enableEvent == TRUE) || (enableEvent == FALSE)) {
|
|
g_enableEvent = enableEvent;
|
|
} else {
|
|
ret = SYS_ERROR;
|
|
}
|
|
|
|
if ((level < LOG_MIN_LEVEL) || (level > LOG_MAX_LEVEL)) {
|
|
return SYS_ERROR;
|
|
}
|
|
|
|
if (moduleId == INVALID) {
|
|
g_globalLogLevel = level;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief CheckLogLevel: check log allow output or not
|
|
* @param [in]moduleId: module Id
|
|
* @param [in]level: log level
|
|
* @return: TRUE/FALSE
|
|
*/
|
|
int CheckLogLevel(int moduleId, int level)
|
|
{
|
|
if (level == DLOG_TRACE || level == DLOG_OPLOG) {
|
|
return TRUE;
|
|
}
|
|
|
|
// event log contrl
|
|
if (level == DLOG_EVENT) {
|
|
return (g_enableEvent == TRUE) ? TRUE : FALSE;
|
|
}
|
|
|
|
// level parameter check
|
|
if (level < LOG_MIN_LEVEL || level >= LOG_MAX_LEVEL) {
|
|
return FALSE;
|
|
}
|
|
|
|
const ModuleInfo *moduleInfos = GetModuleInfos();
|
|
// get module loglevel by moduleId
|
|
int moduleLevel = MODULE_DEFAULT_LOG_LEVEL;
|
|
if (moduleId >= 0 && moduleId < INVLID_MOUDLE_ID) {
|
|
moduleLevel = moduleInfos[moduleId].moduleLevel;
|
|
if (moduleLevel < LOG_MIN_LEVEL || moduleLevel > LOG_MAX_LEVEL) {
|
|
moduleLevel = g_globalLogLevel;
|
|
}
|
|
} else {
|
|
moduleLevel = g_globalLogLevel;
|
|
}
|
|
|
|
// check module loglevel and log control, check time diff to make switch back to false
|
|
if (level >= moduleLevel) {
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* @brief DlogSetAttr: set log attr
|
|
* @param [in]logAttr: attr info, include pid, process type and device id
|
|
* @return: 0: SUCCEED, others: FAILED
|
|
*/
|
|
int DlogSetAttr(LogAttr logAttr)
|
|
{
|
|
UNUSED(logAttr);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void DlogErrorInner(int moduleId, const char *fmt, ...)
|
|
{
|
|
if (fmt != nullptr) {
|
|
int result = CheckLogLevel(moduleId, DLOG_ERROR);
|
|
ONE_ACT_NO_LOG(result == FALSE, return);
|
|
va_list list;
|
|
va_start(list, fmt);
|
|
const ModuleInfo *moduleInfos = GetModuleInfos();
|
|
__android_log_vprint(ANDROID_LOG_ERROR, moduleInfos[moduleId].moduleName, fmt, list);
|
|
va_end(list);
|
|
}
|
|
}
|
|
|
|
void DlogWarnInner(int moduleId, const char *fmt, ...)
|
|
{
|
|
if (fmt != nullptr) {
|
|
int result = CheckLogLevel(moduleId, DLOG_WARN);
|
|
ONE_ACT_NO_LOG(result == FALSE, return);
|
|
va_list list;
|
|
va_start(list, fmt);
|
|
const ModuleInfo *moduleInfos = GetModuleInfos();
|
|
__android_log_vprint(ANDROID_LOG_WARN, moduleInfos[moduleId].moduleName, fmt, list);
|
|
va_end(list);
|
|
}
|
|
}
|
|
|
|
void DlogInfoInner(int moduleId, const char *fmt, ...)
|
|
{
|
|
if (fmt != nullptr) {
|
|
int result = CheckLogLevel(moduleId, DLOG_INFO);
|
|
ONE_ACT_NO_LOG(result == FALSE, return);
|
|
va_list list;
|
|
va_start(list, fmt);
|
|
const ModuleInfo *moduleInfos = GetModuleInfos();
|
|
__android_log_vprint(ANDROID_LOG_INFO, moduleInfos[moduleId].moduleName, fmt, list);
|
|
va_end(list);
|
|
}
|
|
}
|
|
|
|
void DlogDebugInner(int moduleId, const char *fmt, ...)
|
|
{
|
|
if (fmt != nullptr) {
|
|
int result = CheckLogLevel(moduleId, DLOG_DEBUG);
|
|
ONE_ACT_NO_LOG(result == FALSE, return);
|
|
va_list list;
|
|
va_start(list, fmt);
|
|
const ModuleInfo *moduleInfos = GetModuleInfos();
|
|
__android_log_vprint(ANDROID_LOG_DEBUG, moduleInfos[moduleId].moduleName, fmt, list);
|
|
va_end(list);
|
|
}
|
|
}
|
|
|
|
void DlogEventInner(int moduleId, const char *fmt, ...)
|
|
{
|
|
if (fmt != nullptr) {
|
|
int result = CheckLogLevel(moduleId, DLOG_EVENT);
|
|
ONE_ACT_NO_LOG(result == FALSE, return);
|
|
|
|
char msg[MSG_LENGTH] = {0};
|
|
int len = static_cast<int>(strlen(msg));
|
|
int err;
|
|
|
|
err = snprintf_s(msg + len, MSG_LENGTH - len, MSG_LENGTH - len - 1, "<EVENT> ");
|
|
ONE_ACT_NO_LOG(err == -1, return);
|
|
|
|
va_list list;
|
|
va_start(list, fmt);
|
|
len = static_cast<int>(strlen(msg));
|
|
err = vsnprintf_truncated_s(msg + len, MSG_LENGTH - len - 1, fmt, list);
|
|
va_end(list);
|
|
ONE_ACT_NO_LOG(err == -1, return);
|
|
|
|
const ModuleInfo *moduleInfos = GetModuleInfos();
|
|
__android_log_print(ANDROID_LOG_INFO, moduleInfos[moduleId].moduleName, "%s", msg);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief DlogInner: log interface with level
|
|
* @param [in]moduleId: moudule Id eg: CCE
|
|
* @param [in]level: log level((0: debug, 1: info, 2: warning, 3: error)
|
|
* @param [in]fmt: log msg string
|
|
* @return: void
|
|
*/
|
|
void DlogInner(int moduleId, int level, const char *fmt, ...)
|
|
{
|
|
if (fmt != nullptr) {
|
|
int result = CheckLogLevel(moduleId, level);
|
|
ONE_ACT_NO_LOG(result == FALSE, return);
|
|
va_list list;
|
|
va_start(list, fmt);
|
|
const ModuleInfo *moduleInfos = GetModuleInfos();
|
|
__android_log_vprint(ANDROID_LOG_INFO, moduleInfos[moduleId].moduleName, fmt, list);
|
|
va_end(list);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief DlogWithKVInner: log interface with level
|
|
* @param [in]moduleId: moudule Id eg: CCE
|
|
* @param [in]level: log level(0: debug, 1: info, 2: warning, 3: error)
|
|
* @param [in]pstKVArray: key-value arrary
|
|
* @param [in]kvNum: num of key-value arrary
|
|
* @param [in]fmt: log msg string
|
|
* @return: void
|
|
*/
|
|
void DlogWithKVInner(int moduleId, int level, KeyValue *pstKVArray, int kvNum, const char *fmt, ...)
|
|
{
|
|
ONE_ACT_NO_LOG(pstKVArray == NULL, return);
|
|
ONE_ACT_NO_LOG(kvNum <= 0, return);
|
|
|
|
if (fmt != nullptr) {
|
|
int result = CheckLogLevel(moduleId, level);
|
|
ONE_ACT_NO_LOG(result == FALSE, return);
|
|
|
|
char msg[MSG_LENGTH] = {0};
|
|
int len = static_cast<int>(strlen(msg));
|
|
int err;
|
|
int i;
|
|
|
|
for (i = 0; i < kvNum; i++, pstKVArray++) {
|
|
ONE_ACT_NO_LOG(pstKVArray->kname == nullptr || pstKVArray->value == nullptr, continue);
|
|
len = static_cast<int>(strlen(msg));
|
|
err = snprintf_s(msg + len, MSG_LENGTH - len, MSG_LENGTH - len - 1, "[%s:%s] ",
|
|
pstKVArray->kname, pstKVArray->value);
|
|
ONE_ACT_NO_LOG(err == -1, return);
|
|
}
|
|
|
|
va_list list;
|
|
va_start(list, fmt);
|
|
len = static_cast<int>(strlen(msg));
|
|
err = vsnprintf_truncated_s(msg + len, MSG_LENGTH - len - 1, fmt, list);
|
|
va_end(list);
|
|
ONE_ACT_NO_LOG(err == -1, return);
|
|
|
|
const ModuleInfo *moduleInfos = GetModuleInfos();
|
|
__android_log_print(ANDROID_LOG_INFO, moduleInfos[moduleId].moduleName, "%s", msg);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief DlogFlush: flush log buffer to file
|
|
* @return: void
|
|
*/
|
|
void DlogFlush(void)
|
|
{
|
|
return;
|
|
}
|
|
|
|
#ifdef __cplusplus
|
|
#ifndef LOG_CPP
|
|
}
|
|
#endif // LOG_CPP
|
|
#endif // __cplusplus
|
|
|
|
#ifdef LOG_CPP
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
int DlogGetlevelForC(int moduleId, int *enableEvent)
|
|
{
|
|
return dlog_getlevel(moduleId, enableEvent);
|
|
}
|
|
|
|
int DlogSetlevelForC(int moduleId, int level, int enableEvent)
|
|
{
|
|
return dlog_setlevel(moduleId, level, enableEvent);
|
|
}
|
|
|
|
int CheckLogLevelForC(int moduleId, int logLevel)
|
|
{
|
|
return CheckLogLevel(moduleId, logLevel);
|
|
}
|
|
|
|
int DlogSetAttrForC(LogAttr logAttr)
|
|
{
|
|
return DlogSetAttr(logAttr);
|
|
}
|
|
|
|
void DlogFlushForC(void)
|
|
{
|
|
return DlogFlush();
|
|
}
|
|
|
|
void DlogInnerForC(int moduleId, int level, const char *fmt, ...)
|
|
{
|
|
if (fmt != nullptr) {
|
|
int result = CheckLogLevel(moduleId, level);
|
|
ONE_ACT_NO_LOG(result == FALSE, return);
|
|
va_list list;
|
|
va_start(list, fmt);
|
|
const ModuleInfo *moduleInfos = GetModuleInfos();
|
|
__android_log_vprint(ANDROID_LOG_INFO, moduleInfos[moduleId].moduleName, fmt, list);
|
|
va_end(list);
|
|
}
|
|
}
|
|
|
|
void DlogWithKVInnerForC(int moduleId, int level, KeyValue *pstKVArray, int kvNum, const char *fmt, ...)
|
|
{
|
|
ONE_ACT_NO_LOG(pstKVArray == NULL, return);
|
|
ONE_ACT_NO_LOG(kvNum <= 0, return);
|
|
|
|
if (fmt != nullptr) {
|
|
int result = CheckLogLevel(moduleId, level);
|
|
ONE_ACT_NO_LOG(result == FALSE, return);
|
|
|
|
char msg[MSG_LENGTH] = {0};
|
|
int len = static_cast<int>(strlen(msg));
|
|
int err;
|
|
int i;
|
|
|
|
for (i = 0; i < kvNum; i++, pstKVArray++) {
|
|
ONE_ACT_NO_LOG(pstKVArray->kname == nullptr || pstKVArray->value == nullptr, continue);
|
|
len = static_cast<int>(strlen(msg));
|
|
err = snprintf_s(msg + len, MSG_LENGTH - len, MSG_LENGTH - len - 1, "[%s:%s] ",
|
|
pstKVArray->kname, pstKVArray->value);
|
|
ONE_ACT_NO_LOG(err == -1, return);
|
|
}
|
|
|
|
va_list list;
|
|
va_start(list, fmt);
|
|
len = static_cast<int>(strlen(msg));
|
|
err = vsnprintf_truncated_s(msg + len, MSG_LENGTH - len - 1, fmt, list);
|
|
va_end(list);
|
|
ONE_ACT_NO_LOG(err == -1, return);
|
|
|
|
const ModuleInfo *moduleInfos = GetModuleInfos();
|
|
__android_log_print(ANDROID_LOG_INFO, moduleInfos[moduleId].moduleName, "%s", msg);
|
|
}
|
|
}
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
#endif // LOG_CPP
|
|
|
|
// the code for stub
|
|
#if (!defined PROCESS_LOG && !defined PLOG_AUTO)
|
|
#include "plog.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
int DlogReportInitialize()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int DlogReportFinalize()
|
|
{
|
|
return 0;
|
|
}
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
#endif
|
|
|