blob: 45e46dd5209118fcffd0333c3a91bdbeb78bee6a [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>
13
14DECLARE_GLOBAL_DATA_PTR;
15
16static struct log_device *log_device_find_by_name(const char *drv_name)
17{
18 struct log_device *ldev;
19
20 list_for_each_entry(ldev, &gd->log_head, sibling_node) {
21 if (!strcmp(drv_name, ldev->drv->name))
22 return ldev;
23 }
24
25 return NULL;
26}
27
28/**
29 * log_has_cat() - check if a log category exists within a list
30 *
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
35 */
36static bool log_has_cat(enum log_category_t cat_list[], enum log_category_t cat)
37{
38 int i;
39
40 for (i = 0; i < LOGF_MAX_CATEGORIES && cat_list[i] != LOGC_END; i++) {
41 if (cat_list[i] == cat)
42 return true;
43 }
44
45 return false;
46}
47
48/**
49 * log_has_file() - check if a file is with a list
50 *
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
56 */
57static bool log_has_file(const char *file_list, const char *file)
58{
59 int file_len = strlen(file);
60 const char *s, *p;
61 int substr_len;
62
63 for (s = file_list; *s; s = p + (*p != '\0')) {
64 p = strchrnul(s, ',');
65 substr_len = p - s;
66 if (file_len >= substr_len &&
67 !strncmp(file + file_len - substr_len, s, substr_len))
68 return true;
69 }
70
71 return false;
72}
73
74/**
75 * log_passes_filters() - check if a log record passes the filters for a device
76 *
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
80 */
81static bool log_passes_filters(struct log_device *ldev, struct log_rec *rec)
82{
83 struct log_filter *filt;
84
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)
88 return false;
89 return true;
90 }
91
92 list_for_each_entry(filt, &ldev->filter_head, sibling_node) {
93 if (rec->level > filt->max_level)
94 continue;
95 if ((filt->flags & LOGFF_HAS_CAT) &&
96 !log_has_cat(filt->cat_list, rec->cat))
97 continue;
98 if (filt->file_list &&
99 !log_has_file(filt->file_list, rec->file))
100 continue;
101 return true;
102 }
103
104 return false;
105}
106
107/**
108 * log_dispatch() - Send a log record to all log devices for processing
109 *
110 * The log record is sent to each log device in turn, skipping those which have
111 * filters which block the record
112 *
113 * @rec: Log record to dispatch
114 * @return 0 (meaning success)
115 */
116static int log_dispatch(struct log_rec *rec)
117{
118 struct log_device *ldev;
119
120 list_for_each_entry(ldev, &gd->log_head, sibling_node) {
121 if (log_passes_filters(ldev, rec))
122 ldev->drv->emit(ldev, rec);
123 }
124
125 return 0;
126}
127
128int _log(enum log_category_t cat, enum log_level_t level, const char *file,
129 int line, const char *func, const char *fmt, ...)
130{
131 char buf[CONFIG_SYS_CBSIZE];
132 struct log_rec rec;
133 va_list args;
134
135 rec.cat = cat;
136 rec.level = level;
137 rec.file = file;
138 rec.line = line;
139 rec.func = func;
140 va_start(args, fmt);
141 vsnprintf(buf, sizeof(buf), fmt, args);
142 va_end(args);
143 rec.msg = buf;
144 if (!gd || !(gd->flags & GD_FLG_LOG_READY)) {
145 if (gd)
146 gd->log_drop_count++;
147 return -ENOSYS;
148 }
149 log_dispatch(&rec);
150
151 return 0;
152}
153
154int log_add_filter(const char *drv_name, enum log_category_t cat_list[],
155 enum log_level_t max_level, const char *file_list)
156{
157 struct log_filter *filt;
158 struct log_device *ldev;
159 int i;
160
161 ldev = log_device_find_by_name(drv_name);
162 if (!ldev)
163 return -ENOENT;
164 filt = (struct log_filter *)calloc(1, sizeof(*filt));
165 if (!filt)
166 return -ENOMEM;
167
168 if (cat_list) {
169 filt->flags |= LOGFF_HAS_CAT;
170 for (i = 0; ; i++) {
171 if (i == ARRAY_SIZE(filt->cat_list))
172 return -ENOSPC;
173 filt->cat_list[i] = cat_list[i];
174 if (cat_list[i] == LOGC_END)
175 break;
176 }
177 }
178 filt->max_level = max_level;
179 if (file_list) {
180 filt->file_list = strdup(file_list);
181 if (!filt->file_list)
182 goto nomem;
183 }
184 filt->filter_num = ldev->next_filter_num++;
185 list_add_tail(&filt->sibling_node, &ldev->filter_head);
186
187 return filt->filter_num;
188
189nomem:
190 free(filt);
191 return -ENOMEM;
192}
193
194int log_remove_filter(const char *drv_name, int filter_num)
195{
196 struct log_filter *filt;
197 struct log_device *ldev;
198
199 ldev = log_device_find_by_name(drv_name);
200 if (!ldev)
201 return -ENOENT;
202
203 list_for_each_entry(filt, &ldev->filter_head, sibling_node) {
204 if (filt->filter_num == filter_num) {
205 list_del(&filt->sibling_node);
206 free(filt);
207
208 return 0;
209 }
210 }
211
212 return -ENOENT;
213}
214
215int log_init(void)
216{
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;
220
221 /*
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.
225 */
226 INIT_LIST_HEAD((struct list_head *)&gd->log_head);
227 while (drv < end) {
228 struct log_device *ldev;
229
230 ldev = calloc(1, sizeof(*ldev));
231 if (!ldev) {
232 debug("%s: Cannot allocate memory\n", __func__);
233 return -ENOMEM;
234 }
235 INIT_LIST_HEAD(&ldev->filter_head);
236 ldev->drv = drv;
237 list_add_tail(&ldev->sibling_node,
238 (struct list_head *)&gd->log_head);
239 drv++;
240 }
Simon Glassaf1bc0c2017-12-04 13:48:28 -0700241 gd->flags |= GD_FLG_LOG_READY;
Simon Glasse9c8d492017-12-04 13:48:24 -0700242 gd->default_log_level = LOGL_INFO;
243
244 return 0;
245}