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