]>
git.ipfire.org Git - people/ms/u-boot.git/blob - common/log.c
4 * Copyright (c) 2017 Google, Inc
5 * Written by Simon Glass <sjg@chromium.org>
7 * SPDX-License-Identifier: GPL-2.0+
14 DECLARE_GLOBAL_DATA_PTR
;
16 static struct log_device
*log_device_find_by_name(const char *drv_name
)
18 struct log_device
*ldev
;
20 list_for_each_entry(ldev
, &gd
->log_head
, sibling_node
) {
21 if (!strcmp(drv_name
, ldev
->drv
->name
))
29 * log_has_cat() - check if a log category exists within a list
31 * @cat_list: List of categories to check, at most LOGF_MAX_CATEGORIES entries
32 * long, terminated by LC_END if fewer
33 * @cat: Category to search for
34 * @return true if @cat is in @cat_list, else false
36 static bool log_has_cat(enum log_category_t cat_list
[], enum log_category_t cat
)
40 for (i
= 0; i
< LOGF_MAX_CATEGORIES
&& cat_list
[i
] != LOGC_END
; i
++) {
41 if (cat_list
[i
] == cat
)
49 * log_has_file() - check if a file is with a list
51 * @file_list: List of files to check, separated by comma
52 * @file: File to check for. This string is matched against the end of each
53 * file in the list, i.e. ignoring any preceding path. The list is
54 * intended to consist of relative pathnames, e.g. common/main.c,cmd/log.c
55 * @return true if @file is in @file_list, else false
57 static bool log_has_file(const char *file_list
, const char *file
)
59 int file_len
= strlen(file
);
63 for (s
= file_list
; *s
; s
= p
+ (*p
!= '\0')) {
64 p
= strchrnul(s
, ',');
66 if (file_len
>= substr_len
&&
67 !strncmp(file
+ file_len
- substr_len
, s
, substr_len
))
75 * log_passes_filters() - check if a log record passes the filters for a device
77 * @ldev: Log device to check
78 * @rec: Log record to check
79 * @return true if @rec is not blocked by the filters in @ldev, false if it is
81 static bool log_passes_filters(struct log_device
*ldev
, struct log_rec
*rec
)
83 struct log_filter
*filt
;
85 /* If there are no filters, filter on the default log level */
86 if (list_empty(&ldev
->filter_head
)) {
87 if (rec
->level
> gd
->default_log_level
)
92 list_for_each_entry(filt
, &ldev
->filter_head
, sibling_node
) {
93 if (rec
->level
> filt
->max_level
)
95 if ((filt
->flags
& LOGFF_HAS_CAT
) &&
96 !log_has_cat(filt
->cat_list
, rec
->cat
))
98 if (filt
->file_list
&&
99 !log_has_file(filt
->file_list
, rec
->file
))
108 * log_dispatch() - Send a log record to all log devices for processing
110 * The log record is sent to each log device in turn, skipping those which have
111 * filters which block the record
113 * @rec: Log record to dispatch
114 * @return 0 (meaning success)
116 static int log_dispatch(struct log_rec
*rec
)
118 struct log_device
*ldev
;
120 list_for_each_entry(ldev
, &gd
->log_head
, sibling_node
) {
121 if (log_passes_filters(ldev
, rec
))
122 ldev
->drv
->emit(ldev
, rec
);
128 int _log(enum log_category_t cat
, enum log_level_t level
, const char *file
,
129 int line
, const char *func
, const char *fmt
, ...)
131 char buf
[CONFIG_SYS_CBSIZE
];
141 vsnprintf(buf
, sizeof(buf
), fmt
, args
);
144 if (!gd
|| !(gd
->flags
& GD_FLG_LOG_READY
)) {
146 gd
->log_drop_count
++;
154 int log_add_filter(const char *drv_name
, enum log_category_t cat_list
[],
155 enum log_level_t max_level
, const char *file_list
)
157 struct log_filter
*filt
;
158 struct log_device
*ldev
;
161 ldev
= log_device_find_by_name(drv_name
);
164 filt
= (struct log_filter
*)calloc(1, sizeof(*filt
));
169 filt
->flags
|= LOGFF_HAS_CAT
;
171 if (i
== ARRAY_SIZE(filt
->cat_list
))
173 filt
->cat_list
[i
] = cat_list
[i
];
174 if (cat_list
[i
] == LOGC_END
)
178 filt
->max_level
= max_level
;
180 filt
->file_list
= strdup(file_list
);
181 if (!filt
->file_list
)
184 filt
->filter_num
= ldev
->next_filter_num
++;
185 list_add_tail(&filt
->sibling_node
, &ldev
->filter_head
);
187 return filt
->filter_num
;
194 int log_remove_filter(const char *drv_name
, int filter_num
)
196 struct log_filter
*filt
;
197 struct log_device
*ldev
;
199 ldev
= log_device_find_by_name(drv_name
);
203 list_for_each_entry(filt
, &ldev
->filter_head
, sibling_node
) {
204 if (filt
->filter_num
== filter_num
) {
205 list_del(&filt
->sibling_node
);
217 struct log_driver
*drv
= ll_entry_start(struct log_driver
, log_driver
);
218 const int count
= ll_entry_count(struct log_driver
, log_driver
);
219 struct log_driver
*end
= drv
+ count
;
222 * We cannot add runtime data to the driver since it is likely stored
223 * in rodata. Instead, set up a 'device' corresponding to each driver.
224 * We only support having a single device.
226 INIT_LIST_HEAD((struct list_head
*)&gd
->log_head
);
228 struct log_device
*ldev
;
230 ldev
= calloc(1, sizeof(*ldev
));
232 debug("%s: Cannot allocate memory\n", __func__
);
235 INIT_LIST_HEAD(&ldev
->filter_head
);
237 list_add_tail(&ldev
->sibling_node
,
238 (struct list_head
*)&gd
->log_head
);
241 gd
->flags
|= GD_FLG_LOG_READY
;
242 gd
->default_log_level
= LOGL_INFO
;