]> git.sur5r.net Git - u-boot/blob - common/log.c
fdt: Implement weak arch_fixup_fdt()
[u-boot] / common / log.c
1 /*
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>
13 #include <dm/uclass.h>
14
15 DECLARE_GLOBAL_DATA_PTR;
16
17 static const char *log_cat_name[LOGC_COUNT - LOGC_NONE] = {
18         "none",
19         "arch",
20         "board",
21         "core",
22         "driver-model",
23         "device-tree",
24         "efi",
25 };
26
27 static 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
40 const 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
50 enum 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
65 const 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
72 enum 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
84 static 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  */
104 static 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  */
125 static 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  */
149 static 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  */
184 static 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
196 int _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
222 int 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
257 nomem:
258         free(filt);
259         return -ENOMEM;
260 }
261
262 int 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
283 int 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         }
309         gd->flags |= GD_FLG_LOG_READY;
310         gd->default_log_level = LOGL_INFO;
311         gd->log_fmt = LOGF_DEFAULT;
312
313         return 0;
314 }