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