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