From b74ff1cab402da33e0e1bca36fefe4a2e1d4a158 Mon Sep 17 00:00:00 2001 From: wenlong_12 Date: Mon, 9 Dec 2024 17:32:33 +0800 Subject: [PATCH] Add persist log level Signed-off-by: wenlong_12 --- frameworks/libhilog/hilog_printf.cpp | 8 ++ .../libhilog/param/include/properties.h | 6 ++ frameworks/libhilog/param/properties.cpp | 88 +++++++++++++++++++ interfaces/native/innerkits/libhilog.map | 4 + services/hilogd/main.cpp | 5 ++ services/hilogtool/main.cpp | 42 ++++++--- 6 files changed, 142 insertions(+), 11 deletions(-) diff --git a/frameworks/libhilog/hilog_printf.cpp b/frameworks/libhilog/hilog_printf.cpp index 1e92587..922f6ca 100644 --- a/frameworks/libhilog/hilog_printf.cpp +++ b/frameworks/libhilog/hilog_printf.cpp @@ -103,10 +103,18 @@ static uint16_t GetFinalLevel(unsigned int domain, const std::string& tag) if (tagLevel != LOG_LEVEL_MIN) { return tagLevel; } + uint16_t persistTagLevel = GetPersistTagLevel(tag); + if (persistTagLevel != LOG_LEVEL_MIN) { + return persistTagLevel; + } uint16_t domainLevel = GetDomainLevel(domain); if (domainLevel != LOG_LEVEL_MIN) { return domainLevel; } + uint16_t persistDomainLevel = GetPersistDomainLevel(domain); + if (persistDomainLevel != LOG_LEVEL_MIN) { + return persistDomainLevel; + } // domain within the range of [DOMAIN_APP_MIN, DOMAIN_APP_MAX] is a js log, // if this js log comes from debuggable hap, set the default level. if ((domain >= DOMAIN_APP_MIN) && (domain <= DOMAIN_APP_MAX)) { diff --git a/frameworks/libhilog/param/include/properties.h b/frameworks/libhilog/param/include/properties.h index fecf644..7d16c3e 100644 --- a/frameworks/libhilog/param/include/properties.h +++ b/frameworks/libhilog/param/include/properties.h @@ -35,8 +35,11 @@ bool IsPrivateSwitchOn(); #endif bool IsDebuggableHap(); uint16_t GetGlobalLevel(); +uint16_t GetPersistGlobalLevel(); uint16_t GetDomainLevel(uint32_t domain); +uint16_t GetPersistDomainLevel(uint32_t domain); uint16_t GetTagLevel(const std::string& tag); +uint16_t GetPersistTagLevel(const std::string& tag); bool IsProcessSwitchOn(); bool IsDomainSwitchOn(); bool IsKmsgSwitchOn(); @@ -50,8 +53,11 @@ int SetPrivateSwitchOn(bool on); int SetOnceDebugOn(bool on); int SetPersistDebugOn(bool on); int SetGlobalLevel(uint16_t lvl); +int SetPersistGlobalLevel(uint16_t lvl); int SetTagLevel(const std::string& tag, uint16_t lvl); +int SetPersistTagLevel(const std::string& tag, uint16_t lvl); int SetDomainLevel(uint32_t domain, uint16_t lvl); +int SetPersistDomainLevel(uint32_t domain, uint16_t lvl); int SetProcessSwitchOn(bool on); int SetDomainSwitchOn(bool on); int SetKmsgSwitchOn(bool on); diff --git a/frameworks/libhilog/param/properties.cpp b/frameworks/libhilog/param/properties.cpp index 725924c..70247c7 100644 --- a/frameworks/libhilog/param/properties.cpp +++ b/frameworks/libhilog/param/properties.cpp @@ -47,8 +47,11 @@ enum class PropType { PROP_ONCE_DEBUG, PROP_PERSIST_DEBUG, PROP_GLOBAL_LOG_LEVEL, + PROP_PERSIST_GLOBAL_LOG_LEVEL, PROP_DOMAIN_LOG_LEVEL, + PROP_PERSIST_DOMAIN_LOG_LEVEL, PROP_TAG_LOG_LEVEL, + PROP_PERSIST_TAG_LOG_LEVEL, PROP_DOMAIN_FLOWCTRL, PROP_PROCESS_FLOWCTRL, @@ -74,8 +77,11 @@ static pthread_mutex_t g_privateLock = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t g_onceDebugLock = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t g_persistDebugLock = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t g_globalLevelLock = PTHREAD_MUTEX_INITIALIZER; +static pthread_mutex_t g_persistGlobalLevelLock = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t g_domainLevelLock = PTHREAD_MUTEX_INITIALIZER; +static pthread_mutex_t g_persistDomainLevelLock = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t g_tagLevelLock = PTHREAD_MUTEX_INITIALIZER; +static pthread_mutex_t g_persistTagLevelLock = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t g_domainFlowLock = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t g_processFlowLock = PTHREAD_MUTEX_INITIALIZER; static constexpr const char* HAP_DEBUGGABLE = "HAP_DEBUGGABLE"; @@ -90,8 +96,11 @@ static PropRes g_propResources[static_cast(PropType::PROP_MAX)] = { {"hilog.debug.on", &g_onceDebugLock}, // PROP_ONCE_DEBUG {"persist.sys.hilog.debug.on", &g_persistDebugLock}, // PROP_PERSIST_DEBUG {"hilog.loggable.global", &g_globalLevelLock}, // PROP_GLOBAL_LOG_LEVEL + {"persist.sys.hilog.loggable.global", &g_persistGlobalLevelLock}, // PROP_PERSIST_GLOBAL_LOG_LEVEL {"hilog.loggable.domain.", &g_domainLevelLock}, // PROP_DOMAIN_LOG_LEVEL + {"persist.sys.hilog.loggable.domain.", &g_persistDomainLevelLock}, // PROP_PERSIST_DOMAIN_LOG_LEVEL {"hilog.loggable.tag.", &g_tagLevelLock}, // PROP_TAG_LOG_LEVEL + {"persist.sys.hilog.loggable.tag.", &g_persistTagLevelLock}, // PROP_PERSIST_TAG_LOG_LEVEL {"hilog.flowctrl.domain.on", &g_domainFlowLock}, // PROP_DOMAIN_FLOWCTRL {"hilog.flowctrl.proc.on", &g_processFlowLock}, // PROP_PROCESS_FLOWCTRL @@ -332,6 +341,12 @@ uint16_t GetGlobalLevel() return logLevelCache->getValue(); } +uint16_t GetPersistGlobalLevel() +{ + static auto *logLevelCache = new LogLevelCache(TextToLogLevel, LOG_LEVEL_MIN, PropType::PROP_PERSIST_GLOBAL_LOG_LEVEL); + return logLevelCache->getValue(); +} + uint16_t GetDomainLevel(uint32_t domain) { static auto *domainMap = new std::unordered_map(); @@ -361,6 +376,35 @@ uint16_t GetDomainLevel(uint32_t domain) return levelCache->getValue(); } +uint16_t GetPersistDomainLevel(uint32_t domain) +{ + static auto *persistDomainMap = new std::unordered_map(); + static shared_timed_mutex* mtx = new shared_timed_mutex; + std::decay::type::iterator it; + { + ReadLock lock(*mtx); + it = persistDomainMap->find(domain); + if (it != persistDomainMap->end()) { + LogLevelCache* levelCache = it->second; + return levelCache->getValue(); + } + } + InsertLock lock(*mtx); + it = persistDomainMap->find(domain); // secured for two thread went across above condition + if (it == persistDomainMap->end()) { + LogLevelCache* levelCache = new LogLevelCache(TextToLogLevel, LOG_LEVEL_MIN, + PropType::PROP_PERSIST_DOMAIN_LOG_LEVEL, Uint2HexStr(domain)); + auto result = persistDomainMap->insert({ domain, levelCache }); + if (!result.second) { + delete levelCache; + return LOG_LEVEL_MIN; + } + it = result.first; + } + LogLevelCache* levelCache = it->second; + return levelCache->getValue(); +} + uint16_t GetTagLevel(const string& tag) { static auto *tagMap = new std::unordered_map(); @@ -390,6 +434,35 @@ uint16_t GetTagLevel(const string& tag) return levelCache->getValue(); } +uint16_t GetPersistTagLevel(const string& tag) +{ + static auto *persistTagMap = new std::unordered_map(); + static shared_timed_mutex* mtx = new shared_timed_mutex; + std::decay::type::iterator it; + { + ReadLock lock(*mtx); + it = persistTagMap->find(tag); + if (it != persistTagMap->end()) { + LogLevelCache* levelCache = it->second; + return levelCache->getValue(); + } + } + InsertLock lock(*mtx); + it = persistTagMap->find(tag); // secured for two thread went across above condition + if (it == persistTagMap->end()) { + LogLevelCache* levelCache = new LogLevelCache(TextToLogLevel, LOG_LEVEL_MIN, + PropType::PROP_PERSIST_TAG_LOG_LEVEL, tag); + auto result = persistTagMap->insert({ tag, levelCache }); + if (!result.second) { + delete levelCache; + return LOG_LEVEL_MIN; + } + it = result.first; + } + LogLevelCache* levelCache = it->second; + return levelCache->getValue(); +} + bool IsProcessSwitchOn() { static auto *switchCache = new SwitchCache(TextToBool, false, PropType::PROP_PROCESS_FLOWCTRL); @@ -524,16 +597,31 @@ int SetGlobalLevel(uint16_t lvl) return SetLevel(PropType::PROP_GLOBAL_LOG_LEVEL, "", lvl); } +int SetPersistGlobalLevel(uint16_t lvl) +{ + return SetLevel(PropType::PROP_PERSIST_GLOBAL_LOG_LEVEL, "", lvl); +} + int SetTagLevel(const std::string& tag, uint16_t lvl) { return SetLevel(PropType::PROP_TAG_LOG_LEVEL, tag, lvl); } +int SetPersistTagLevel(const std::string& tag, uint16_t lvl) +{ + return SetLevel(PropType::PROP_PERSIST_TAG_LOG_LEVEL, tag, lvl); +} + int SetDomainLevel(uint32_t domain, uint16_t lvl) { return SetLevel(PropType::PROP_DOMAIN_LOG_LEVEL, Uint2HexStr(domain), lvl); } +int SetPersistDomainLevel(uint32_t domain, uint16_t lvl) +{ + return SetLevel(PropType::PROP_PERSIST_DOMAIN_LOG_LEVEL, Uint2HexStr(domain), lvl); +} + int SetProcessSwitchOn(bool on) { return SetBoolValue(PropType::PROP_PROCESS_FLOWCTRL, on); diff --git a/interfaces/native/innerkits/libhilog.map b/interfaces/native/innerkits/libhilog.map index 0312d45..383a80c 100644 --- a/interfaces/native/innerkits/libhilog.map +++ b/interfaces/native/innerkits/libhilog.map @@ -46,9 +46,12 @@ "OHOS::HiviewDFX::LogIoctl::RequestOutput(OutputRqst const&, std::__h::function)"; "OHOS::HiviewDFX::PrettyStr2LogLevel(std::__h::basic_string, std::__h::allocator> const&)"; "OHOS::HiviewDFX::SetGlobalLevel(unsigned short)"; + "OHOS::HiviewDFX::SetPersistGlobalLevel(unsigned short)"; "OHOS::HiviewDFX::SetDomainLevel(unsigned int, unsigned short)"; + "OHOS::HiviewDFX::SetPersistDomainLevel(unsigned int, unsigned short)"; "OHOS::HiviewDFX::Uint2HexStr(unsigned int)"; "OHOS::HiviewDFX::SetTagLevel(std::__h::basic_string, std::__h::allocator> const&, unsigned short)"; + "OHOS::HiviewDFX::SetPersistTagLevel(std::__h::basic_string, std::__h::allocator> const&, unsigned short)"; "OHOS::HiviewDFX::Split(std::__h::basic_string, std::__h::allocator> const&, std::__h::vector, std::__h::allocator>, std::__h::allocator, std::__h::allocator>>>&, std::__h::basic_string, std::__h::allocator> const&)"; "OHOS::HiviewDFX::HexStr2Uint(std::__h::basic_string, std::__h::allocator> const&)"; "OHOS::HiviewDFX::ComboLogType2Str(unsigned short)"; @@ -87,6 +90,7 @@ "OHOS::HiviewDFX::IsProcessSwitchOn()"; "OHOS::HiviewDFX::ShortStr2LogLevel(std::__h::basic_string, std::__h::allocator> const&)"; "OHOS::HiviewDFX::GetGlobalLevel()"; + "OHOS::HiviewDFX::GetPersistGlobalLevel()"; "OHOS::HiviewDFX::GetDomainLevel(unsigned int)"; "OHOS::HiviewDFX::GetTagLevel(std::__h::basic_string, std::__h::allocator> const&)"; "OHOS::HiviewDFX::Str2LogType(std::__h::basic_string, std::__h::allocator> const&)"; diff --git a/services/hilogd/main.cpp b/services/hilogd/main.cpp index 7daa6bf..324efe3 100644 --- a/services/hilogd/main.cpp +++ b/services/hilogd/main.cpp @@ -215,6 +215,11 @@ int HilogdEntry() controlExecutor.MainLoop(CONTROL_SOCKET_NAME); }).detach(); + uint16_t persistGlobalLevel = GetPersistGlobalLevel(); + if (persistGlobalLevel != LOG_LEVEL_MIN) { + SetGlobalLevel(persistGlobalLevel); + } + CmdList outputList {IoctlCmd::OUTPUT_RQST}; CmdExecutor outputExecutor(logCollector, hilogBuffer, kmsgBuffer, outputList, ("hilogd.output")); outputExecutor.MainLoop(OUTPUT_SOCKET_NAME); diff --git a/services/hilogtool/main.cpp b/services/hilogtool/main.cpp index ddc77cc..892c257 100644 --- a/services/hilogtool/main.cpp +++ b/services/hilogtool/main.cpp @@ -314,6 +314,7 @@ struct HilogArgs { uint16_t levels; string stream; uint16_t fileNum; + bool persist; bool blackPid; int pidCount; uint32_t pids[MAX_PIDS]; @@ -331,10 +332,10 @@ struct HilogArgs { uint16_t tailLines; HilogArgs() : headLines (0), baseLevel(0), blackDomain(false), domainCount(0), domains { 0 }, regex(""), - fileName(""), buffSize(0), jobId(0), fileSize(0), levels(0), stream(""), fileNum(0), blackPid(false), - pidCount(0), pids { 0 }, types(0), blackTag(false), tagCount(0), tags { "" }, colorful(false), - timeFormat(FormatTime::INVALID), timeAccuFormat(FormatTimeAccu::INVALID), year(false), zone(false), - wrap(false), noBlock(false), tailLines(0) {} + fileName(""), buffSize(0), jobId(0), fileSize(0), levels(0), stream(""), fileNum(0), persist(false), + blackPid(false), pidCount(0), pids { 0 }, types(0), blackTag(false), tagCount(0), tags { "" }, + colorful(false), timeFormat(FormatTime::INVALID), timeAccuFormat(FormatTimeAccu::INVALID), + year(false), zone(false), wrap(false), noBlock(false), tailLines(0) {} void ToOutputRqst(OutputRqst& rqst) { @@ -468,17 +469,30 @@ static int BaseLogLevelHandler(HilogArgs& context, const char *arg) if (context.domainCount == 0 && context.tagCount == 0) { ret = SetGlobalLevel(context.baseLevel); PrintResult(ret, (string("Set global log level to ") + arg)); + if (context.persist) { + ret = SetPersistGlobalLevel(context.baseLevel); + PrintResult(ret, (string("Set persist global log level to ") + arg)); + } } if (context.domainCount != 0) { for (int i = 0; i < context.domainCount; i++) { ret = SetDomainLevel(context.domains[i], context.baseLevel); PrintResult(ret, (string("Set domain 0x") + Uint2HexStr(context.domains[i]) + " log level to " + arg)); + if (context.persist) { + ret = SetPersistDomainLevel(context.domains[i], context.baseLevel); + PrintResult(ret, (string("Set persist domain 0x") + + Uint2HexStr(context.domains[i]) + " log level to " + arg)); + } } } if (context.tagCount != 0) { for (int i = 0; i < context.tagCount; i++) { ret = SetTagLevel(context.tags[i], context.baseLevel); PrintResult(ret, (string("Set tag ") + context.tags[i] + " log level to " + arg)); + if (context.persist) { + ret = SetPersistTagLevel(context.tags[i], context.baseLevel); + PrintResult(ret, (string("Set persist tag ") + context.tags[i] + " log level to " + arg)); + } } } return RET_SUCCESS; @@ -517,6 +531,12 @@ static int RegexHandler(HilogArgs& context, const char *arg) return RET_SUCCESS; } +static int PersistHandler(HilogArgs& context, const char *arg) +{ + context.persist = true; + return RET_SUCCESS; +} + static int FileNameHandler(HilogArgs& context, const char *arg) { context.fileName = arg; @@ -1002,6 +1022,7 @@ static OptEntry optEntries[] = { {'b', "baselevel", ControlCmd::CMD_LOGLEVEL_SET, BaseLogLevelHandler, true, 1}, {'D', "domain", ControlCmd::NOT_CMD, DomainHandler, true, 1}, {'e', "regex", ControlCmd::NOT_CMD, RegexHandler, true, 1}, + {0, "persist", ControlCmd::NOT_CMD, PersistHandler, false, 1}, {'f', "filename", ControlCmd::NOT_CMD, FileNameHandler, true, 1}, {'g', nullptr, ControlCmd::CMD_BUFFER_SIZE_QUERY, BufferSizeGetHandler, false, 1}, {'G', "buffer-size", ControlCmd::CMD_BUFFER_SIZE_SET, BufferSizeSetHandler, true, 1}, @@ -1034,13 +1055,12 @@ static void GetOpts(string& opts, struct option(&longOptions)[OPT_ENTRY_CNT]) opts = ""; int i; for (i = 0; i < OPT_ENTRY_CNT; i++) { - if (optEntries[i].opt == 0) { - break; - } - // opts - opts += optEntries[i].opt; - if (optEntries[i].needArg) { - opts += ':'; + if (optEntries[i].opt != 0) { + // opts + opts += optEntries[i].opt; + if (optEntries[i].needArg) { + opts += ':'; + } } // long option if (optEntries[i].longOpt == nullptr) { -- Gitee