]>
git.ipfire.org Git - thirdparty/u-boot.git/blob - common/log.c
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
] = {
26 static const char *log_level_name
[LOGL_COUNT
] = {
39 const char *log_get_cat_name(enum log_category_t cat
)
43 if (cat
< 0 || cat
>= LOGC_COUNT
)
46 return log_cat_name
[cat
- LOGC_NONE
];
48 name
= uclass_get_name((enum uclass_id
)cat
);
50 return name
? name
: "<missing>";
53 enum log_category_t
log_get_cat_by_name(const char *name
)
58 for (i
= LOGC_NONE
; i
< LOGC_COUNT
; i
++)
59 if (!strcmp(name
, log_cat_name
[i
- LOGC_NONE
]))
61 id
= uclass_get_by_name(name
);
62 if (id
!= UCLASS_INVALID
)
63 return (enum log_category_t
)id
;
68 const char *log_get_level_name(enum log_level_t level
)
70 if (level
>= LOGL_COUNT
)
72 return log_level_name
[level
];
75 enum log_level_t
log_get_level_by_name(const char *name
)
79 for (i
= 0; i
< LOGL_COUNT
; i
++) {
80 if (!strcasecmp(log_level_name
[i
], name
))
87 static struct log_device
*log_device_find_by_name(const char *drv_name
)
89 struct log_device
*ldev
;
91 list_for_each_entry(ldev
, &gd
->log_head
, sibling_node
) {
92 if (!strcmp(drv_name
, ldev
->drv
->name
))
100 * log_has_cat() - check if a log category exists within a list
102 * @cat_list: List of categories to check, at most LOGF_MAX_CATEGORIES entries
103 * long, terminated by LC_END if fewer
104 * @cat: Category to search for
105 * @return true if @cat is in @cat_list, else false
107 static bool log_has_cat(enum log_category_t cat_list
[], enum log_category_t cat
)
111 for (i
= 0; i
< LOGF_MAX_CATEGORIES
&& cat_list
[i
] != LOGC_END
; i
++) {
112 if (cat_list
[i
] == cat
)
120 * log_has_file() - check if a file is with a list
122 * @file_list: List of files to check, separated by comma
123 * @file: File to check for. This string is matched against the end of each
124 * file in the list, i.e. ignoring any preceding path. The list is
125 * intended to consist of relative pathnames, e.g. common/main.c,cmd/log.c
126 * @return true if @file is in @file_list, else false
128 static bool log_has_file(const char *file_list
, const char *file
)
130 int file_len
= strlen(file
);
134 for (s
= file_list
; *s
; s
= p
+ (*p
!= '\0')) {
135 p
= strchrnul(s
, ',');
137 if (file_len
>= substr_len
&&
138 !strncmp(file
+ file_len
- substr_len
, s
, substr_len
))
146 * log_passes_filters() - check if a log record passes the filters for a device
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
152 static bool log_passes_filters(struct log_device
*ldev
, struct log_rec
*rec
)
154 struct log_filter
*filt
;
156 /* If there are no filters, filter on the default log level */
157 if (list_empty(&ldev
->filter_head
)) {
158 if (rec
->level
> gd
->default_log_level
)
163 list_for_each_entry(filt
, &ldev
->filter_head
, sibling_node
) {
164 if (rec
->level
> filt
->max_level
)
166 if ((filt
->flags
& LOGFF_HAS_CAT
) &&
167 !log_has_cat(filt
->cat_list
, rec
->cat
))
169 if (filt
->file_list
&&
170 !log_has_file(filt
->file_list
, rec
->file
))
179 * log_dispatch() - Send a log record to all log devices for processing
181 * The log record is sent to each log device in turn, skipping those which have
182 * filters which block the record
184 * @rec: Log record to dispatch
185 * @return 0 (meaning success)
187 static int log_dispatch(struct log_rec
*rec
)
189 struct log_device
*ldev
;
191 list_for_each_entry(ldev
, &gd
->log_head
, sibling_node
) {
192 if (log_passes_filters(ldev
, rec
))
193 ldev
->drv
->emit(ldev
, rec
);
199 int _log(enum log_category_t cat
, enum log_level_t level
, const char *file
,
200 int line
, const char *func
, const char *fmt
, ...)
202 char buf
[CONFIG_SYS_CBSIZE
];
212 vsnprintf(buf
, sizeof(buf
), fmt
, args
);
215 if (!gd
|| !(gd
->flags
& GD_FLG_LOG_READY
)) {
217 gd
->log_drop_count
++;
225 int log_add_filter(const char *drv_name
, enum log_category_t cat_list
[],
226 enum log_level_t max_level
, const char *file_list
)
228 struct log_filter
*filt
;
229 struct log_device
*ldev
;
233 ldev
= log_device_find_by_name(drv_name
);
236 filt
= (struct log_filter
*)calloc(1, sizeof(*filt
));
241 filt
->flags
|= LOGFF_HAS_CAT
;
243 if (i
== ARRAY_SIZE(filt
->cat_list
)) {
247 filt
->cat_list
[i
] = cat_list
[i
];
248 if (cat_list
[i
] == LOGC_END
)
252 filt
->max_level
= max_level
;
254 filt
->file_list
= strdup(file_list
);
255 if (!filt
->file_list
) {
260 filt
->filter_num
= ldev
->next_filter_num
++;
261 list_add_tail(&filt
->sibling_node
, &ldev
->filter_head
);
263 return filt
->filter_num
;
270 int log_remove_filter(const char *drv_name
, int filter_num
)
272 struct log_filter
*filt
;
273 struct log_device
*ldev
;
275 ldev
= log_device_find_by_name(drv_name
);
279 list_for_each_entry(filt
, &ldev
->filter_head
, sibling_node
) {
280 if (filt
->filter_num
== filter_num
) {
281 list_del(&filt
->sibling_node
);
293 struct log_driver
*drv
= ll_entry_start(struct log_driver
, log_driver
);
294 const int count
= ll_entry_count(struct log_driver
, log_driver
);
295 struct log_driver
*end
= drv
+ count
;
298 * We cannot add runtime data to the driver since it is likely stored
299 * in rodata. Instead, set up a 'device' corresponding to each driver.
300 * We only support having a single device.
302 INIT_LIST_HEAD((struct list_head
*)&gd
->log_head
);
304 struct log_device
*ldev
;
306 ldev
= calloc(1, sizeof(*ldev
));
308 debug("%s: Cannot allocate memory\n", __func__
);
311 INIT_LIST_HEAD(&ldev
->filter_head
);
313 list_add_tail(&ldev
->sibling_node
,
314 (struct list_head
*)&gd
->log_head
);
317 gd
->flags
|= GD_FLG_LOG_READY
;
318 if (!gd
->default_log_level
)
319 gd
->default_log_level
= CONFIG_LOG_DEFAULT_LEVEL
;
320 gd
->log_fmt
= LOGF_DEFAULT
;