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 *const log_cat_name[] = {
  17         "none",
  18         "arch",
  19         "board",
  20         "core",
  21         "driver-model",
  22         "device-tree",
  23         "efi",
  24         "alloc",
  25         "sandbox",
  26         "bloblist",
  27         "devres",
  28         "acpi",
  29         "boot",
  30 };
  31
  32 _Static_assert(ARRAY_SIZE(log_cat_name) == LOGC_COUNT - LOGC_NONE,
  33                "log_cat_name size");
  34
  35 static const char *const log_level_name[] = {
  36         "EMERG",
  37         "ALERT",
  38         "CRIT",
  39         "ERR",
  40         "WARNING",
  41         "NOTICE",
  42         "INFO",
  43         "DEBUG",
  44         "CONTENT",
  45         "IO",
  46 };
  47
  48 _Static_assert(ARRAY_SIZE(log_level_name) == LOGL_COUNT, "log_level_name size");
  49
  50 /* All error responses MUST begin with '<' */
  51 const char *log_get_cat_name(enum log_category_t cat)
  52 {
  53         const char *name;
  54
  55         if (cat < 0 || cat >= LOGC_COUNT)
  56                 return "<invalid>";
  57         if (cat >= LOGC_NONE)
  58                 return log_cat_name[cat - LOGC_NONE];
  59
  60 #if CONFIG_IS_ENABLED(DM)
  61         name = uclass_get_name((enum uclass_id)cat);
  62 #else
  63         name = NULL;
  64 #endif
  65
  66         return name ? name : "<missing>";
  67 }
  68
  69 enum log_category_t log_get_cat_by_name(const char *name)
  70 {
  71         enum uclass_id id;
  72         int i;
  73
  74         for (i = LOGC_NONE; i < LOGC_COUNT; i++)
  75                 if (!strcmp(name, log_cat_name[i - LOGC_NONE]))
  76                         return i;
  77         id = uclass_get_by_name(name);
  78         if (id != UCLASS_INVALID)
  79                 return (enum log_category_t)id;
  80
  81         return LOGC_NONE;
  82 }
  83
  84 const char *log_get_level_name(enum log_level_t level)
  85 {
  86         if (level >= LOGL_COUNT)
  87                 return "INVALID";
  88         return log_level_name[level];
  89 }
  90
  91 enum log_level_t log_get_level_by_name(const char *name)
  92 {
  93         int i;
  94
  95         for (i = 0; i < LOGL_COUNT; i++) {
  96                 if (!strcasecmp(log_level_name[i], name))
  97                         return i;
  98         }
  99
 100         return LOGL_NONE;
 101 }
 102
 103 struct log_device *log_device_find_by_name(const char *drv_name)
 104 {
 105         struct log_device *ldev;
 106
 107         list_for_each_entry(ldev, &gd->log_head, sibling_node) {
 108                 if (!strcmp(drv_name, ldev->drv->name))
 109                         return ldev;
 110         }
 111
 112         return NULL;
 113 }
 114
 115 bool log_has_cat(enum log_category_t cat_list[], enum log_category_t cat)
 116 {
 117         int i;
 118
 119         for (i = 0; i < LOGF_MAX_CATEGORIES && cat_list[i] != LOGC_END; i++) {
 120                 if (cat_list[i] == cat)
 121                         return true;
 122         }
 123
 124         return false;
 125 }
 126
 127 bool log_has_file(const char *file_list, const char *file)
 128 {
 129         int file_len = strlen(file);
 130         const char *s, *p;
 131         int substr_len;
 132
 133         for (s = file_list; *s; s = p + (*p != '\0')) {
 134                 p = strchrnul(s, ',');
 135                 substr_len = p - s;
 136                 if (file_len >= substr_len &&
 137                     !strncmp(file + file_len - substr_len, s, substr_len))
 138                         return true;
 139         }
 140
 141         return false;
 142 }
 143
 144 /**
 145  * log_passes_filters() - check if a log record passes the filters for a device
 146  *
 147  * @ldev: Log device to check
 148  * @rec: Log record to check
 149  * @return true if @rec is not blocked by the filters in @ldev, false if it is
 150  */
 151 static bool log_passes_filters(struct log_device *ldev, struct log_rec *rec)
 152 {
 153         struct log_filter *filt;
 154
 155         if (rec->force_debug)
 156                 return true;
 157
 158         /* If there are no filters, filter on the default log level */
 159         if (list_empty(&ldev->filter_head)) {
 160                 if (rec->level > gd->default_log_level)
 161                         return false;
 162                 return true;
 163         }
 164
 165         list_for_each_entry(filt, &ldev->filter_head, sibling_node) {
 166                 if (filt->flags & LOGFF_LEVEL_MIN) {
 167                         if (rec->level < filt->level)
 168                                 continue;
 169                 } else if (rec->level > filt->level) {
 170                         continue;
 171                 }
 172
 173                 if ((filt->flags & LOGFF_HAS_CAT) &&
 174                     !log_has_cat(filt->cat_list, rec->cat))
 175                         continue;
 176
 177                 if (filt->file_list &&
 178                     !log_has_file(filt->file_list, rec->file))
 179                         continue;
 180
 181                 if (filt->flags & LOGFF_DENY)
 182                         return false;
 183                 else
 184                         return true;
 185         }
 186
 187         return false;
 188 }
 189
 190 /**
 191  * log_dispatch() - Send a log record to all log devices for processing
 192  *
 193  * The log record is sent to each log device in turn, skipping those which have
 194  * filters which block the record.
 195  *
 196  * All log messages created while processing log record @rec are ignored.
 197  *
 198  * @rec:        log record to dispatch
 199  * Return:      0 msg sent, 1 msg not sent while already dispatching another msg
 200  */
 201 static int log_dispatch(struct log_rec *rec, const char *fmt, va_list args)
 202 {
 203         struct log_device *ldev;
 204         char buf[CONFIG_SYS_CBSIZE];
 205
 206         /*
 207          * When a log driver writes messages (e.g. via the network stack) this
 208          * may result in further generated messages. We cannot process them here
 209          * as this might result in infinite recursion.
 210          */
 211         if (gd->processing_msg)
 212                 return 1;
 213
 214         /* Emit message */
 215         gd->processing_msg = true;
 216         list_for_each_entry(ldev, &gd->log_head, sibling_node) {
 217                 if ((ldev->flags & LOGDF_ENABLE) &&
 218                     log_passes_filters(ldev, rec)) {
 219                         if (!rec->msg) {
 220                                 vsnprintf(buf, sizeof(buf), fmt, args);
 221                                 rec->msg = buf;
 222                         }
 223                         ldev->drv->emit(ldev, rec);
 224                 }
 225         }
 226         gd->processing_msg = false;
 227         return 0;
 228 }
 229
 230 int _log(enum log_category_t cat, enum log_level_t level, const char *file,
 231          int line, const char *func, const char *fmt, ...)
 232 {
 233         struct log_rec rec;
 234         va_list args;
 235
 236         if (!gd)
 237                 return -ENOSYS;
 238
 239         /* Check for message continuation */
 240         if (cat == LOGC_CONT)
 241                 cat = gd->logc_prev;
 242         if (level == LOGL_CONT)
 243                 level = gd->logl_prev;
 244
 245         rec.cat = cat;
 246         rec.level = level & LOGL_LEVEL_MASK;
 247         rec.force_debug = level & LOGL_FORCE_DEBUG;
 248         rec.file = file;
 249         rec.line = line;
 250         rec.func = func;
 251         rec.msg = NULL;
 252
 253         if (!(gd->flags & GD_FLG_LOG_READY)) {
 254                 gd->log_drop_count++;
 255
 256                 /* display dropped traces with console puts and DEBUG_UART */
 257                 if (rec.level <= CONFIG_LOG_DEFAULT_LEVEL || rec.force_debug) {
 258                         char buf[CONFIG_SYS_CBSIZE];
 259
 260                         va_start(args, fmt);
 261                         vsnprintf(buf, sizeof(buf), fmt, args);
 262                         puts(buf);
 263                         va_end(args);
 264                 }
 265
 266                 return -ENOSYS;
 267         }
 268         va_start(args, fmt);
 269         if (!log_dispatch(&rec, fmt, args)) {
 270                 gd->logc_prev = cat;
 271                 gd->logl_prev = level;
 272         }
 273         va_end(args);
 274
 275         return 0;
 276 }
 277
 278 int log_add_filter_flags(const char *drv_name, enum log_category_t cat_list[],
 279                          enum log_level_t level, const char *file_list,
 280                          int flags)
 281 {
 282         struct log_filter *filt;
 283         struct log_device *ldev;
 284         int ret;
 285         int i;
 286
 287         ldev = log_device_find_by_name(drv_name);
 288         if (!ldev)
 289                 return -ENOENT;
 290         filt = calloc(1, sizeof(*filt));
 291         if (!filt)
 292                 return -ENOMEM;
 293
 294         filt->flags = flags;
 295         if (cat_list) {
 296                 filt->flags |= LOGFF_HAS_CAT;
 297                 for (i = 0; ; i++) {
 298                         if (i == ARRAY_SIZE(filt->cat_list)) {
 299                                 ret = -ENOSPC;
 300                                 goto err;
 301                         }
 302                         filt->cat_list[i] = cat_list[i];
 303                         if (cat_list[i] == LOGC_END)
 304                                 break;
 305                 }
 306         }
 307         filt->level = level;
 308         if (file_list) {
 309                 filt->file_list = strdup(file_list);
 310                 if (!filt->file_list) {
 311                         ret = -ENOMEM;
 312                         goto err;
 313                 }
 314         }
 315         filt->filter_num = ldev->next_filter_num++;
 316         /* Add deny filters to the beginning of the list */
 317         if (flags & LOGFF_DENY)
 318                 list_add(&filt->sibling_node, &ldev->filter_head);
 319         else
 320                 list_add_tail(&filt->sibling_node, &ldev->filter_head);
 321
 322         return filt->filter_num;
 323
 324 err:
 325         free(filt);
 326         return ret;
 327 }
 328
 329 int log_remove_filter(const char *drv_name, int filter_num)
 330 {
 331         struct log_filter *filt;
 332         struct log_device *ldev;
 333
 334         ldev = log_device_find_by_name(drv_name);
 335         if (!ldev)
 336                 return -ENOENT;
 337
 338         list_for_each_entry(filt, &ldev->filter_head, sibling_node) {
 339                 if (filt->filter_num == filter_num) {
 340                         list_del(&filt->sibling_node);
 341                         free(filt);
 342
 343                         return 0;
 344                 }
 345         }
 346
 347         return -ENOENT;
 348 }
 349
 350 /**
 351  * log_find_device_by_drv() - Find a device by its driver
 352  *
 353  * @drv: Log driver
 354  * @return Device associated with that driver, or NULL if not found
 355  */
 356 static struct log_device *log_find_device_by_drv(struct log_driver *drv)
 357 {
 358         struct log_device *ldev;
 359
 360         list_for_each_entry(ldev, &gd->log_head, sibling_node) {
 361                 if (ldev->drv == drv)
 362                         return ldev;
 363         }
 364         /*
 365          * It is quite hard to pass an invalid driver since passing an unknown
 366          * LOG_GET_DRIVER(xxx) would normally produce a compilation error. But
 367          * it is possible to pass NULL, for example, so this
 368          */
 369
 370         return NULL;
 371 }
 372
 373 int log_device_set_enable(struct log_driver *drv, bool enable)
 374 {
 375         struct log_device *ldev;
 376
 377         ldev = log_find_device_by_drv(drv);
 378         if (!ldev)
 379                 return -ENOENT;
 380         if (enable)
 381                 ldev->flags |= LOGDF_ENABLE;
 382         else
 383                 ldev->flags &= ~LOGDF_ENABLE;
 384
 385         return 0;
 386 }
 387
 388 int log_init(void)
 389 {
 390         struct log_driver *drv = ll_entry_start(struct log_driver, log_driver);
 391         const int count = ll_entry_count(struct log_driver, log_driver);
 392         struct log_driver *end = drv + count;
 393
 394         /*
 395          * We cannot add runtime data to the driver since it is likely stored
 396          * in rodata. Instead, set up a 'device' corresponding to each driver.
 397          * We only support having a single device.
 398          */
 399         INIT_LIST_HEAD((struct list_head *)&gd->log_head);
 400         while (drv < end) {
 401                 struct log_device *ldev;
 402
 403                 ldev = calloc(1, sizeof(*ldev));
 404                 if (!ldev) {
 405                         debug("%s: Cannot allocate memory\n", __func__);
 406                         return -ENOMEM;
 407                 }
 408                 INIT_LIST_HEAD(&ldev->filter_head);
 409                 ldev->drv = drv;
 410                 ldev->flags = drv->flags;
 411                 list_add_tail(&ldev->sibling_node,
 412                               (struct list_head *)&gd->log_head);
 413                 drv++;
 414         }
 415         gd->flags |= GD_FLG_LOG_READY;
 416         if (!gd->default_log_level)
 417                 gd->default_log_level = CONFIG_LOG_DEFAULT_LEVEL;
 418         gd->log_fmt = log_get_default_format();
 419         gd->logc_prev = LOGC_NONE;
 420         gd->logl_prev = LOGL_INFO;
 421
 422         return 0;
 423 }