From 3aec59936425310912fff5d8ca3399dc306e0210 Mon Sep 17 00:00:00 2001 From: youyouyuai Date: Thu, 1 Jul 2021 10:02:20 +0000 Subject: [PATCH 1/4] property lock & log level Signed-off-by: youyouyuai --- adapter/properties.cpp | 99 +++++++++++++++++---------- services/hilogtool/log_controller.cpp | 57 ++++++++------- 2 files changed, 96 insertions(+), 60 deletions(-) diff --git a/adapter/properties.cpp b/adapter/properties.cpp index 1e6e91b..523cc2d 100644 --- a/adapter/properties.cpp +++ b/adapter/properties.cpp @@ -33,8 +33,6 @@ #include #include -#define HILOG_LEVEL_MIN LOG_LEVEL_MIN -#define HILOG_LEVEL_MAX LOG_LEVEL_MAX static pthread_mutex_t g_globalLevelLock = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t g_tagLevelLock = PTHREAD_MUTEX_INITIALIZER; @@ -84,7 +82,8 @@ void PropertySet(const std::string &key, const char* value) std::string GetProgName() { - return nullptr; /* use HOS interface */ + return nullptr; + /* use HOS interface */ } std::string GetPropertyName(uint32_t propType) @@ -188,6 +187,7 @@ static bool CheckCache(const PropertyCache *cache) /* use OHOS interface */ } + static bool GetSwitchCache(bool isFirst, SwitchCache& switchCache, uint32_t propType, bool defaultValue) { int notLocked; @@ -268,10 +268,40 @@ bool IsDomainSwitchOn() return GetSwitchCache(isFirst, switchCache, PROP_DOMAIN_FLOWCTRL, false); } +uint16_t GetCacheLevel(char propertyChar) +{ + uint16_t cacheLevel = LOG_LEVEL_MIN; + switch (propertyChar) { + case 'D': + case 'd': + cacheLevel = LOG_DEBUG; + break; + case 'I': + case 'i': + cacheLevel = LOG_INFO; + break; + case 'W': + case 'w': + cacheLevel = LOG_WARN; + break; + case 'E': + case 'e': + cacheLevel = LOG_ERROR; + break; + case 'F': + case 'f': + cacheLevel = LOG_FATAL; + break; + default: + break; + } + return cacheLevel; +} + uint16_t GetGlobalLevel() { std::string key = GetPropertyName(PROP_GLOBAL_LOG_LEVEL); - static LogLevelCache levelCache = {{nullptr, 0xffffffff, ""}, HILOG_LEVEL_MIN}; + static LogLevelCache levelCache = {{nullptr, 0xffffffff, ""}, LOG_LEVEL_MIN}; static std::atomic_flag isFirstFlag = ATOMIC_FLAG_INIT; int notLocked; @@ -279,18 +309,13 @@ uint16_t GetGlobalLevel() notLocked = LockByProp(PROP_GLOBAL_LOG_LEVEL); if (!notLocked) { RefreshCacheBuf(&levelCache.cache, key.c_str()); - if (sscanf_s(levelCache.cache.propertyValue, "%d", &levelCache.logLevel) <= 0) { - UnlockByProp(PROP_GLOBAL_LOG_LEVEL); - return HILOG_LEVEL_MIN; - } + levelCache.logLevel = GetCacheLevel(levelCache.cache.propertyValue[0]); UnlockByProp(PROP_GLOBAL_LOG_LEVEL); return levelCache.logLevel; } else { - LogLevelCache tmpCache = {{nullptr, 0xffffffff, ""}, HILOG_LEVEL_MIN}; + LogLevelCache tmpCache = {{nullptr, 0xffffffff, ""}, LOG_LEVEL_MIN}; RefreshCacheBuf(&tmpCache.cache, key.c_str()); - if (sscanf_s(tmpCache.cache.propertyValue, "%d", &tmpCache.logLevel) <= 0) { - return HILOG_LEVEL_MIN; - } + tmpCache.logLevel = GetCacheLevel(tmpCache.cache.propertyValue[0]); return tmpCache.logLevel; } } else { @@ -310,29 +335,31 @@ uint16_t GetDomainLevel(uint32_t domain) LogLevelCache* levelCache = new(LogLevelCache); levelCache->cache.pinfo = nullptr; levelCache->cache.serial = 0xffffffff; + levelCache->logLevel = LOG_LEVEL_MIN; RefreshCacheBuf(&levelCache->cache, key.c_str()); - if (sscanf_s(levelCache->cache.propertyValue, "%d", &levelCache->logLevel) <= 0) { - return HILOG_LEVEL_MIN; + levelCache->logLevel = GetCacheLevel(levelCache->cache.propertyValue[0]); + notLocked = LockByProp(PROP_DOMAIN_LOG_LEVEL); + if (!notLocked) { + domainMap.insert({ domain, levelCache }); + UnlockByProp(PROP_DOMAIN_LOG_LEVEL); + } else { + uint16_t level = levelCache->logLevel; + delete(levelCache); + return level; } - domainMap.insert({ domain, levelCache }); return levelCache->logLevel; } else { // exist domain if (CheckCache(&it->second->cache)) { // change notLocked = LockByProp(PROP_DOMAIN_LOG_LEVEL); if (!notLocked) { RefreshCacheBuf(&it->second->cache, key.c_str()); - if (sscanf_s(it->second->cache.propertyValue, "%d", &it->second->logLevel) <= 0) { - UnlockByProp(PROP_DOMAIN_LOG_LEVEL); - return HILOG_LEVEL_MIN; - } + it->second->logLevel = GetCacheLevel(it->second->cache.propertyValue[0]); UnlockByProp(PROP_DOMAIN_LOG_LEVEL); return it->second->logLevel; } else { - LogLevelCache tmpCache = {{nullptr, 0xffffffff, ""}, HILOG_LEVEL_MIN}; + LogLevelCache tmpCache = {{nullptr, 0xffffffff, ""}, LOG_LEVEL_MIN}; RefreshCacheBuf(&tmpCache.cache, key.c_str()); - if (sscanf_s(tmpCache.cache.propertyValue, "%d", &tmpCache.logLevel) <= 0) { - return HILOG_LEVEL_MIN; - } + tmpCache.logLevel = GetCacheLevel(tmpCache.cache.propertyValue[0]); return tmpCache.logLevel; } } else { // not change @@ -354,33 +381,35 @@ uint16_t GetTagLevel(const std::string& tag) LogLevelCache* levelCache = new(LogLevelCache); levelCache->cache.pinfo = nullptr; levelCache->cache.serial = 0xffffffff; + levelCache->logLevel = LOG_LEVEL_MIN; RefreshCacheBuf(&levelCache->cache, key.c_str()); - if (sscanf_s(levelCache->cache.propertyValue, "%d", &levelCache->logLevel) <= 0) { - return HILOG_LEVEL_MIN; + levelCache->logLevel = GetCacheLevel(levelCache->cache.propertyValue[0]); + notLocked = LockByProp(PROP_TAG_LOG_LEVEL); + if (!notLocked) { + tagMap.insert({ tagStr, levelCache }); + UnlockByProp(PROP_TAG_LOG_LEVEL); + } else { + uint16_t level = levelCache->logLevel; + delete(levelCache); + return level; } - tagMap.insert({ tagStr, levelCache }); return levelCache->logLevel; } else { if (CheckCache(&it->second->cache)) { notLocked = LockByProp(PROP_TAG_LOG_LEVEL); if (!notLocked) { RefreshCacheBuf(&it->second->cache, key.c_str()); - if (sscanf_s(it->second->cache.propertyValue, "%d", &it->second->logLevel) <= 0) { - UnlockByProp(PROP_TAG_LOG_LEVEL); - return HILOG_LEVEL_MIN; - } + it->second->logLevel = GetCacheLevel(it->second->cache.propertyValue[0]); UnlockByProp(PROP_TAG_LOG_LEVEL); return it->second->logLevel; } else { - LogLevelCache tmpCache = {{nullptr, 0xffffffff, ""}, HILOG_LEVEL_MIN}; + LogLevelCache tmpCache = {{nullptr, 0xffffffff, ""}, LOG_LEVEL_MIN}; RefreshCacheBuf(&tmpCache.cache, key.c_str()); - if (sscanf_s(tmpCache.cache.propertyValue, "%d", &tmpCache.logLevel) <= 0) { - return HILOG_LEVEL_MIN; - } + tmpCache.logLevel = GetCacheLevel(tmpCache.cache.propertyValue[0]); return tmpCache.logLevel; } } else { return it->second->logLevel; } } -} \ No newline at end of file +} diff --git a/services/hilogtool/log_controller.cpp b/services/hilogtool/log_controller.cpp index 1fb61fd..da5f5f9 100644 --- a/services/hilogtool/log_controller.cpp +++ b/services/hilogtool/log_controller.cpp @@ -107,21 +107,26 @@ uint64_t GetBuffSize(const string& buffSizeStr) } return buffSize; } -uint16_t GetLogLevel(const string& logLevelStr) + +uint16_t GetLogLevel(const std::string& logLevelStr, std::string& logLevel) { - if (logLevelStr == "debug" || logLevelStr == "DEBUG") { + if (logLevelStr == "debug" || logLevelStr == "DEBUG" || logLevelStr == "d" || logLevelStr == "D") { + logLevel = "D"; return LOG_DEBUG; - } else if (logLevelStr == "info" || logLevelStr == "INFO") { + } else if (logLevelStr == "info" || logLevelStr == "INFO" || logLevelStr == "i" || logLevelStr == "I") { + logLevel = "I"; return LOG_INFO; - } else if (logLevelStr == "warn" || logLevelStr == "WARN") { + } else if (logLevelStr == "warn" || logLevelStr == "WARN" || logLevelStr == "w" || logLevelStr == "W") { + logLevel = "W"; return LOG_WARN; - } else if (logLevelStr == "error" || logLevelStr == "ERROR") { + } else if (logLevelStr == "error" || logLevelStr == "ERROR" || logLevelStr == "e" || logLevelStr == "E") { + logLevel = "E"; return LOG_ERROR; - } else if (logLevelStr == "fatal" || logLevelStr == "FATAL") { + } else if (logLevelStr == "fatal" || logLevelStr == "FATAL" || logLevelStr == "f" || logLevelStr == "F") { + logLevel = "F"; return LOG_FATAL; - } else { - return 0xffff; - } + } + return 0xffff; } string SetDefaultLogType(const std::string& logTypeStr) @@ -464,22 +469,23 @@ int32_t SetPropertiesOp(SeqPacketSocketClient& controller, uint8_t operationType if (propertyParm->privateSwitchStr == "on") { PropertySet(key.c_str(), "true"); cout << "hilog private formatter is enabled" << endl; - } - if (propertyParm->privateSwitchStr == "off") { + } else if (propertyParm->privateSwitchStr == "off") { PropertySet(key.c_str(), "false"); cout << "hilog private formatter is disabled" << endl; + } else { + return RET_FAIL; } break; - case OT_LOG_LEVEL: - if ((propertyParm->tagStr != "" && propertyParm->domainStr != "") || GetLogLevel(propertyParm->logLevelStr) - == 0xffff) { + if (propertyParm->tagStr != "" && propertyParm->domainStr != "") { return RET_FAIL; } else if (propertyParm->domainStr != "") { // by domain std::string keyPre = GetPropertyName(PROP_DOMAIN_LOG_LEVEL); for (iter = 0; iter < domainNum; iter++) { key = keyPre + vecDomain[iter]; - value = to_string(GetLogLevel(propertyParm->logLevelStr)); + if (GetLogLevel(propertyParm->logLevelStr, value) == 0xffff) { + continue; + } PropertySet(key.c_str(), value.c_str()); cout << "domain " << vecDomain[iter] << " level is set to " << propertyParm->logLevelStr << endl; } @@ -487,41 +493,42 @@ int32_t SetPropertiesOp(SeqPacketSocketClient& controller, uint8_t operationType std::string keyPre = GetPropertyName(PROP_TAG_LOG_LEVEL); for (iter = 0; iter < tagNum; iter++) { key = keyPre + vecTag[iter]; - value = to_string(GetLogLevel(propertyParm->logLevelStr)); + if (GetLogLevel(propertyParm->logLevelStr, value) == 0xffff) { + continue; + } PropertySet(key.c_str(), value.c_str()); cout << "tag " << vecTag[iter] << " level is set to " << propertyParm->logLevelStr << endl; } } else { key = GetPropertyName(PROP_GLOBAL_LOG_LEVEL); - value = to_string(GetLogLevel(propertyParm->logLevelStr)); + if (GetLogLevel(propertyParm->logLevelStr, value) == 0xffff) { + return RET_FAIL; + } PropertySet(key.c_str(), value.c_str()); cout << "global log level is set to " << propertyParm->logLevelStr << endl; } break; - case OT_FLOW_SWITCH: if (propertyParm->flowSwitchStr == "pidon") { key = GetPropertyName(PROP_PROCESS_FLOWCTRL); PropertySet(key.c_str(), "true"); cout << "flow control by process is enabled" << endl; - } - if (propertyParm->flowSwitchStr == "pidoff") { + } else if (propertyParm->flowSwitchStr == "pidoff") { key = GetPropertyName(PROP_PROCESS_FLOWCTRL); PropertySet(key.c_str(), "false"); cout << "flow control by process is disabled" << endl; - } - if (propertyParm->flowSwitchStr == "domainon") { + } else if (propertyParm->flowSwitchStr == "domainon") { key = GetPropertyName(PROP_DOMAIN_FLOWCTRL); PropertySet(key.c_str(), "true"); cout << "flow control by domain is enabled" << endl; - } - if (propertyParm->flowSwitchStr == "domainoff") { + } else if (propertyParm->flowSwitchStr == "domainoff") { key = GetPropertyName(PROP_DOMAIN_FLOWCTRL); PropertySet(key.c_str(), "false"); cout << "flow control by domain is disabled" << endl; + } else { + return RET_FAIL; } break; - default: break; } -- Gitee From d92d3ede67152fb0e18242b5033a1e708d48f329 Mon Sep 17 00:00:00 2001 From: youyouyuai Date: Fri, 2 Jul 2021 01:52:40 +0000 Subject: [PATCH 2/4] codeing style Signed-off-by: youyouyuai --- adapter/properties.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/adapter/properties.cpp b/adapter/properties.cpp index 523cc2d..0eaa624 100644 --- a/adapter/properties.cpp +++ b/adapter/properties.cpp @@ -268,7 +268,7 @@ bool IsDomainSwitchOn() return GetSwitchCache(isFirst, switchCache, PROP_DOMAIN_FLOWCTRL, false); } -uint16_t GetCacheLevel(char propertyChar) +static uint16_t GetCacheLevel(char propertyChar) { uint16_t cacheLevel = LOG_LEVEL_MIN; switch (propertyChar) { -- Gitee From c568ddb132c90c85d4f65ef3fa5acf73ebc8dcfc Mon Sep 17 00:00:00 2001 From: youyouyuai Date: Tue, 6 Jul 2021 02:22:25 +0000 Subject: [PATCH 3/4] memory initial use new Signed-off-by: youyouyuai --- adapter/properties.cpp | 71 ++++++++++++++++++++---------------------- 1 file changed, 33 insertions(+), 38 deletions(-) diff --git a/adapter/properties.cpp b/adapter/properties.cpp index 0eaa624..e04d683 100644 --- a/adapter/properties.cpp +++ b/adapter/properties.cpp @@ -188,24 +188,23 @@ static bool CheckCache(const PropertyCache *cache) } -static bool GetSwitchCache(bool isFirst, SwitchCache& switchCache, uint32_t propType, bool defaultValue) +static bool GetSwitchCache(bool isFirst, SwitchCache* switchCache, uint32_t propType, bool defaultValue) { int notLocked; std::string key = GetPropertyName(propType); - - if (isFirst || CheckCache(&switchCache.cache)) { + if (isFirst || CheckCache(&switchCache->cache)) { notLocked = LockByProp(propType); if (!notLocked) { - RefreshCacheBuf(&switchCache.cache, key.c_str()); - if (strcmp(switchCache.cache.propertyValue, "true") == 0) { - switchCache.isOn = true; - } else if (strcmp(switchCache.cache.propertyValue, "false") == 0) { - switchCache.isOn = false; + RefreshCacheBuf(&switchCache->cache, key.c_str()); + if (strcmp(switchCache->cache.propertyValue, "true") == 0) { + switchCache->isOn = true; + } else if (strcmp(switchCache->cache.propertyValue, "false") == 0) { + switchCache->isOn = false; } else { - switchCache.isOn = defaultValue; + switchCache->isOn = defaultValue; } UnlockByProp(propType); - return switchCache.isOn; + return switchCache->isOn; } else { SwitchCache tmpCache = {{nullptr, 0xffffffff, ""}, defaultValue}; RefreshCacheBuf(&tmpCache.cache, key.c_str()); @@ -219,7 +218,7 @@ static bool GetSwitchCache(bool isFirst, SwitchCache& switchCache, uint32_t prop return tmpCache.isOn; } } else { - return switchCache.isOn; + return switchCache->isOn; } } @@ -230,7 +229,7 @@ bool IsDebugOn() bool IsSingleDebugOn() { - static SwitchCache switchCache = {{nullptr, 0xffffffff, ""}, false}; + static SwitchCache *switchCache = new SwitchCache{{nullptr, 0xffffffff, ""}, false}; static std::atomic_flag isFirstFlag = ATOMIC_FLAG_INIT; bool isFirst = !isFirstFlag.test_and_set(); return GetSwitchCache(isFirst, switchCache, PROP_SINGLE_DEBUG, false); @@ -238,7 +237,7 @@ bool IsSingleDebugOn() bool IsPersistDebugOn() { - static SwitchCache switchCache = {{nullptr, 0xffffffff, ""}, false}; + static SwitchCache *switchCache = new SwitchCache{{nullptr, 0xffffffff, ""}, false}; static std::atomic_flag isFirstFlag = ATOMIC_FLAG_INIT; bool isFirst = !isFirstFlag.test_and_set(); return GetSwitchCache(isFirst, switchCache, PROP_PERSIST_DEBUG, false); @@ -246,7 +245,7 @@ bool IsPersistDebugOn() bool IsPrivateSwitchOn() { - static SwitchCache switchCache = {{nullptr, 0xffffffff, ""}, true}; + static SwitchCache *switchCache = new SwitchCache{{nullptr, 0xffffffff, ""}, true}; static std::atomic_flag isFirstFlag = ATOMIC_FLAG_INIT; bool isFirst = !isFirstFlag.test_and_set(); return GetSwitchCache(isFirst, switchCache, PROP_PRIVATE, true); @@ -254,7 +253,7 @@ bool IsPrivateSwitchOn() bool IsProcessSwitchOn() { - static SwitchCache switchCache = {{nullptr, 0xffffffff, ""}, false}; + static SwitchCache *switchCache = new SwitchCache{{nullptr, 0xffffffff, ""}, false}; static std::atomic_flag isFirstFlag = ATOMIC_FLAG_INIT; bool isFirst = !isFirstFlag.test_and_set(); return GetSwitchCache(isFirst, switchCache, PROP_PROCESS_FLOWCTRL, false); @@ -262,7 +261,7 @@ bool IsProcessSwitchOn() bool IsDomainSwitchOn() { - static SwitchCache switchCache = {{nullptr, 0xffffffff, ""}, false}; + static SwitchCache *switchCache = new SwitchCache{{nullptr, 0xffffffff, ""}, false}; static std::atomic_flag isFirstFlag = ATOMIC_FLAG_INIT; bool isFirst = !isFirstFlag.test_and_set(); return GetSwitchCache(isFirst, switchCache, PROP_DOMAIN_FLOWCTRL, false); @@ -301,17 +300,17 @@ static uint16_t GetCacheLevel(char propertyChar) uint16_t GetGlobalLevel() { std::string key = GetPropertyName(PROP_GLOBAL_LOG_LEVEL); - static LogLevelCache levelCache = {{nullptr, 0xffffffff, ""}, LOG_LEVEL_MIN}; + static LogLevelCache *levelCache = new LogLevelCache{{nullptr, 0xffffffff, ""}, LOG_LEVEL_MIN}; static std::atomic_flag isFirstFlag = ATOMIC_FLAG_INIT; int notLocked; - if (!isFirstFlag.test_and_set() || CheckCache(&levelCache.cache)) { + if (!isFirstFlag.test_and_set() || CheckCache(&levelCache->cache)) { notLocked = LockByProp(PROP_GLOBAL_LOG_LEVEL); if (!notLocked) { - RefreshCacheBuf(&levelCache.cache, key.c_str()); - levelCache.logLevel = GetCacheLevel(levelCache.cache.propertyValue[0]); + RefreshCacheBuf(&levelCache->cache, key.c_str()); + levelCache->logLevel = GetCacheLevel(levelCache->cache.propertyValue[0]); UnlockByProp(PROP_GLOBAL_LOG_LEVEL); - return levelCache.logLevel; + return levelCache->logLevel; } else { LogLevelCache tmpCache = {{nullptr, 0xffffffff, ""}, LOG_LEVEL_MIN}; RefreshCacheBuf(&tmpCache.cache, key.c_str()); @@ -319,28 +318,26 @@ uint16_t GetGlobalLevel() return tmpCache.logLevel; } } else { - return levelCache.logLevel; + return levelCache->logLevel; } } uint16_t GetDomainLevel(uint32_t domain) { - static std::unordered_map domainMap; + static std::unordered_map *domainMap = new std::unordered_map(); std::unordered_map::iterator it; std::string key = GetPropertyName(PROP_DOMAIN_LOG_LEVEL) + std::to_string(domain); int notLocked; - it = domainMap.find(domain); - if (it == domainMap.end()) { // new domain - LogLevelCache* levelCache = new(LogLevelCache); - levelCache->cache.pinfo = nullptr; - levelCache->cache.serial = 0xffffffff; - levelCache->logLevel = LOG_LEVEL_MIN; + it = domainMap->find(domain); + if (it == domainMap->end()) { // new domain + LogLevelCache* levelCache = new LogLevelCache{{nullptr, 0xffffffff, ""}, LOG_LEVEL_MIN}; RefreshCacheBuf(&levelCache->cache, key.c_str()); levelCache->logLevel = GetCacheLevel(levelCache->cache.propertyValue[0]); notLocked = LockByProp(PROP_DOMAIN_LOG_LEVEL); if (!notLocked) { - domainMap.insert({ domain, levelCache }); + domainMap->insert({ domain, levelCache }); UnlockByProp(PROP_DOMAIN_LOG_LEVEL); } else { uint16_t level = levelCache->logLevel; @@ -370,23 +367,21 @@ uint16_t GetDomainLevel(uint32_t domain) uint16_t GetTagLevel(const std::string& tag) { - static std::unordered_map tagMap; + static std::unordered_map *tagMap = new std::unordered_map(); std::unordered_map::iterator it; std::string tagStr = tag; std::string key = GetPropertyName(PROP_TAG_LOG_LEVEL) + tagStr; int notLocked; - it = tagMap.find(tagStr); - if (it == tagMap.end()) { - LogLevelCache* levelCache = new(LogLevelCache); - levelCache->cache.pinfo = nullptr; - levelCache->cache.serial = 0xffffffff; - levelCache->logLevel = LOG_LEVEL_MIN; + it = tagMap->find(tagStr); + if (it == tagMap->end()) { + LogLevelCache* levelCache = new LogLevelCache{{nullptr, 0xffffffff, ""}, LOG_LEVEL_MIN}; RefreshCacheBuf(&levelCache->cache, key.c_str()); levelCache->logLevel = GetCacheLevel(levelCache->cache.propertyValue[0]); notLocked = LockByProp(PROP_TAG_LOG_LEVEL); if (!notLocked) { - tagMap.insert({ tagStr, levelCache }); + tagMap->insert({ tagStr, levelCache }); UnlockByProp(PROP_TAG_LOG_LEVEL); } else { uint16_t level = levelCache->logLevel; -- Gitee From 7192421e6da048339a5541e08099e3f385e9d98d Mon Sep 17 00:00:00 2001 From: youyouyuai Date: Tue, 6 Jul 2021 06:16:28 +0000 Subject: [PATCH 4/4] Revert "memory initial use new" This reverts commit c568ddb132c90c85d4f65ef3fa5acf73ebc8dcfc. --- adapter/properties.cpp | 71 ++++++++++++++++++++++-------------------- 1 file changed, 38 insertions(+), 33 deletions(-) diff --git a/adapter/properties.cpp b/adapter/properties.cpp index e04d683..0eaa624 100644 --- a/adapter/properties.cpp +++ b/adapter/properties.cpp @@ -188,23 +188,24 @@ static bool CheckCache(const PropertyCache *cache) } -static bool GetSwitchCache(bool isFirst, SwitchCache* switchCache, uint32_t propType, bool defaultValue) +static bool GetSwitchCache(bool isFirst, SwitchCache& switchCache, uint32_t propType, bool defaultValue) { int notLocked; std::string key = GetPropertyName(propType); - if (isFirst || CheckCache(&switchCache->cache)) { + + if (isFirst || CheckCache(&switchCache.cache)) { notLocked = LockByProp(propType); if (!notLocked) { - RefreshCacheBuf(&switchCache->cache, key.c_str()); - if (strcmp(switchCache->cache.propertyValue, "true") == 0) { - switchCache->isOn = true; - } else if (strcmp(switchCache->cache.propertyValue, "false") == 0) { - switchCache->isOn = false; + RefreshCacheBuf(&switchCache.cache, key.c_str()); + if (strcmp(switchCache.cache.propertyValue, "true") == 0) { + switchCache.isOn = true; + } else if (strcmp(switchCache.cache.propertyValue, "false") == 0) { + switchCache.isOn = false; } else { - switchCache->isOn = defaultValue; + switchCache.isOn = defaultValue; } UnlockByProp(propType); - return switchCache->isOn; + return switchCache.isOn; } else { SwitchCache tmpCache = {{nullptr, 0xffffffff, ""}, defaultValue}; RefreshCacheBuf(&tmpCache.cache, key.c_str()); @@ -218,7 +219,7 @@ static bool GetSwitchCache(bool isFirst, SwitchCache* switchCache, uint32_t prop return tmpCache.isOn; } } else { - return switchCache->isOn; + return switchCache.isOn; } } @@ -229,7 +230,7 @@ bool IsDebugOn() bool IsSingleDebugOn() { - static SwitchCache *switchCache = new SwitchCache{{nullptr, 0xffffffff, ""}, false}; + static SwitchCache switchCache = {{nullptr, 0xffffffff, ""}, false}; static std::atomic_flag isFirstFlag = ATOMIC_FLAG_INIT; bool isFirst = !isFirstFlag.test_and_set(); return GetSwitchCache(isFirst, switchCache, PROP_SINGLE_DEBUG, false); @@ -237,7 +238,7 @@ bool IsSingleDebugOn() bool IsPersistDebugOn() { - static SwitchCache *switchCache = new SwitchCache{{nullptr, 0xffffffff, ""}, false}; + static SwitchCache switchCache = {{nullptr, 0xffffffff, ""}, false}; static std::atomic_flag isFirstFlag = ATOMIC_FLAG_INIT; bool isFirst = !isFirstFlag.test_and_set(); return GetSwitchCache(isFirst, switchCache, PROP_PERSIST_DEBUG, false); @@ -245,7 +246,7 @@ bool IsPersistDebugOn() bool IsPrivateSwitchOn() { - static SwitchCache *switchCache = new SwitchCache{{nullptr, 0xffffffff, ""}, true}; + static SwitchCache switchCache = {{nullptr, 0xffffffff, ""}, true}; static std::atomic_flag isFirstFlag = ATOMIC_FLAG_INIT; bool isFirst = !isFirstFlag.test_and_set(); return GetSwitchCache(isFirst, switchCache, PROP_PRIVATE, true); @@ -253,7 +254,7 @@ bool IsPrivateSwitchOn() bool IsProcessSwitchOn() { - static SwitchCache *switchCache = new SwitchCache{{nullptr, 0xffffffff, ""}, false}; + static SwitchCache switchCache = {{nullptr, 0xffffffff, ""}, false}; static std::atomic_flag isFirstFlag = ATOMIC_FLAG_INIT; bool isFirst = !isFirstFlag.test_and_set(); return GetSwitchCache(isFirst, switchCache, PROP_PROCESS_FLOWCTRL, false); @@ -261,7 +262,7 @@ bool IsProcessSwitchOn() bool IsDomainSwitchOn() { - static SwitchCache *switchCache = new SwitchCache{{nullptr, 0xffffffff, ""}, false}; + static SwitchCache switchCache = {{nullptr, 0xffffffff, ""}, false}; static std::atomic_flag isFirstFlag = ATOMIC_FLAG_INIT; bool isFirst = !isFirstFlag.test_and_set(); return GetSwitchCache(isFirst, switchCache, PROP_DOMAIN_FLOWCTRL, false); @@ -300,17 +301,17 @@ static uint16_t GetCacheLevel(char propertyChar) uint16_t GetGlobalLevel() { std::string key = GetPropertyName(PROP_GLOBAL_LOG_LEVEL); - static LogLevelCache *levelCache = new LogLevelCache{{nullptr, 0xffffffff, ""}, LOG_LEVEL_MIN}; + static LogLevelCache levelCache = {{nullptr, 0xffffffff, ""}, LOG_LEVEL_MIN}; static std::atomic_flag isFirstFlag = ATOMIC_FLAG_INIT; int notLocked; - if (!isFirstFlag.test_and_set() || CheckCache(&levelCache->cache)) { + if (!isFirstFlag.test_and_set() || CheckCache(&levelCache.cache)) { notLocked = LockByProp(PROP_GLOBAL_LOG_LEVEL); if (!notLocked) { - RefreshCacheBuf(&levelCache->cache, key.c_str()); - levelCache->logLevel = GetCacheLevel(levelCache->cache.propertyValue[0]); + RefreshCacheBuf(&levelCache.cache, key.c_str()); + levelCache.logLevel = GetCacheLevel(levelCache.cache.propertyValue[0]); UnlockByProp(PROP_GLOBAL_LOG_LEVEL); - return levelCache->logLevel; + return levelCache.logLevel; } else { LogLevelCache tmpCache = {{nullptr, 0xffffffff, ""}, LOG_LEVEL_MIN}; RefreshCacheBuf(&tmpCache.cache, key.c_str()); @@ -318,26 +319,28 @@ uint16_t GetGlobalLevel() return tmpCache.logLevel; } } else { - return levelCache->logLevel; + return levelCache.logLevel; } } uint16_t GetDomainLevel(uint32_t domain) { - static std::unordered_map *domainMap = new std::unordered_map(); + static std::unordered_map domainMap; std::unordered_map::iterator it; std::string key = GetPropertyName(PROP_DOMAIN_LOG_LEVEL) + std::to_string(domain); int notLocked; - it = domainMap->find(domain); - if (it == domainMap->end()) { // new domain - LogLevelCache* levelCache = new LogLevelCache{{nullptr, 0xffffffff, ""}, LOG_LEVEL_MIN}; + it = domainMap.find(domain); + if (it == domainMap.end()) { // new domain + LogLevelCache* levelCache = new(LogLevelCache); + levelCache->cache.pinfo = nullptr; + levelCache->cache.serial = 0xffffffff; + levelCache->logLevel = LOG_LEVEL_MIN; RefreshCacheBuf(&levelCache->cache, key.c_str()); levelCache->logLevel = GetCacheLevel(levelCache->cache.propertyValue[0]); notLocked = LockByProp(PROP_DOMAIN_LOG_LEVEL); if (!notLocked) { - domainMap->insert({ domain, levelCache }); + domainMap.insert({ domain, levelCache }); UnlockByProp(PROP_DOMAIN_LOG_LEVEL); } else { uint16_t level = levelCache->logLevel; @@ -367,21 +370,23 @@ uint16_t GetDomainLevel(uint32_t domain) uint16_t GetTagLevel(const std::string& tag) { - static std::unordered_map *tagMap = new std::unordered_map(); + static std::unordered_map tagMap; std::unordered_map::iterator it; std::string tagStr = tag; std::string key = GetPropertyName(PROP_TAG_LOG_LEVEL) + tagStr; int notLocked; - it = tagMap->find(tagStr); - if (it == tagMap->end()) { - LogLevelCache* levelCache = new LogLevelCache{{nullptr, 0xffffffff, ""}, LOG_LEVEL_MIN}; + it = tagMap.find(tagStr); + if (it == tagMap.end()) { + LogLevelCache* levelCache = new(LogLevelCache); + levelCache->cache.pinfo = nullptr; + levelCache->cache.serial = 0xffffffff; + levelCache->logLevel = LOG_LEVEL_MIN; RefreshCacheBuf(&levelCache->cache, key.c_str()); levelCache->logLevel = GetCacheLevel(levelCache->cache.propertyValue[0]); notLocked = LockByProp(PROP_TAG_LOG_LEVEL); if (!notLocked) { - tagMap->insert({ tagStr, levelCache }); + tagMap.insert({ tagStr, levelCache }); UnlockByProp(PROP_TAG_LOG_LEVEL); } else { uint16_t level = levelCache->logLevel; -- Gitee