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