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 7733 : aclLogLevel AclLog::GetCurLogLevel()
28 : {
29 7733 : int32_t eventEnable = 0;
30 7733 : const int32_t dlogLevel = dlog_getlevel(ACL_MODE_ID, &eventEnable);
31 7733 : aclLogLevel curLevel = ACL_INFO;
32 7733 : 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 7729 : case DLOG_DEBUG:
43 7729 : curLevel = ACL_DEBUG;
44 7729 : break;
45 1 : default:
46 1 : break;
47 : }
48 :
49 7733 : isEnableEvent_ = (eventEnable == 1); // Out put event enable
50 7733 : return curLevel;
51 : }
52 :
53 1739 : bool AclLog::IsEventLogOutputEnable()
54 : {
55 1739 : (void)AclLog::GetCurLogLevel();
56 1739 : return isEnableEvent_;
57 : }
58 :
59 5989 : bool AclLog::IsLogOutputEnable(const aclLogLevel logLevel)
60 : {
61 5989 : const aclLogLevel curLevel = AclLog::GetCurLogLevel();
62 5989 : return (curLevel <= logLevel);
63 : }
64 :
65 6795 : mmPid_t AclLog::GetTid()
66 : {
67 6795 : static const thread_local mmPid_t tid = static_cast<mmPid_t>(mmGetTid());
68 6795 : 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(
104 : str, static_cast<size_t>(acl::MAX_LOG_STRING), 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 272 : void AclErrorLogManager::ReportInputError(
114 : const char* errorCode, const std::vector<const char*>& key, const std::vector<const char*>& val)
115 : {
116 272 : (void)REPORT_PREDEFINED_ERR_MSG(errorCode, key, val);
117 272 : }
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(
125 : errorMsgStr, static_cast<size_t>(ACL_LIMIT_PER_MESSAGE), static_cast<size_t>(ACL_LIMIT_PER_MESSAGE - 1U), fmt,
126 : ap);
127 1 : if (ret == -1) {
128 0 : va_end(ap);
129 0 : ACL_LOG_ERROR("[Call][Vsnprintf]call vsnprintf failed, ret = %d", ret);
130 0 : return;
131 : }
132 1 : va_end(ap);
133 1 : REPORT_INNER_ERR_MSG("EH9999", "%s", errorMsgStr);
134 : }
135 :
136 1 : void AclErrorLogManager::ReportCallError(const char_t* const fmt, ...)
137 : {
138 : va_list ap;
139 1 : va_start(ap, fmt);
140 1 : char_t errorMsgStr[ACL_LIMIT_PER_MESSAGE] = {};
141 1 : const int32_t ret = vsnprintf_s(
142 : errorMsgStr, static_cast<size_t>(ACL_LIMIT_PER_MESSAGE), static_cast<size_t>(ACL_LIMIT_PER_MESSAGE - 1U), fmt,
143 : ap);
144 1 : if (ret == -1) {
145 0 : va_end(ap);
146 0 : ACL_LOG_ERROR("[Call][Vsnprintf]call vsnprintf failed, ret = %d", ret);
147 0 : return;
148 : }
149 1 : va_end(ap);
150 1 : REPORT_INNER_ERR_MSG("EH9999", "%s", errorMsgStr);
151 : }
152 :
153 372 : void AclErrorLogManager::ReportInputErrorWithChar(
154 : const char_t* const errorCode, const char_t* const argNames[], const char_t* const argVals[], const size_t size)
155 : {
156 372 : std::vector<const char*> argNameArr;
157 372 : std::vector<const char*> argValArr;
158 1113 : for (size_t i = 0U; i < size; ++i) {
159 741 : argNameArr.push_back(argNames[i]);
160 741 : argValArr.push_back(argVals[i]);
161 : }
162 372 : (void)REPORT_PREDEFINED_ERR_MSG(errorCode, argNameArr, argValArr);
163 372 : }
164 :
165 480 : std::string AclErrorLogManager::GetFuncNameWithoutImplSuffix(const char_t* funcName)
166 : {
167 480 : constexpr size_t kAclPrefixLen = 3U;
168 480 : constexpr size_t kImplSuffixLen = 4U;
169 480 : std::string result = funcName;
170 953 : if ((result.size() >= kImplSuffixLen) && (result.compare(0, kAclPrefixLen, "acl") == 0) &&
171 473 : (result.compare(result.size() - kImplSuffixLen, kImplSuffixLen, "Impl") == 0)) {
172 427 : result.resize(result.size() - kImplSuffixLen);
173 : }
174 480 : return result;
175 0 : }
176 : } // namespace acl
|
