1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Logging support
4 *
5 * Copyright (c) 2017 Google, Inc
6 * Written by Simon Glass <sjg@chromium.org>
7 */
8
9 #include <common.h>
10 #include <log.h>
11 #include <malloc.h>
12 #include <asm/global_data.h>
13 #include <dm/uclass.h>
14
15 DECLARE_GLOBAL_DATA_PTR;
16
17 static const char *const log_cat_name[] = {
18 "none",
19 "arch",
20 "board",
21 "core",
22 "driver-model",
23 "device-tree",
24 "efi",
25 "alloc",
26 "sandbox",
27 "bloblist",
28 "devres",
29 "acpi",
30 "boot",
31 };
32
33 _Static_assert(ARRAY_SIZE(log_cat_name) == LOGC_COUNT - LOGC_NONE,
34 "log_cat_name size");
35
36 static const char *const log_level_name[] = {
37 "EMERG",
38 "ALERT",
39 "CRIT",
40 "ERR",
41 "WARNING",
42 "NOTICE",
43 "INFO",
44 "DEBUG",
45 "CONTENT",
46 "IO",
47 };
48
49 _Static_assert(ARRAY_SIZE(log_level_name) == LOGL_COUNT, "log_level_name size");
50
51 /* All error responses MUST begin with '<' */
log_get_cat_name(enum log_category_t cat)52 const char *log_get_cat_name(enum log_category_t cat)
53 {
54 const char *name;
55
56 if (cat < 0 || cat >= LOGC_COUNT)
57 return "<invalid>";
58 if (cat >= LOGC_NONE)
59 return log_cat_name[cat - LOGC_NONE];
60
61 #if CONFIG_IS_ENABLED(DM)
62 name = uclass_get_name((enum uclass_id)cat);
63 #else
64 name = NULL;
65 #endif
66
67 return name ? name : "<missing>";
68 }
69
log_get_cat_by_name(const char * name)70 enum log_category_t log_get_cat_by_name(const char *name)
71 {
72 enum uclass_id id;
73 int i;
74
75 for (i = LOGC_NONE; i < LOGC_COUNT; i++)
76 if (!strcmp(name, log_cat_name[i - LOGC_NONE]))
77 return i;
78 id = uclass_get_by_name(name);
79 if (id != UCLASS_INVALID)
80 return (enum log_category_t)id;
81
82 return LOGC_NONE;
83 }
84
log_get_level_name(enum log_level_t level)85 const char *log_get_level_name(enum log_level_t level)
86 {
87 if (level >= LOGL_COUNT)
88 return "INVALID";
89 return log_level_name[level];
90 }
91
log_get_level_by_name(const char * name)92 enum log_level_t log_get_level_by_name(const char *name)
93 {
94 int i;
95
96 for (i = 0; i < LOGL_COUNT; i++) {
97 if (!strcasecmp(log_level_name[i], name))
98 return i;
99 }
100
101 return LOGL_NONE;
102 }
103
log_device_find_by_name(const char * drv_name)104 struct log_device *log_device_find_by_name(const char *drv_name)
105 {
106 struct log_device *ldev;
107
108 list_for_each_entry(ldev, &gd->log_head, sibling_node) {
109 if (!strcmp(drv_name, ldev->drv->name))
110 return ldev;
111 }
112
113 return NULL;
114 }
115
log_has_cat(enum log_category_t cat_list[],enum log_category_t cat)116 bool log_has_cat(enum log_category_t cat_list[], enum log_category_t cat)
117 {
118 int i;
119
120 for (i = 0; i < LOGF_MAX_CATEGORIES && cat_list[i] != LOGC_END; i++) {
121 if (cat_list[i] == cat)
122 return true;
123 }
124
125 return false;
126 }
127
log_has_file(const char * file_list,const char * file)128 bool log_has_file(const char *file_list, const char *file)
129 {
130 int file_len = strlen(file);
131 const char *s, *p;
132 int substr_len;
133
134 for (s = file_list; *s; s = p + (*p != '\0')) {
135 p = strchrnul(s, ',');
136 substr_len = p - s;
137 if (file_len >= substr_len &&
138 !strncmp(file + file_len - substr_len, s, substr_len))
139 return true;
140 }
141
142 return false;
143 }
144
145 /**
146 * log_passes_filters() - check if a log record passes the filters for a device
147 *
148 * @ldev: Log device to check
149 * @rec: Log record to check
150 * @return true if @rec is not blocked by the filters in @ldev, false if it is
151 */
log_passes_filters(struct log_device * ldev,struct log_rec * rec)152 static bool log_passes_filters(struct log_device *ldev, struct log_rec *rec)
153 {
154 struct log_filter *filt;
155
156 if (rec->flags & LOGRECF_FORCE_DEBUG)
157 return true;
158
159 /* If there are no filters, filter on the default log level */
160 if (list_empty(&ldev->filter_head)) {
161 if (rec->level > gd->default_log_level)
162 return false;
163 return true;
164 }
165
166 list_for_each_entry(filt, &ldev->filter_head, sibling_node) {
167 if (filt->flags & LOGFF_LEVEL_MIN) {
168 if (rec->level < filt->level)
169 continue;
170 } else if (rec->level > filt->level) {
171 continue;
172 }
173
174 if ((filt->flags & LOGFF_HAS_CAT) &&
175 !log_has_cat(filt->cat_list, rec->cat))
176 continue;
177
178 if (filt->file_list &&
179 !log_has_file(filt->file_list, rec->file))
180 continue;
181
182 if (filt->flags & LOGFF_DENY)
183 return false;
184 else
185 return true;
186 }
187
188 return false;
189 }
190
191 /**
192 * log_dispatch() - Send a log record to all log devices for processing
193 *
194 * The log record is sent to each log device in turn, skipping those which have
195 * filters which block the record.
196 *
197 * All log messages created while processing log record @rec are ignored.
198 *
199 * @rec: log record to dispatch
200 * Return: 0 msg sent, 1 msg not sent while already dispatching another msg
201 */
log_dispatch(struct log_rec * rec,const char * fmt,va_list args)202 static int log_dispatch(struct log_rec *rec, const char *fmt, va_list args)
203 {
204 struct log_device *ldev;
205 char buf[CONFIG_SYS_CBSIZE];
206
207 /*
208 * When a log driver writes messages (e.g. via the network stack) this
209 * may result in further generated messages. We cannot process them here
210 * as this might result in infinite recursion.
211 */
212 if (gd->processing_msg)
213 return 1;
214
215 /* Emit message */
216 gd->processing_msg = true;
217 list_for_each_entry(ldev, &gd->log_head, sibling_node) {
218 if ((ldev->flags & LOGDF_ENABLE) &&
219 log_passes_filters(ldev, rec)) {
220 if (!rec->msg) {
221 int len;
222
223 len = vsnprintf(buf, sizeof(buf), fmt, args);
224 rec->msg = buf;
225 gd->log_cont = len && buf[len - 1] != '\n';
226 }
227 ldev->drv->emit(ldev, rec);
228 }
229 }
230 gd->processing_msg = false;
231 return 0;
232 }
233
_log(enum log_category_t cat,enum log_level_t level,const char * file,int line,const char * func,const char * fmt,...)234 int _log(enum log_category_t cat, enum log_level_t level, const char *file,
235 int line, const char *func, const char *fmt, ...)
236 {
237 struct log_rec rec;
238 va_list args;
239
240 if (!gd)
241 return -ENOSYS;
242
243 /* Check for message continuation */
244 if (cat == LOGC_CONT)
245 cat = gd->logc_prev;
246 if (level == LOGL_CONT)
247 level = gd->logl_prev;
248
249 rec.cat = cat;
250 rec.level = level & LOGL_LEVEL_MASK;
251 rec.flags = 0;
252 if (level & LOGL_FORCE_DEBUG)
253 rec.flags |= LOGRECF_FORCE_DEBUG;
254 if (gd->log_cont)
255 rec.flags |= LOGRECF_CONT;
256 rec.file = file;
257 rec.line = line;
258 rec.func = func;
259 rec.msg = NULL;
260
261 if (!(gd->flags & GD_FLG_LOG_READY)) {
262 gd->log_drop_count++;
263
264 /* display dropped traces with console puts and DEBUG_UART */
265 if (rec.level <= CONFIG_LOG_DEFAULT_LEVEL ||
266 rec.flags & LOGRECF_FORCE_DEBUG) {
267 char buf[CONFIG_SYS_CBSIZE];
268
269 va_start(args, fmt);
270 vsnprintf(buf, sizeof(buf), fmt, args);
271 puts(buf);
272 va_end(args);
273 }
274
275 return -ENOSYS;
276 }
277 va_start(args, fmt);
278 if (!log_dispatch(&rec, fmt, args)) {
279 gd->logc_prev = cat;
280 gd->logl_prev = level;
281 }
282 va_end(args);
283
284 return 0;
285 }
286
log_add_filter_flags(const char * drv_name,enum log_category_t cat_list[],enum log_level_t level,const char * file_list,int flags)287 int log_add_filter_flags(const char *drv_name, enum log_category_t cat_list[],
288 enum log_level_t level, const char *file_list,
289 int flags)
290 {
291 struct log_filter *filt;
292 struct log_device *ldev;
293 int ret;
294 int i;
295
296 ldev = log_device_find_by_name(drv_name);
297 if (!ldev)
298 return -ENOENT;
299 filt = calloc(1, sizeof(*filt));
300 if (!filt)
301 return -ENOMEM;
302
303 filt->flags = flags;
304 if (cat_list) {
305 filt->flags |= LOGFF_HAS_CAT;
306 for (i = 0; ; i++) {
307 if (i == ARRAY_SIZE(filt->cat_list)) {
308 ret = -ENOSPC;
309 goto err;
310 }
311 filt->cat_list[i] = cat_list[i];
312 if (cat_list[i] == LOGC_END)
313 break;
314 }
315 }
316 filt->level = level;
317 if (file_list) {
318 filt->file_list = strdup(file_list);
319 if (!filt->file_list) {
320 ret = -ENOMEM;
321 goto err;
322 }
323 }
324 filt->filter_num = ldev->next_filter_num++;
325 /* Add deny filters to the beginning of the list */
326 if (flags & LOGFF_DENY)
327 list_add(&filt->sibling_node, &ldev->filter_head);
328 else
329 list_add_tail(&filt->sibling_node, &ldev->filter_head);
330
331 return filt->filter_num;
332
333 err:
334 free(filt);
335 return ret;
336 }
337
log_remove_filter(const char * drv_name,int filter_num)338 int log_remove_filter(const char *drv_name, int filter_num)
339 {
340 struct log_filter *filt;
341 struct log_device *ldev;
342
343 ldev = log_device_find_by_name(drv_name);
344 if (!ldev)
345 return -ENOENT;
346
347 list_for_each_entry(filt, &ldev->filter_head, sibling_node) {
348 if (filt->filter_num == filter_num) {
349 list_del(&filt->sibling_node);
350 free(filt);
351
352 return 0;
353 }
354 }
355
356 return -ENOENT;
357 }
358
359 /**
360 * log_find_device_by_drv() - Find a device by its driver
361 *
362 * @drv: Log driver
363 * @return Device associated with that driver, or NULL if not found
364 */
log_find_device_by_drv(struct log_driver * drv)365 static struct log_device *log_find_device_by_drv(struct log_driver *drv)
366 {
367 struct log_device *ldev;
368
369 list_for_each_entry(ldev, &gd->log_head, sibling_node) {
370 if (ldev->drv == drv)
371 return ldev;
372 }
373 /*
374 * It is quite hard to pass an invalid driver since passing an unknown
375 * LOG_GET_DRIVER(xxx) would normally produce a compilation error. But
376 * it is possible to pass NULL, for example, so this
377 */
378
379 return NULL;
380 }
381
log_device_set_enable(struct log_driver * drv,bool enable)382 int log_device_set_enable(struct log_driver *drv, bool enable)
383 {
384 struct log_device *ldev;
385
386 ldev = log_find_device_by_drv(drv);
387 if (!ldev)
388 return -ENOENT;
389 if (enable)
390 ldev->flags |= LOGDF_ENABLE;
391 else
392 ldev->flags &= ~LOGDF_ENABLE;
393
394 return 0;
395 }
396
log_init(void)397 int log_init(void)
398 {
399 struct log_driver *drv = ll_entry_start(struct log_driver, log_driver);
400 const int count = ll_entry_count(struct log_driver, log_driver);
401 struct log_driver *end = drv + count;
402
403 /*
404 * We cannot add runtime data to the driver since it is likely stored
405 * in rodata. Instead, set up a 'device' corresponding to each driver.
406 * We only support having a single device.
407 */
408 INIT_LIST_HEAD((struct list_head *)&gd->log_head);
409 while (drv < end) {
410 struct log_device *ldev;
411
412 ldev = calloc(1, sizeof(*ldev));
413 if (!ldev) {
414 debug("%s: Cannot allocate memory\n", __func__);
415 return -ENOMEM;
416 }
417 INIT_LIST_HEAD(&ldev->filter_head);
418 ldev->drv = drv;
419 ldev->flags = drv->flags;
420 list_add_tail(&ldev->sibling_node,
421 (struct list_head *)&gd->log_head);
422 drv++;
423 }
424 gd->flags |= GD_FLG_LOG_READY;
425 if (!gd->default_log_level)
426 gd->default_log_level = CONFIG_LOG_DEFAULT_LEVEL;
427 gd->log_fmt = log_get_default_format();
428 gd->logc_prev = LOGC_NONE;
429 gd->logl_prev = LOGL_INFO;
430
431 return 0;
432 }
433