1 // SPDX-License-Identifier: GPL-2.0+
5 * Copyright (c) 2017 Google, Inc
6 * Written by Simon Glass <sjg@chromium.org>
12 #include <dm/uclass.h>
14 DECLARE_GLOBAL_DATA_PTR;
16 static const char *const log_cat_name[] = {
32 _Static_assert(ARRAY_SIZE(log_cat_name) == LOGC_COUNT - LOGC_NONE,
35 static const char *const log_level_name[] = {
48 _Static_assert(ARRAY_SIZE(log_level_name) == LOGL_COUNT, "log_level_name size");
50 /* All error responses MUST begin with '<' */
51 const char *log_get_cat_name(enum log_category_t cat)
55 if (cat < 0 || cat >= LOGC_COUNT)
58 return log_cat_name[cat - LOGC_NONE];
60 #if CONFIG_IS_ENABLED(DM)
61 name = uclass_get_name((enum uclass_id)cat);
66 return name ? name : "<missing>";
69 enum log_category_t log_get_cat_by_name(const char *name)
74 for (i = LOGC_NONE; i < LOGC_COUNT; i++)
75 if (!strcmp(name, log_cat_name[i - LOGC_NONE]))
77 id = uclass_get_by_name(name);
78 if (id != UCLASS_INVALID)
79 return (enum log_category_t)id;
84 const char *log_get_level_name(enum log_level_t level)
86 if (level >= LOGL_COUNT)
88 return log_level_name[level];
91 enum log_level_t log_get_level_by_name(const char *name)
95 for (i = 0; i < LOGL_COUNT; i++) {
96 if (!strcasecmp(log_level_name[i], name))
103 struct log_device *log_device_find_by_name(const char *drv_name)
105 struct log_device *ldev;
107 list_for_each_entry(ldev, &gd->log_head, sibling_node) {
108 if (!strcmp(drv_name, ldev->drv->name))
115 bool log_has_cat(enum log_category_t cat_list[], enum log_category_t cat)
119 for (i = 0; i < LOGF_MAX_CATEGORIES && cat_list[i] != LOGC_END; i++) {
120 if (cat_list[i] == cat)
127 bool log_has_file(const char *file_list, const char *file)
129 int file_len = strlen(file);
133 for (s = file_list; *s; s = p + (*p != '\0')) {
134 p = strchrnul(s, ',');
136 if (file_len >= substr_len &&
137 !strncmp(file + file_len - substr_len, s, substr_len))
145 * log_passes_filters() - check if a log record passes the filters for a device
147 * @ldev: Log device to check
148 * @rec: Log record to check
149 * @return true if @rec is not blocked by the filters in @ldev, false if it is
151 static bool log_passes_filters(struct log_device *ldev, struct log_rec *rec)
153 struct log_filter *filt;
155 if (rec->force_debug)
158 /* If there are no filters, filter on the default log level */
159 if (list_empty(&ldev->filter_head)) {
160 if (rec->level > gd->default_log_level)
165 list_for_each_entry(filt, &ldev->filter_head, sibling_node) {
166 if (filt->flags & LOGFF_LEVEL_MIN) {
167 if (rec->level < filt->level)
169 } else if (rec->level > filt->level) {
173 if ((filt->flags & LOGFF_HAS_CAT) &&
174 !log_has_cat(filt->cat_list, rec->cat))
177 if (filt->file_list &&
178 !log_has_file(filt->file_list, rec->file))
181 if (filt->flags & LOGFF_DENY)
191 * log_dispatch() - Send a log record to all log devices for processing
193 * The log record is sent to each log device in turn, skipping those which have
194 * filters which block the record.
196 * All log messages created while processing log record @rec are ignored.
198 * @rec: log record to dispatch
199 * Return: 0 msg sent, 1 msg not sent while already dispatching another msg
201 static int log_dispatch(struct log_rec *rec, const char *fmt, va_list args)
203 struct log_device *ldev;
204 char buf[CONFIG_SYS_CBSIZE];
207 * When a log driver writes messages (e.g. via the network stack) this
208 * may result in further generated messages. We cannot process them here
209 * as this might result in infinite recursion.
211 if (gd->processing_msg)
215 gd->processing_msg = true;
216 list_for_each_entry(ldev, &gd->log_head, sibling_node) {
217 if ((ldev->flags & LOGDF_ENABLE) &&
218 log_passes_filters(ldev, rec)) {
220 vsnprintf(buf, sizeof(buf), fmt, args);
223 ldev->drv->emit(ldev, rec);
226 gd->processing_msg = false;
230 int _log(enum log_category_t cat, enum log_level_t level, const char *file,
231 int line, const char *func, const char *fmt, ...)
239 /* Check for message continuation */
240 if (cat == LOGC_CONT)
242 if (level == LOGL_CONT)
243 level = gd->logl_prev;
246 rec.level = level & LOGL_LEVEL_MASK;
247 rec.force_debug = level & LOGL_FORCE_DEBUG;
253 if (!(gd->flags & GD_FLG_LOG_READY)) {
254 gd->log_drop_count++;
256 /* display dropped traces with console puts and DEBUG_UART */
257 if (rec.level <= CONFIG_LOG_DEFAULT_LEVEL || rec.force_debug) {
258 char buf[CONFIG_SYS_CBSIZE];
261 vsnprintf(buf, sizeof(buf), fmt, args);
269 if (!log_dispatch(&rec, fmt, args)) {
271 gd->logl_prev = level;
278 int log_add_filter_flags(const char *drv_name, enum log_category_t cat_list[],
279 enum log_level_t level, const char *file_list,
282 struct log_filter *filt;
283 struct log_device *ldev;
287 ldev = log_device_find_by_name(drv_name);
290 filt = calloc(1, sizeof(*filt));
296 filt->flags |= LOGFF_HAS_CAT;
298 if (i == ARRAY_SIZE(filt->cat_list)) {
302 filt->cat_list[i] = cat_list[i];
303 if (cat_list[i] == LOGC_END)
309 filt->file_list = strdup(file_list);
310 if (!filt->file_list) {
315 filt->filter_num = ldev->next_filter_num++;
316 /* Add deny filters to the beginning of the list */
317 if (flags & LOGFF_DENY)
318 list_add(&filt->sibling_node, &ldev->filter_head);
320 list_add_tail(&filt->sibling_node, &ldev->filter_head);
322 return filt->filter_num;
329 int log_remove_filter(const char *drv_name, int filter_num)
331 struct log_filter *filt;
332 struct log_device *ldev;
334 ldev = log_device_find_by_name(drv_name);
338 list_for_each_entry(filt, &ldev->filter_head, sibling_node) {
339 if (filt->filter_num == filter_num) {
340 list_del(&filt->sibling_node);
351 * log_find_device_by_drv() - Find a device by its driver
354 * @return Device associated with that driver, or NULL if not found
356 static struct log_device *log_find_device_by_drv(struct log_driver *drv)
358 struct log_device *ldev;
360 list_for_each_entry(ldev, &gd->log_head, sibling_node) {
361 if (ldev->drv == drv)
365 * It is quite hard to pass an invalid driver since passing an unknown
366 * LOG_GET_DRIVER(xxx) would normally produce a compilation error. But
367 * it is possible to pass NULL, for example, so this
373 int log_device_set_enable(struct log_driver *drv, bool enable)
375 struct log_device *ldev;
377 ldev = log_find_device_by_drv(drv);
381 ldev->flags |= LOGDF_ENABLE;
383 ldev->flags &= ~LOGDF_ENABLE;
390 struct log_driver *drv = ll_entry_start(struct log_driver, log_driver);
391 const int count = ll_entry_count(struct log_driver, log_driver);
392 struct log_driver *end = drv + count;
395 * We cannot add runtime data to the driver since it is likely stored
396 * in rodata. Instead, set up a 'device' corresponding to each driver.
397 * We only support having a single device.
399 INIT_LIST_HEAD((struct list_head *)&gd->log_head);
401 struct log_device *ldev;
403 ldev = calloc(1, sizeof(*ldev));
405 debug("%s: Cannot allocate memory\n", __func__);
408 INIT_LIST_HEAD(&ldev->filter_head);
410 ldev->flags = drv->flags;
411 list_add_tail(&ldev->sibling_node,
412 (struct list_head *)&gd->log_head);
415 gd->flags |= GD_FLG_LOG_READY;
416 if (!gd->default_log_level)
417 gd->default_log_level = CONFIG_LOG_DEFAULT_LEVEL;
418 gd->log_fmt = log_get_default_format();
419 gd->logc_prev = LOGC_NONE;
420 gd->logl_prev = LOGL_INFO;