blob: 680a60f86e819888e2891085d9a8179f4052d8b3 [file] [log] [blame]
Simon Glasse9c8d492017-12-04 13:48:24 -07001/*
2 * Logging support
3 *
4 * Copyright (c) 2017 Google, Inc
5 * Written by Simon Glass <sjg@chromium.org>
6 *
7 * SPDX-License-Identifier: GPL-2.0+
8 */
9
10#include <common.h>
11#include <log.h>
12#include <malloc.h>
Simon Glassf941c8d2017-12-28 13:14:16 -070013#include <dm/uclass.h>
Simon Glasse9c8d492017-12-04 13:48:24 -070014
15DECLARE_GLOBAL_DATA_PTR;
16
Simon Glassf941c8d2017-12-28 13:14:16 -070017static const char *log_cat_name[LOGC_COUNT - LOGC_NONE] = {
18 "none",
19 "arch",
20 "board",
21 "core",
22 "driver-model",
23 "device-tree",
Heinrich Schuchardt1973b382018-01-22 20:10:45 +010024 "efi",
Simon Glassf941c8d2017-12-28 13:14:16 -070025};
26
27static const char *log_level_name[LOGL_COUNT] = {
28 "EMERG",
29 "ALERT",
30 "CRIT",
31 "ERR",
32 "WARNING",
33 "NOTICE",
34 "INFO",
35 "DEBUG",
36 "CONTENT",
37 "IO",
38};
39
40const char *log_get_cat_name(enum log_category_t cat)
41{
42 if (cat > LOGC_COUNT)
43 return "invalid";
44 if (cat >= LOGC_NONE)
45 return log_cat_name[cat - LOGC_NONE];
46
47 return uclass_get_name((enum uclass_id)cat);
48}
49
50enum log_category_t log_get_cat_by_name(const char *name)
51{
52 enum uclass_id id;
53 int i;
54
55 for (i = LOGC_NONE; i < LOGC_COUNT; i++)
56 if (!strcmp(name, log_cat_name[i - LOGC_NONE]))
57 return i;
58 id = uclass_get_by_name(name);
59 if (id != UCLASS_INVALID)
60 return (enum log_category_t)id;
61
62 return LOGC_NONE;
63}
64
65const char *log_get_level_name(enum log_level_t level)
66{
67 if (level >= LOGL_COUNT)
68 return "INVALID";
69 return log_level_name[level];
70}
71
72enum log_level_t log_get_level_by_name(const char *name)
73{
74 int i;
75
76 for (i = 0; i < LOGL_COUNT; i++) {
77 if (!strcasecmp(log_level_name[i], name))
78 return i;
79 }
80
81 return LOGL_NONE;
82}
83
Simon Glasse9c8d492017-12-04 13:48:24 -070084static struct log_device *log_device_find_by_name(const char *drv_name)
85{
86 struct log_device *ldev;
87
88 list_for_each_entry(ldev, &gd->log_head, sibling_node) {
89 if (!strcmp(drv_name, ldev->drv->name))
90 return ldev;
91 }
92
93 return NULL;
94}
95
96/**
97 * log_has_cat() - check if a log category exists within a list
98 *
99 * @cat_list: List of categories to check, at most LOGF_MAX_CATEGORIES entries
100 * long, terminated by LC_END if fewer
101 * @cat: Category to search for
102 * @return true if @cat is in @cat_list, else false
103 */
104static bool log_has_cat(enum log_category_t cat_list[], enum log_category_t cat)
105{
106 int i;
107
108 for (i = 0; i < LOGF_MAX_CATEGORIES && cat_list[i] != LOGC_END; i++) {
109 if (cat_list[i] == cat)
110 return true;
111 }
112
113 return false;
114}
115
116/**
117 * log_has_file() - check if a file is with a list
118 *
119 * @file_list: List of files to check, separated by comma
120 * @file: File to check for. This string is matched against the end of each
121 * file in the list, i.e. ignoring any preceding path. The list is
122 * intended to consist of relative pathnames, e.g. common/main.c,cmd/log.c
123 * @return true if @file is in @file_list, else false
124 */
125static bool log_has_file(const char *file_list, const char *file)
126{
127 int file_len = strlen(file);
128 const char *s, *p;
129 int substr_len;
130
131 for (s = file_list; *s; s = p + (*p != '\0')) {
132 p = strchrnul(s, ',');
133 substr_len = p - s;
134 if (file_len >= substr_len &&
135 !strncmp(file + file_len - substr_len, s, substr_len))
136 return true;
137 }
138
139 return false;
140}
141
142/**
143 * log_passes_filters() - check if a log record passes the filters for a device
144 *
145 * @ldev: Log device to check
146 * @rec: Log record to check
147 * @return true if @rec is not blocked by the filters in @ldev, false if it is
148 */
149static bool log_passes_filters(struct log_device *ldev, struct log_rec *rec)
150{
151 struct log_filter *filt;
152
153 /* If there are no filters, filter on the default log level */
154 if (list_empty(&ldev->filter_head)) {
155 if (rec->level > gd->default_log_level)
156 return false;
157 return true;
158 }
159
160 list_for_each_entry(filt, &ldev->filter_head, sibling_node) {
161 if (rec->level > filt->max_level)
162 continue;
163 if ((filt->flags & LOGFF_HAS_CAT) &&
164 !log_has_cat(filt->cat_list, rec->cat))
165 continue;
166 if (filt->file_list &&
167 !log_has_file(filt->file_list, rec->file))
168 continue;
169 return true;
170 }
171
172 return false;
173}
174
175/**
176 * log_dispatch() - Send a log record to all log devices for processing
177 *
178 * The log record is sent to each log device in turn, skipping those which have
179 * filters which block the record
180 *
181 * @rec: Log record to dispatch
182 * @return 0 (meaning success)
183 */
184static int log_dispatch(struct log_rec *rec)
185{
186 struct log_device *ldev;
187
188 list_for_each_entry(ldev, &gd->log_head, sibling_node) {
189 if (log_passes_filters(ldev, rec))
190 ldev->drv->emit(ldev, rec);
191 }
192
193 return 0;
194}
195
196int _log(enum log_category_t cat, enum log_level_t level, const char *file,
197 int line, const char *func, const char *fmt, ...)
198{
199 char buf[CONFIG_SYS_CBSIZE];
200 struct log_rec rec;
201 va_list args;
202
203 rec.cat = cat;
204 rec.level = level;
205 rec.file = file;
206 rec.line = line;
207 rec.func = func;
208 va_start(args, fmt);
209 vsnprintf(buf, sizeof(buf), fmt, args);
210 va_end(args);
211 rec.msg = buf;
212 if (!gd || !(gd->flags & GD_FLG_LOG_READY)) {
213 if (gd)
214 gd->log_drop_count++;
215 return -ENOSYS;
216 }
217 log_dispatch(&rec);
218
219 return 0;
220}
221
222int log_add_filter(const char *drv_name, enum log_category_t cat_list[],
223 enum log_level_t max_level, const char *file_list)
224{
225 struct log_filter *filt;
226 struct log_device *ldev;
227 int i;
228
229 ldev = log_device_find_by_name(drv_name);
230 if (!ldev)
231 return -ENOENT;
232 filt = (struct log_filter *)calloc(1, sizeof(*filt));
233 if (!filt)
234 return -ENOMEM;
235
236 if (cat_list) {
237 filt->flags |= LOGFF_HAS_CAT;
238 for (i = 0; ; i++) {
239 if (i == ARRAY_SIZE(filt->cat_list))
240 return -ENOSPC;
241 filt->cat_list[i] = cat_list[i];
242 if (cat_list[i] == LOGC_END)
243 break;
244 }
245 }
246 filt->max_level = max_level;
247 if (file_list) {
248 filt->file_list = strdup(file_list);
249 if (!filt->file_list)
250 goto nomem;
251 }
252 filt->filter_num = ldev->next_filter_num++;
253 list_add_tail(&filt->sibling_node, &ldev->filter_head);
254
255 return filt->filter_num;
256
257nomem:
258 free(filt);
259 return -ENOMEM;
260}
261
262int log_remove_filter(const char *drv_name, int filter_num)
263{
264 struct log_filter *filt;
265 struct log_device *ldev;
266
267 ldev = log_device_find_by_name(drv_name);
268 if (!ldev)
269 return -ENOENT;
270
271 list_for_each_entry(filt, &ldev->filter_head, sibling_node) {
272 if (filt->filter_num == filter_num) {
273 list_del(&filt->sibling_node);
274 free(filt);
275
276 return 0;
277 }
278 }
279
280 return -ENOENT;
281}
282
283int log_init(void)
284{
285 struct log_driver *drv = ll_entry_start(struct log_driver, log_driver);
286 const int count = ll_entry_count(struct log_driver, log_driver);
287 struct log_driver *end = drv + count;
288
289 /*
290 * We cannot add runtime data to the driver since it is likely stored
291 * in rodata. Instead, set up a 'device' corresponding to each driver.
292 * We only support having a single device.
293 */
294 INIT_LIST_HEAD((struct list_head *)&gd->log_head);
295 while (drv < end) {
296 struct log_device *ldev;
297
298 ldev = calloc(1, sizeof(*ldev));
299 if (!ldev) {
300 debug("%s: Cannot allocate memory\n", __func__);
301 return -ENOMEM;
302 }
303 INIT_LIST_HEAD(&ldev->filter_head);
304 ldev->drv = drv;
305 list_add_tail(&ldev->sibling_node,
306 (struct list_head *)&gd->log_head);
307 drv++;
308 }
Simon Glassaf1bc0c2017-12-04 13:48:28 -0700309 gd->flags |= GD_FLG_LOG_READY;
Simon Glasse9c8d492017-12-04 13:48:24 -0700310 gd->default_log_level = LOGL_INFO;
Simon Glass3b73e8d2017-12-28 13:14:17 -0700311 gd->log_fmt = LOGF_DEFAULT;
Simon Glasse9c8d492017-12-04 13:48:24 -0700312
313 return 0;
314}