1 /*
2 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
3 * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without modification,
6 * are permitted provided that the following conditions are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice, this list of
9 * conditions and the following disclaimer.
10 *
11 * 2. Redistributions in binary form must reproduce the above copyright notice, this list
12 * of conditions and the following disclaimer in the documentation and/or other materials
13 * provided with the distribution.
14 *
15 * 3. Neither the name of the copyright holder nor the names of its contributors may be used
16 * to endorse or promote products derived from this software without specific prior written
17 * permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
21 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
26 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
27 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
28 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
29 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #include "los_base.h"
33 #ifdef LOSCFG_LIB_LIBC
34 #include "stdlib.h"
35 #include "unistd.h"
36 #endif
37 #include "los_hwi.h"
38 #include "los_memory_pri.h"
39 #include "los_process_pri.h"
40 #ifdef LOSCFG_FS_VFS
41 #include "console.h"
42 #endif
43 #ifdef LOSCFG_SHELL_DMESG
44 #include "dmesg_pri.h"
45 #endif
46 #ifdef LOSCFG_SAVE_EXCINFO
47 #include "los_excinfo_pri.h"
48 #endif
49 #include "los_exc_pri.h"
50 #include "los_sched_pri.h"
51
52 #define SIZEBUF 256
53
54 const CHAR *g_logString[] = {
55 "EMG",
56 "COMMON",
57 "ERR",
58 "WARN",
59 "INFO",
60 "DEBUG",
61 "TRACE"
62 };
63
OsLogLvGet(INT32 level)64 const CHAR *OsLogLvGet(INT32 level)
65 {
66 return g_logString[level];
67 }
68
ErrorMsg(VOID)69 STATIC VOID ErrorMsg(VOID)
70 {
71 const CHAR *p = "Output illegal string! vsnprintf_s failed!\n";
72 UartPuts(p, (UINT32)strlen(p), UART_WITH_LOCK);
73 }
74
UartOutput(const CHAR * str,UINT32 len,BOOL isLock)75 STATIC VOID UartOutput(const CHAR *str, UINT32 len, BOOL isLock)
76 {
77 #ifdef LOSCFG_SHELL_DMESG
78 if (!OsCheckUartLock()) {
79 UartPuts(str, len, isLock);
80 }
81 if (isLock != UART_WITHOUT_LOCK) {
82 (VOID)OsLogMemcpyRecord(str, len);
83 }
84 #else
85 UartPuts(str, len, isLock);
86 #endif
87 }
88
89 #ifdef LOSCFG_PLATFORM_CONSOLE
ConsoleOutput(const CHAR * str,UINT32 len)90 STATIC VOID ConsoleOutput(const CHAR *str, UINT32 len)
91 {
92 ssize_t written = 0;
93 ssize_t cnt;
94 ssize_t toWrite = len;
95
96 for (;;) {
97 cnt = write(STDOUT_FILENO, str + written, (size_t)toWrite);
98 if ((cnt < 0) || ((cnt == 0) && ((!OsPreemptable()) || (OS_INT_ACTIVE))) || (toWrite == cnt)) {
99 break;
100 }
101 written += cnt;
102 toWrite -= cnt;
103 }
104 }
105 #endif
106
OutputControl(const CHAR * str,UINT32 len,OutputType type)107 VOID OutputControl(const CHAR *str, UINT32 len, OutputType type)
108 {
109 switch (type) {
110 case CONSOLE_OUTPUT:
111 #ifdef LOSCFG_PLATFORM_CONSOLE
112 if (ConsoleEnable() == TRUE) {
113 ConsoleOutput(str, len);
114 break;
115 }
116 #endif
117 /* fall-through */
118 case UART_OUTPUT:
119 UartOutput(str, len, UART_WITH_LOCK);
120 break;
121 case EXC_OUTPUT:
122 UartPuts(str, len, UART_WITH_LOCK);
123 break;
124 default:
125 break;
126 }
127 return;
128 }
129
OsVprintfFree(CHAR * buf,UINT32 bufLen)130 STATIC VOID OsVprintfFree(CHAR *buf, UINT32 bufLen)
131 {
132 if (bufLen != SIZEBUF) {
133 (VOID)LOS_MemFree(m_aucSysMem0, buf);
134 }
135 }
136
OsVprintf(const CHAR * fmt,va_list ap,OutputType type)137 VOID OsVprintf(const CHAR *fmt, va_list ap, OutputType type)
138 {
139 INT32 len;
140 const CHAR *errMsgMalloc = "OsVprintf, malloc failed!\n";
141 const CHAR *errMsgLen = "OsVprintf, length overflow!\n";
142 CHAR aBuf[SIZEBUF] = {0};
143 CHAR *bBuf = NULL;
144 UINT32 bufLen = SIZEBUF;
145 UINT32 systemStatus;
146
147 bBuf = aBuf;
148 len = vsnprintf_s(bBuf, bufLen, bufLen - 1, fmt, ap);
149 if ((len == -1) && (*bBuf == '\0')) {
150 /* parameter is illegal or some features in fmt dont support */
151 ErrorMsg();
152 return;
153 }
154
155 while (len == -1) {
156 /* bBuf is not enough */
157 OsVprintfFree(bBuf, bufLen);
158
159 bufLen = bufLen << 1;
160 if ((INT32)bufLen <= 0) {
161 UartPuts(errMsgLen, (UINT32)strlen(errMsgLen), UART_WITH_LOCK);
162 return;
163 }
164 bBuf = (CHAR *)LOS_MemAlloc(m_aucSysMem0, bufLen);
165 if (bBuf == NULL) {
166 UartPuts(errMsgMalloc, (UINT32)strlen(errMsgMalloc), UART_WITH_LOCK);
167 return;
168 }
169 len = vsnprintf_s(bBuf, bufLen, bufLen - 1, fmt, ap);
170 if (*bBuf == '\0') {
171 /* parameter is illegal or some features in fmt dont support */
172 (VOID)LOS_MemFree(m_aucSysMem0, bBuf);
173 ErrorMsg();
174 return;
175 }
176 }
177 *(bBuf + len) = '\0';
178
179 systemStatus = OsGetSystemStatus();
180 if ((systemStatus == OS_SYSTEM_NORMAL) || (systemStatus == OS_SYSTEM_EXC_OTHER_CPU)) {
181 OutputControl(bBuf, len, type);
182 } else if (systemStatus == OS_SYSTEM_EXC_CURR_CPU) {
183 OutputControl(bBuf, len, EXC_OUTPUT);
184 }
185 OsVprintfFree(bBuf, bufLen);
186 }
187
UartVprintf(const CHAR * fmt,va_list ap)188 VOID UartVprintf(const CHAR *fmt, va_list ap)
189 {
190 OsVprintf(fmt, ap, UART_OUTPUT);
191 }
192
UartPrintf(const CHAR * fmt,...)193 __attribute__((noinline)) VOID UartPrintf(const CHAR *fmt, ...)
194 {
195 va_list ap;
196 va_start(ap, fmt);
197 OsVprintf(fmt, ap, UART_OUTPUT);
198 va_end(ap);
199 }
200
dprintf(const CHAR * fmt,...)201 __attribute__((noinline)) VOID dprintf(const CHAR *fmt, ...)
202 {
203 va_list ap;
204 va_start(ap, fmt);
205 OsVprintf(fmt, ap, CONSOLE_OUTPUT);
206 #ifdef LOSCFG_SAVE_EXCINFO
207 if (OsGetSystemStatus() == OS_SYSTEM_EXC_CURR_CPU) {
208 WriteExcBufVa(fmt, ap);
209 }
210 #endif
211 va_end(ap);
212 }
213
LkDprintf(const CHAR * fmt,va_list ap)214 VOID LkDprintf(const CHAR *fmt, va_list ap)
215 {
216 OsVprintf(fmt, ap, CONSOLE_OUTPUT);
217 #ifdef LOSCFG_SAVE_EXCINFO
218 if (OsGetSystemStatus() == OS_SYSTEM_EXC_CURR_CPU) {
219 WriteExcBufVa(fmt, ap);
220 }
221 #endif
222 }
223
224 #ifdef LOSCFG_SHELL_DMESG
DmesgPrintf(const CHAR * fmt,va_list ap)225 VOID DmesgPrintf(const CHAR *fmt, va_list ap)
226 {
227 OsVprintf(fmt, ap, CONSOLE_OUTPUT);
228 }
229 #endif
230
231 #ifdef LOSCFG_PLATFORM_UART_WITHOUT_VFS
printf(const CHAR * fmt,...)232 __attribute__((noinline)) INT32 printf(const CHAR *fmt, ...)
233 {
234 va_list ap;
235 va_start(ap, fmt);
236 OsVprintf(fmt, ap, UART_OUTPUT);
237 va_end(ap);
238 return 0;
239 }
240 #endif
241
syslog(INT32 level,const CHAR * fmt,...)242 __attribute__((noinline)) VOID syslog(INT32 level, const CHAR *fmt, ...)
243 {
244 va_list ap;
245 va_start(ap, fmt);
246 OsVprintf(fmt, ap, CONSOLE_OUTPUT);
247 va_end(ap);
248 (VOID)level;
249 }
250
ExcPrintf(const CHAR * fmt,...)251 __attribute__((noinline)) VOID ExcPrintf(const CHAR *fmt, ...)
252 {
253 va_list ap;
254 va_start(ap, fmt);
255 /* uart output without print-spinlock */
256 OsVprintf(fmt, ap, EXC_OUTPUT);
257 va_end(ap);
258 }
259
PrintExcInfo(const CHAR * fmt,...)260 VOID PrintExcInfo(const CHAR *fmt, ...)
261 {
262 va_list ap;
263 va_start(ap, fmt);
264 /* uart output without print-spinlock */
265 OsVprintf(fmt, ap, EXC_OUTPUT);
266 #ifdef LOSCFG_SAVE_EXCINFO
267 WriteExcBufVa(fmt, ap);
268 #endif
269 va_end(ap);
270 }
271
272 #ifndef LOSCFG_SHELL_LK
LOS_LkPrint(INT32 level,const CHAR * func,INT32 line,const CHAR * fmt,...)273 VOID LOS_LkPrint(INT32 level, const CHAR *func, INT32 line, const CHAR *fmt, ...)
274 {
275 va_list ap;
276
277 if (level > PRINT_LEVEL) {
278 return;
279 }
280
281 if ((level != LOS_COMMON_LEVEL) && ((level > LOS_EMG_LEVEL) && (level <= LOS_TRACE_LEVEL))) {
282 dprintf("[%s][%s:%s]", g_logString[level],
283 ((OsCurrProcessGet() == NULL) ? "NULL" : OsCurrProcessGet()->processName),
284 ((OsCurrTaskGet() == NULL) ? "NULL" : OsCurrTaskGet()->taskName));
285 }
286
287 va_start(ap, fmt);
288 OsVprintf(fmt, ap, CONSOLE_OUTPUT);
289 #ifdef LOSCFG_SAVE_EXCINFO
290 if (OsGetSystemStatus() == OS_SYSTEM_EXC_CURR_CPU) {
291 WriteExcBufVa(fmt, ap);
292 }
293 #endif
294 va_end(ap);
295 }
296 #endif
297
298