Line data Source code
1 : /**
2 : * Copyright (c) 2025 Huawei Technologies Co., Ltd.
3 : * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4 : * CANN Open Software License Agreement Version 2.0 (the "License").
5 : * Please refer to the License for details. You may not use this file except in compliance with the License.
6 : * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7 : * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8 : * See LICENSE in the root of the software repository for the full text of the License.
9 : */
10 :
11 : #include "log_inner.h"
12 :
13 : #include "base/err_msg.h"
14 :
15 : namespace acl {
16 : bool AclLog::isEnableEvent_ = false;
17 : constexpr size_t const ACL_LIMIT_PER_MESSAGE = 1024U;
18 :
19 6 : std::string AclGetErrorFormatMessage(const mmErrorMsg errnum)
20 : {
21 6 : char_t errBuff[acl::MAX_ERROR_STRING + 1U] = {};
22 6 : const auto msgPtr = mmGetErrorFormatMessage(errnum, &errBuff[0], acl::MAX_ERROR_STRING);
23 6 : const auto errMessage = (msgPtr == nullptr) ? "" : msgPtr;
24 12 : return std::string(errMessage);
25 : }
26 :
27 7569 : aclLogLevel AclLog::GetCurLogLevel()
28 : {
29 7569 : int32_t eventEnable = 0;
30 7569 : const int32_t dlogLevel = dlog_getlevel(ACL_MODE_ID, &eventEnable);
31 7569 : aclLogLevel curLevel = ACL_INFO;
32 7569 : switch (dlogLevel) {
33 1 : case DLOG_ERROR:
34 1 : curLevel = ACL_ERROR;
35 1 : break;
36 1 : case DLOG_WARN:
37 1 : curLevel = ACL_WARNING;
38 1 : break;
39 1 : case DLOG_INFO:
40 1 : curLevel = ACL_INFO;
41 1 : break;
42 7565 : case DLOG_DEBUG:
43 7565 : curLevel = ACL_DEBUG;
44 7565 : break;
45 1 : default:
46 1 : break;
47 : }
48 :
49 7569 : isEnableEvent_ = (eventEnable == 1); // Out put event enable
50 7569 : return curLevel;
51 : }
52 :
53 1739 : bool AclLog::IsEventLogOutputEnable()
54 : {
55 1739 : (void)AclLog::GetCurLogLevel();
56 1739 : return isEnableEvent_;
57 : }
58 :
59 5825 : bool AclLog::IsLogOutputEnable(const aclLogLevel logLevel)
60 : {
61 5825 : const aclLogLevel curLevel = AclLog::GetCurLogLevel();
62 5825 : return (curLevel <= logLevel);
63 : }
64 :
65 6602 : mmPid_t AclLog::GetTid()
66 : {
67 6602 : static const thread_local mmPid_t tid = static_cast<mmPid_t>(mmGetTid());
68 6602 : return tid;
69 : }
70 :
71 14 : void AclLog::ACLSaveLog(const aclLogLevel logLevel, const char_t *const strLog)
72 : {
73 14 : if (strLog == nullptr) {
74 0 : return;
75 : }
76 14 : switch (logLevel) {
77 6 : case ACL_ERROR:
78 6 : DlogRecord(APP_MODE_ID, DLOG_ERROR, "%s", strLog);
79 6 : break;
80 1 : case ACL_WARNING:
81 1 : DlogRecord(APP_MODE_ID, DLOG_WARN, "%s", strLog);
82 1 : break;
83 6 : case ACL_INFO:
84 6 : DlogRecord(APP_MODE_ID, DLOG_INFO, "%s", strLog);
85 6 : break;
86 1 : case ACL_DEBUG:
87 1 : DlogRecord(APP_MODE_ID, DLOG_DEBUG, "%s", strLog);
88 1 : break;
89 0 : default:
90 0 : break;
91 : }
92 : }
93 :
94 46 : std::string AclErrorLogManager::FormatStr(const char_t *const fmt, ...)
95 : {
96 46 : if (fmt == nullptr) {
97 2 : return "";
98 : }
99 :
100 : va_list ap;
101 45 : va_start(ap, fmt);
102 45 : char_t str[acl::MAX_LOG_STRING] = {};
103 45 : const int32_t printRet = vsnprintf_s(str, static_cast<size_t>(acl::MAX_LOG_STRING),
104 : static_cast<size_t>(acl::MAX_LOG_STRING - 1U), fmt, ap);
105 45 : if (printRet == -1) {
106 1 : va_end(ap);
107 2 : return "";
108 : }
109 44 : va_end(ap);
110 88 : return str;
111 : }
112 :
113 255 : void AclErrorLogManager::ReportInputError(const char *errorCode, const std::vector<const char *> &key,
114 : const std::vector<const char *> &val)
115 : {
116 255 : (void)REPORT_PREDEFINED_ERR_MSG(errorCode, key, val);
117 255 : }
118 :
119 1 : void AclErrorLogManager::ReportInnerError(const char_t *const fmt, ...)
120 : {
121 : va_list ap;
122 1 : va_start(ap, fmt);
123 1 : char_t errorMsgStr[ACL_LIMIT_PER_MESSAGE] = {};
124 1 : const int32_t ret = vsnprintf_s(errorMsgStr, static_cast<size_t>(ACL_LIMIT_PER_MESSAGE),
125 : static_cast<size_t>(ACL_LIMIT_PER_MESSAGE - 1U), fmt, ap);
126 1 : if (ret == -1) {
127 0 : va_end(ap);
128 0 : ACL_LOG_ERROR("[Call][Vsnprintf]call vsnprintf failed, ret = %d", ret);
129 0 : return;
130 : }
131 1 : va_end(ap);
132 1 : REPORT_INNER_ERR_MSG("EH9999", "%s", errorMsgStr);
133 : }
134 :
135 1 : void AclErrorLogManager::ReportCallError(const char_t *const fmt, ...)
136 : {
137 : va_list ap;
138 1 : va_start(ap, fmt);
139 1 : char_t errorMsgStr[ACL_LIMIT_PER_MESSAGE] = {};
140 1 : const int32_t ret = vsnprintf_s(errorMsgStr, static_cast<size_t>(ACL_LIMIT_PER_MESSAGE),
141 : static_cast<size_t>(ACL_LIMIT_PER_MESSAGE - 1U), fmt, ap);
142 1 : if (ret == -1) {
143 0 : va_end(ap);
144 0 : ACL_LOG_ERROR("[Call][Vsnprintf]call vsnprintf failed, ret = %d", ret);
145 0 : return;
146 : }
147 1 : va_end(ap);
148 1 : REPORT_INNER_ERR_MSG("EH9999", "%s", errorMsgStr);
149 : }
150 :
151 364 : void AclErrorLogManager::ReportInputErrorWithChar(const char_t *const errorCode, const char_t *const argNames[],
152 : const char_t *const argVals[], const size_t size)
153 : {
154 364 : std::vector<const char *> argNameArr;
155 364 : std::vector<const char *> argValArr;
156 1089 : for (size_t i = 0U; i < size; ++i) {
157 725 : argNameArr.push_back(argNames[i]);
158 725 : argValArr.push_back(argVals[i]);
159 : }
160 364 : (void)REPORT_PREDEFINED_ERR_MSG(errorCode, argNameArr, argValArr);
161 364 : }
162 :
163 463 : std::string AclErrorLogManager::GetFuncNameWithoutImplSuffix(const char_t *funcName)
164 : {
165 463 : constexpr size_t kAclPrefixLen = 3U;
166 463 : constexpr size_t kImplSuffixLen = 4U;
167 463 : std::string result = funcName;
168 919 : if ((result.size() >= kImplSuffixLen) && (result.compare(0, kAclPrefixLen, "acl") == 0) &&
169 456 : (result.compare(result.size() - kImplSuffixLen, kImplSuffixLen, "Impl") == 0)) {
170 410 : result.resize(result.size() - kImplSuffixLen);
171 : }
172 463 : return result;
173 0 : }
174 : } // namespace acl
|
