Tom Rini | 10e4779 | 2018-05-06 17:58:06 -0400 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0+ |
Simon Glass | d95645d | 2017-12-04 13:48:24 -0700 | [diff] [blame] | 2 | /* |
| 3 | * Logging support |
| 4 | * |
| 5 | * Copyright (c) 2017 Google, Inc |
| 6 | * Written by Simon Glass <sjg@chromium.org> |
Simon Glass | d95645d | 2017-12-04 13:48:24 -0700 | [diff] [blame] | 7 | */ |
| 8 | |
| 9 | #include <common.h> |
| 10 | #include <log.h> |
| 11 | #include <malloc.h> |
Simon Glass | 4f0fdb7 | 2017-12-28 13:14:16 -0700 | [diff] [blame] | 12 | #include <dm/uclass.h> |
Simon Glass | d95645d | 2017-12-04 13:48:24 -0700 | [diff] [blame] | 13 | |
| 14 | DECLARE_GLOBAL_DATA_PTR; |
| 15 | |
Simon Glass | 4f0fdb7 | 2017-12-28 13:14:16 -0700 | [diff] [blame] | 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", |
Heinrich Schuchardt | 90979f9 | 2018-01-22 20:10:45 +0100 | [diff] [blame] | 23 | "efi", |
Simon Glass | 4f0fdb7 | 2017-12-28 13:14:16 -0700 | [diff] [blame] | 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 | { |
Simon Glass | 8909656 | 2018-06-12 00:04:55 -0600 | [diff] [blame] | 41 | const char *name; |
| 42 | |
| 43 | if (cat < 0 || cat >= LOGC_COUNT) |
| 44 | return "<invalid>"; |
Simon Glass | 4f0fdb7 | 2017-12-28 13:14:16 -0700 | [diff] [blame] | 45 | if (cat >= LOGC_NONE) |
| 46 | return log_cat_name[cat - LOGC_NONE]; |
| 47 | |
Heinrich Schuchardt | 60075ea | 2020-06-08 18:04:22 +0200 | [diff] [blame] | 48 | #if CONFIG_IS_ENABLED(DM) |
Simon Glass | 8909656 | 2018-06-12 00:04:55 -0600 | [diff] [blame] | 49 | name = uclass_get_name((enum uclass_id)cat); |
Heinrich Schuchardt | 60075ea | 2020-06-08 18:04:22 +0200 | [diff] [blame] | 50 | #else |
| 51 | name = NULL; |
| 52 | #endif |
Simon Glass | 8909656 | 2018-06-12 00:04:55 -0600 | [diff] [blame] | 53 | |
| 54 | return name ? name : "<missing>"; |
Simon Glass | 4f0fdb7 | 2017-12-28 13:14:16 -0700 | [diff] [blame] | 55 | } |
| 56 | |
| 57 | enum log_category_t log_get_cat_by_name(const char *name) |
| 58 | { |
| 59 | enum uclass_id id; |
| 60 | int i; |
| 61 | |
| 62 | for (i = LOGC_NONE; i < LOGC_COUNT; i++) |
| 63 | if (!strcmp(name, log_cat_name[i - LOGC_NONE])) |
| 64 | return i; |
| 65 | id = uclass_get_by_name(name); |
| 66 | if (id != UCLASS_INVALID) |
| 67 | return (enum log_category_t)id; |
| 68 | |
| 69 | return LOGC_NONE; |
| 70 | } |
| 71 | |
| 72 | const char *log_get_level_name(enum log_level_t level) |
| 73 | { |
| 74 | if (level >= LOGL_COUNT) |
| 75 | return "INVALID"; |
| 76 | return log_level_name[level]; |
| 77 | } |
| 78 | |
| 79 | enum log_level_t log_get_level_by_name(const char *name) |
| 80 | { |
| 81 | int i; |
| 82 | |
| 83 | for (i = 0; i < LOGL_COUNT; i++) { |
| 84 | if (!strcasecmp(log_level_name[i], name)) |
| 85 | return i; |
| 86 | } |
| 87 | |
| 88 | return LOGL_NONE; |
| 89 | } |
| 90 | |
Simon Glass | d95645d | 2017-12-04 13:48:24 -0700 | [diff] [blame] | 91 | static struct log_device *log_device_find_by_name(const char *drv_name) |
| 92 | { |
| 93 | struct log_device *ldev; |
| 94 | |
| 95 | list_for_each_entry(ldev, &gd->log_head, sibling_node) { |
| 96 | if (!strcmp(drv_name, ldev->drv->name)) |
| 97 | return ldev; |
| 98 | } |
| 99 | |
| 100 | return NULL; |
| 101 | } |
| 102 | |
| 103 | /** |
| 104 | * log_has_cat() - check if a log category exists within a list |
| 105 | * |
| 106 | * @cat_list: List of categories to check, at most LOGF_MAX_CATEGORIES entries |
| 107 | * long, terminated by LC_END if fewer |
| 108 | * @cat: Category to search for |
| 109 | * @return true if @cat is in @cat_list, else false |
| 110 | */ |
| 111 | static bool log_has_cat(enum log_category_t cat_list[], enum log_category_t cat) |
| 112 | { |
| 113 | int i; |
| 114 | |
| 115 | for (i = 0; i < LOGF_MAX_CATEGORIES && cat_list[i] != LOGC_END; i++) { |
| 116 | if (cat_list[i] == cat) |
| 117 | return true; |
| 118 | } |
| 119 | |
| 120 | return false; |
| 121 | } |
| 122 | |
| 123 | /** |
| 124 | * log_has_file() - check if a file is with a list |
| 125 | * |
| 126 | * @file_list: List of files to check, separated by comma |
| 127 | * @file: File to check for. This string is matched against the end of each |
| 128 | * file in the list, i.e. ignoring any preceding path. The list is |
| 129 | * intended to consist of relative pathnames, e.g. common/main.c,cmd/log.c |
| 130 | * @return true if @file is in @file_list, else false |
| 131 | */ |
| 132 | static bool log_has_file(const char *file_list, const char *file) |
| 133 | { |
| 134 | int file_len = strlen(file); |
| 135 | const char *s, *p; |
| 136 | int substr_len; |
| 137 | |
| 138 | for (s = file_list; *s; s = p + (*p != '\0')) { |
| 139 | p = strchrnul(s, ','); |
| 140 | substr_len = p - s; |
| 141 | if (file_len >= substr_len && |
| 142 | !strncmp(file + file_len - substr_len, s, substr_len)) |
| 143 | return true; |
| 144 | } |
| 145 | |
| 146 | return false; |
| 147 | } |
| 148 | |
| 149 | /** |
| 150 | * log_passes_filters() - check if a log record passes the filters for a device |
| 151 | * |
| 152 | * @ldev: Log device to check |
| 153 | * @rec: Log record to check |
| 154 | * @return true if @rec is not blocked by the filters in @ldev, false if it is |
| 155 | */ |
| 156 | static bool log_passes_filters(struct log_device *ldev, struct log_rec *rec) |
| 157 | { |
| 158 | struct log_filter *filt; |
| 159 | |
Simon Glass | 9c83cac | 2020-09-12 11:13:34 -0600 | [diff] [blame] | 160 | if (rec->force_debug) |
| 161 | return true; |
| 162 | |
Simon Glass | d95645d | 2017-12-04 13:48:24 -0700 | [diff] [blame] | 163 | /* If there are no filters, filter on the default log level */ |
| 164 | if (list_empty(&ldev->filter_head)) { |
| 165 | if (rec->level > gd->default_log_level) |
| 166 | return false; |
| 167 | return true; |
| 168 | } |
| 169 | |
| 170 | list_for_each_entry(filt, &ldev->filter_head, sibling_node) { |
| 171 | if (rec->level > filt->max_level) |
| 172 | continue; |
| 173 | if ((filt->flags & LOGFF_HAS_CAT) && |
| 174 | !log_has_cat(filt->cat_list, rec->cat)) |
| 175 | continue; |
| 176 | if (filt->file_list && |
| 177 | !log_has_file(filt->file_list, rec->file)) |
| 178 | continue; |
| 179 | return true; |
| 180 | } |
| 181 | |
| 182 | return false; |
| 183 | } |
| 184 | |
| 185 | /** |
| 186 | * log_dispatch() - Send a log record to all log devices for processing |
| 187 | * |
| 188 | * The log record is sent to each log device in turn, skipping those which have |
| 189 | * filters which block the record |
| 190 | * |
| 191 | * @rec: Log record to dispatch |
| 192 | * @return 0 (meaning success) |
| 193 | */ |
| 194 | static int log_dispatch(struct log_rec *rec) |
| 195 | { |
| 196 | struct log_device *ldev; |
Heinrich Schuchardt | b5ecfca | 2020-09-14 10:01:00 +0200 | [diff] [blame] | 197 | static int processing_msg; |
Simon Glass | d95645d | 2017-12-04 13:48:24 -0700 | [diff] [blame] | 198 | |
Heinrich Schuchardt | b5ecfca | 2020-09-14 10:01:00 +0200 | [diff] [blame] | 199 | /* |
| 200 | * When a log driver writes messages (e.g. via the network stack) this |
| 201 | * may result in further generated messages. We cannot process them here |
| 202 | * as this might result in infinite recursion. |
| 203 | */ |
| 204 | if (processing_msg) |
| 205 | return 0; |
| 206 | |
| 207 | /* Emit message */ |
| 208 | processing_msg = 1; |
Simon Glass | d95645d | 2017-12-04 13:48:24 -0700 | [diff] [blame] | 209 | list_for_each_entry(ldev, &gd->log_head, sibling_node) { |
Simon Glass | 885cf5f | 2020-09-12 12:28:47 -0600 | [diff] [blame] | 210 | if ((ldev->flags & LOGDF_ENABLE) && |
| 211 | log_passes_filters(ldev, rec)) |
Simon Glass | d95645d | 2017-12-04 13:48:24 -0700 | [diff] [blame] | 212 | ldev->drv->emit(ldev, rec); |
| 213 | } |
Heinrich Schuchardt | b5ecfca | 2020-09-14 10:01:00 +0200 | [diff] [blame] | 214 | processing_msg = 0; |
Simon Glass | d95645d | 2017-12-04 13:48:24 -0700 | [diff] [blame] | 215 | return 0; |
| 216 | } |
| 217 | |
| 218 | int _log(enum log_category_t cat, enum log_level_t level, const char *file, |
| 219 | int line, const char *func, const char *fmt, ...) |
| 220 | { |
| 221 | char buf[CONFIG_SYS_CBSIZE]; |
| 222 | struct log_rec rec; |
| 223 | va_list args; |
| 224 | |
| 225 | rec.cat = cat; |
Simon Glass | 9c83cac | 2020-09-12 11:13:34 -0600 | [diff] [blame] | 226 | rec.level = level & LOGL_LEVEL_MASK; |
| 227 | rec.force_debug = level & LOGL_FORCE_DEBUG; |
Simon Glass | d95645d | 2017-12-04 13:48:24 -0700 | [diff] [blame] | 228 | rec.file = file; |
| 229 | rec.line = line; |
| 230 | rec.func = func; |
| 231 | va_start(args, fmt); |
| 232 | vsnprintf(buf, sizeof(buf), fmt, args); |
| 233 | va_end(args); |
| 234 | rec.msg = buf; |
| 235 | if (!gd || !(gd->flags & GD_FLG_LOG_READY)) { |
| 236 | if (gd) |
| 237 | gd->log_drop_count++; |
| 238 | return -ENOSYS; |
| 239 | } |
| 240 | log_dispatch(&rec); |
| 241 | |
| 242 | return 0; |
| 243 | } |
| 244 | |
| 245 | int log_add_filter(const char *drv_name, enum log_category_t cat_list[], |
| 246 | enum log_level_t max_level, const char *file_list) |
| 247 | { |
| 248 | struct log_filter *filt; |
| 249 | struct log_device *ldev; |
Simon Glass | f14f393 | 2018-04-02 02:42:39 -0600 | [diff] [blame] | 250 | int ret; |
Simon Glass | d95645d | 2017-12-04 13:48:24 -0700 | [diff] [blame] | 251 | int i; |
| 252 | |
| 253 | ldev = log_device_find_by_name(drv_name); |
| 254 | if (!ldev) |
| 255 | return -ENOENT; |
Heinrich Schuchardt | be9ab32 | 2020-04-19 10:48:36 +0200 | [diff] [blame] | 256 | filt = calloc(1, sizeof(*filt)); |
Simon Glass | d95645d | 2017-12-04 13:48:24 -0700 | [diff] [blame] | 257 | if (!filt) |
| 258 | return -ENOMEM; |
| 259 | |
| 260 | if (cat_list) { |
| 261 | filt->flags |= LOGFF_HAS_CAT; |
| 262 | for (i = 0; ; i++) { |
Simon Glass | f14f393 | 2018-04-02 02:42:39 -0600 | [diff] [blame] | 263 | if (i == ARRAY_SIZE(filt->cat_list)) { |
| 264 | ret = -ENOSPC; |
| 265 | goto err; |
| 266 | } |
Simon Glass | d95645d | 2017-12-04 13:48:24 -0700 | [diff] [blame] | 267 | filt->cat_list[i] = cat_list[i]; |
| 268 | if (cat_list[i] == LOGC_END) |
| 269 | break; |
| 270 | } |
| 271 | } |
| 272 | filt->max_level = max_level; |
| 273 | if (file_list) { |
| 274 | filt->file_list = strdup(file_list); |
Simon Glass | f14f393 | 2018-04-02 02:42:39 -0600 | [diff] [blame] | 275 | if (!filt->file_list) { |
| 276 | ret = ENOMEM; |
| 277 | goto err; |
| 278 | } |
Simon Glass | d95645d | 2017-12-04 13:48:24 -0700 | [diff] [blame] | 279 | } |
| 280 | filt->filter_num = ldev->next_filter_num++; |
| 281 | list_add_tail(&filt->sibling_node, &ldev->filter_head); |
| 282 | |
| 283 | return filt->filter_num; |
| 284 | |
Simon Glass | f14f393 | 2018-04-02 02:42:39 -0600 | [diff] [blame] | 285 | err: |
Simon Glass | d95645d | 2017-12-04 13:48:24 -0700 | [diff] [blame] | 286 | free(filt); |
Simon Glass | f14f393 | 2018-04-02 02:42:39 -0600 | [diff] [blame] | 287 | return ret; |
Simon Glass | d95645d | 2017-12-04 13:48:24 -0700 | [diff] [blame] | 288 | } |
| 289 | |
| 290 | int log_remove_filter(const char *drv_name, int filter_num) |
| 291 | { |
| 292 | struct log_filter *filt; |
| 293 | struct log_device *ldev; |
| 294 | |
| 295 | ldev = log_device_find_by_name(drv_name); |
| 296 | if (!ldev) |
| 297 | return -ENOENT; |
| 298 | |
| 299 | list_for_each_entry(filt, &ldev->filter_head, sibling_node) { |
| 300 | if (filt->filter_num == filter_num) { |
| 301 | list_del(&filt->sibling_node); |
| 302 | free(filt); |
| 303 | |
| 304 | return 0; |
| 305 | } |
| 306 | } |
| 307 | |
| 308 | return -ENOENT; |
| 309 | } |
| 310 | |
Simon Glass | 133350a | 2020-09-12 12:28:49 -0600 | [diff] [blame] | 311 | /** |
| 312 | * log_find_device_by_drv() - Find a device by its driver |
| 313 | * |
| 314 | * @drv: Log driver |
| 315 | * @return Device associated with that driver, or NULL if not found |
| 316 | */ |
| 317 | static struct log_device *log_find_device_by_drv(struct log_driver *drv) |
| 318 | { |
| 319 | struct log_device *ldev; |
| 320 | |
| 321 | list_for_each_entry(ldev, &gd->log_head, sibling_node) { |
| 322 | if (ldev->drv == drv) |
| 323 | return ldev; |
| 324 | } |
| 325 | /* |
| 326 | * It is quite hard to pass an invalid driver since passing an unknown |
| 327 | * LOG_GET_DRIVER(xxx) would normally produce a compilation error. But |
| 328 | * it is possible to pass NULL, for example, so this |
| 329 | */ |
| 330 | |
| 331 | return NULL; |
| 332 | } |
| 333 | |
| 334 | int log_device_set_enable(struct log_driver *drv, bool enable) |
| 335 | { |
| 336 | struct log_device *ldev; |
| 337 | |
| 338 | ldev = log_find_device_by_drv(drv); |
| 339 | if (!ldev) |
| 340 | return -ENOENT; |
| 341 | if (enable) |
| 342 | ldev->flags |= LOGDF_ENABLE; |
| 343 | else |
| 344 | ldev->flags &= ~LOGDF_ENABLE; |
| 345 | |
| 346 | return 0; |
| 347 | } |
| 348 | |
Simon Glass | d95645d | 2017-12-04 13:48:24 -0700 | [diff] [blame] | 349 | int log_init(void) |
| 350 | { |
| 351 | struct log_driver *drv = ll_entry_start(struct log_driver, log_driver); |
| 352 | const int count = ll_entry_count(struct log_driver, log_driver); |
| 353 | struct log_driver *end = drv + count; |
| 354 | |
| 355 | /* |
| 356 | * We cannot add runtime data to the driver since it is likely stored |
| 357 | * in rodata. Instead, set up a 'device' corresponding to each driver. |
| 358 | * We only support having a single device. |
| 359 | */ |
| 360 | INIT_LIST_HEAD((struct list_head *)&gd->log_head); |
| 361 | while (drv < end) { |
| 362 | struct log_device *ldev; |
| 363 | |
| 364 | ldev = calloc(1, sizeof(*ldev)); |
| 365 | if (!ldev) { |
| 366 | debug("%s: Cannot allocate memory\n", __func__); |
| 367 | return -ENOMEM; |
| 368 | } |
| 369 | INIT_LIST_HEAD(&ldev->filter_head); |
| 370 | ldev->drv = drv; |
Simon Glass | 885cf5f | 2020-09-12 12:28:47 -0600 | [diff] [blame] | 371 | ldev->flags = drv->flags; |
Simon Glass | d95645d | 2017-12-04 13:48:24 -0700 | [diff] [blame] | 372 | list_add_tail(&ldev->sibling_node, |
| 373 | (struct list_head *)&gd->log_head); |
| 374 | drv++; |
| 375 | } |
Simon Glass | 55e32ba | 2017-12-04 13:48:28 -0700 | [diff] [blame] | 376 | gd->flags |= GD_FLG_LOG_READY; |
Simon Glass | 4e9a64d | 2018-10-01 11:55:11 -0600 | [diff] [blame] | 377 | if (!gd->default_log_level) |
Simon Glass | 38617e8 | 2019-02-16 20:24:35 -0700 | [diff] [blame] | 378 | gd->default_log_level = CONFIG_LOG_DEFAULT_LEVEL; |
Heinrich Schuchardt | 2d349c7 | 2020-06-17 21:52:44 +0200 | [diff] [blame] | 379 | gd->log_fmt = log_get_default_format(); |
Simon Glass | d95645d | 2017-12-04 13:48:24 -0700 | [diff] [blame] | 380 | |
| 381 | return 0; |
| 382 | } |