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 *log_cat_name[LOGC_COUNT - LOGC_NONE] = {
31 static const char *log_level_name[LOGL_COUNT] = {
44 const char *log_get_cat_name(enum log_category_t cat)
48 if (cat < 0 || cat >= LOGC_COUNT)
51 return log_cat_name[cat - LOGC_NONE];
53 #if CONFIG_IS_ENABLED(DM)
54 name = uclass_get_name((enum uclass_id)cat);
59 return name ? name : "<missing>";
62 enum log_category_t log_get_cat_by_name(const char *name)
67 for (i = LOGC_NONE; i < LOGC_COUNT; i++)
68 if (!strcmp(name, log_cat_name[i - LOGC_NONE]))
70 id = uclass_get_by_name(name);
71 if (id != UCLASS_INVALID)
72 return (enum log_category_t)id;
77 const char *log_get_level_name(enum log_level_t level)
79 if (level >= LOGL_COUNT)
81 return log_level_name[level];
84 enum log_level_t log_get_level_by_name(const char *name)
88 for (i = 0; i < LOGL_COUNT; i++) {
89 if (!strcasecmp(log_level_name[i], name))
96 static struct log_device *log_device_find_by_name(const char *drv_name)
98 struct log_device *ldev;
100 list_for_each_entry(ldev, &gd->log_head, sibling_node) {
101 if (!strcmp(drv_name, ldev->drv->name))
109 * log_has_cat() - check if a log category exists within a list
111 * @cat_list: List of categories to check, at most LOGF_MAX_CATEGORIES entries
112 * long, terminated by LC_END if fewer
113 * @cat: Category to search for
114 * @return true if @cat is in @cat_list, else false
116 static bool log_has_cat(enum log_category_t cat_list[], enum log_category_t cat)
120 for (i = 0; i < LOGF_MAX_CATEGORIES && cat_list[i] != LOGC_END; i++) {
121 if (cat_list[i] == cat)
129 * log_has_file() - check if a file is with a list
131 * @file_list: List of files to check, separated by comma
132 * @file: File to check for. This string is matched against the end of each
133 * file in the list, i.e. ignoring any preceding path. The list is
134 * intended to consist of relative pathnames, e.g. common/main.c,cmd/log.c
135 * @return true if @file is in @file_list, else false
137 static bool log_has_file(const char *file_list, const char *file)
139 int file_len = strlen(file);
143 for (s = file_list; *s; s = p + (*p != '\0')) {
144 p = strchrnul(s, ',');
146 if (file_len >= substr_len &&
147 !strncmp(file + file_len - substr_len, s, substr_len))
155 * log_passes_filters() - check if a log record passes the filters for a device
157 * @ldev: Log device to check
158 * @rec: Log record to check
159 * @return true if @rec is not blocked by the filters in @ldev, false if it is
161 static bool log_passes_filters(struct log_device *ldev, struct log_rec *rec)
163 struct log_filter *filt;
165 if (rec->force_debug)
168 /* If there are no filters, filter on the default log level */
169 if (list_empty(&ldev->filter_head)) {
170 if (rec->level > gd->default_log_level)
175 list_for_each_entry(filt, &ldev->filter_head, sibling_node) {
176 if (rec->level > filt->max_level)
178 if ((filt->flags & LOGFF_HAS_CAT) &&
179 !log_has_cat(filt->cat_list, rec->cat))
181 if (filt->file_list &&
182 !log_has_file(filt->file_list, rec->file))
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 * @rec: Log record to dispatch
197 * @return 0 (meaning success)
199 static int log_dispatch(struct log_rec *rec)
201 struct log_device *ldev;
204 * When a log driver writes messages (e.g. via the network stack) this
205 * may result in further generated messages. We cannot process them here
206 * as this might result in infinite recursion.
208 if (gd->processing_msg)
212 gd->processing_msg = true;
213 list_for_each_entry(ldev, &gd->log_head, sibling_node) {
214 if ((ldev->flags & LOGDF_ENABLE) &&
215 log_passes_filters(ldev, rec))
216 ldev->drv->emit(ldev, rec);
218 gd->processing_msg = false;
222 int _log(enum log_category_t cat, enum log_level_t level, const char *file,
223 int line, const char *func, const char *fmt, ...)
225 char buf[CONFIG_SYS_CBSIZE];
230 rec.level = level & LOGL_LEVEL_MASK;
231 rec.force_debug = level & LOGL_FORCE_DEBUG;
236 vsnprintf(buf, sizeof(buf), fmt, args);
239 if (!gd || !(gd->flags & GD_FLG_LOG_READY)) {
241 gd->log_drop_count++;
249 int log_add_filter(const char *drv_name, enum log_category_t cat_list[],
250 enum log_level_t max_level, const char *file_list)
252 struct log_filter *filt;
253 struct log_device *ldev;
257 ldev = log_device_find_by_name(drv_name);
260 filt = calloc(1, sizeof(*filt));
265 filt->flags |= LOGFF_HAS_CAT;
267 if (i == ARRAY_SIZE(filt->cat_list)) {
271 filt->cat_list[i] = cat_list[i];
272 if (cat_list[i] == LOGC_END)
276 filt->max_level = max_level;
278 filt->file_list = strdup(file_list);
279 if (!filt->file_list) {
284 filt->filter_num = ldev->next_filter_num++;
285 list_add_tail(&filt->sibling_node, &ldev->filter_head);
287 return filt->filter_num;
294 int log_remove_filter(const char *drv_name, int filter_num)
296 struct log_filter *filt;
297 struct log_device *ldev;
299 ldev = log_device_find_by_name(drv_name);
303 list_for_each_entry(filt, &ldev->filter_head, sibling_node) {
304 if (filt->filter_num == filter_num) {
305 list_del(&filt->sibling_node);
316 * log_find_device_by_drv() - Find a device by its driver
319 * @return Device associated with that driver, or NULL if not found
321 static struct log_device *log_find_device_by_drv(struct log_driver *drv)
323 struct log_device *ldev;
325 list_for_each_entry(ldev, &gd->log_head, sibling_node) {
326 if (ldev->drv == drv)
330 * It is quite hard to pass an invalid driver since passing an unknown
331 * LOG_GET_DRIVER(xxx) would normally produce a compilation error. But
332 * it is possible to pass NULL, for example, so this
338 int log_device_set_enable(struct log_driver *drv, bool enable)
340 struct log_device *ldev;
342 ldev = log_find_device_by_drv(drv);
346 ldev->flags |= LOGDF_ENABLE;
348 ldev->flags &= ~LOGDF_ENABLE;
355 struct log_driver *drv = ll_entry_start(struct log_driver, log_driver);
356 const int count = ll_entry_count(struct log_driver, log_driver);
357 struct log_driver *end = drv + count;
360 * We cannot add runtime data to the driver since it is likely stored
361 * in rodata. Instead, set up a 'device' corresponding to each driver.
362 * We only support having a single device.
364 INIT_LIST_HEAD((struct list_head *)&gd->log_head);
366 struct log_device *ldev;
368 ldev = calloc(1, sizeof(*ldev));
370 debug("%s: Cannot allocate memory\n", __func__);
373 INIT_LIST_HEAD(&ldev->filter_head);
375 ldev->flags = drv->flags;
376 list_add_tail(&ldev->sibling_node,
377 (struct list_head *)&gd->log_head);
380 gd->flags |= GD_FLG_LOG_READY;
381 if (!gd->default_log_level)
382 gd->default_log_level = CONFIG_LOG_DEFAULT_LEVEL;
383 gd->log_fmt = log_get_default_format();