Merge git://git.denx.de/u-boot-sunxi
[platform/kernel/u-boot.git] / common / log.c
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Logging support
4  *
5  * Copyright (c) 2017 Google, Inc
6  * Written by Simon Glass <sjg@chromium.org>
7  */
8
9 #include <common.h>
10 #include <log.h>
11 #include <malloc.h>
12 #include <dm/uclass.h>
13
14 DECLARE_GLOBAL_DATA_PTR;
15
16 static const char *log_cat_name[LOGC_COUNT - LOGC_NONE] = {
17         "none",
18         "arch",
19         "board",
20         "core",
21         "driver-model",
22         "device-tree",
23         "efi",
24 };
25
26 static 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
39 const 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
49 enum 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
64 const 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
71 enum 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
83 static 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  */
103 static 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  */
124 static 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  */
148 static 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  */
183 static 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
195 int _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
221 int 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;
226         int ret;
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                                 ret = -ENOSPC;
241                                 goto err;
242                         }
243                         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);
251                 if (!filt->file_list) {
252                         ret = ENOMEM;
253                         goto err;
254                 }
255         }
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
261 err:
262         free(filt);
263         return ret;
264 }
265
266 int 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
287 int 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         }
313         gd->flags |= GD_FLG_LOG_READY;
314         gd->default_log_level = LOGL_INFO;
315         gd->log_fmt = LOGF_DEFAULT;
316
317         return 0;
318 }