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 <[email protected]>
   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 *log_cat_name[LOGC_COUNT - LOGC_NONE] = {
  17         "none",
  18         "arch",
  19         "board",
  20         "core",
  21         "driver-model",
  22         "device-tree",
  23         "efi",
  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 {
  41         const char *name;
  42
  43         if (cat < 0 || cat >= LOGC_COUNT)
  44                 return "<invalid>";
  45         if (cat >= LOGC_NONE)
  46                 return log_cat_name[cat - LOGC_NONE];
  47
  48 #if CONFIG_IS_ENABLED(DM)
  49         name = uclass_get_name((enum uclass_id)cat);
  50 #else
  51         name = NULL;
  52 #endif
  53
  54         return name ? name : "<missing>";
  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
  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
 160         if (rec->force_debug)
 161                 return true;
 162
 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;
 197         static int processing_msg;
 198
 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;
 209         list_for_each_entry(ldev, &gd->log_head, sibling_node) {
 210                 if (log_passes_filters(ldev, rec))
 211                         ldev->drv->emit(ldev, rec);
 212         }
 213         processing_msg = 0;
 214         return 0;
 215 }
 216
 217 int _log(enum log_category_t cat, enum log_level_t level, const char *file,
 218          int line, const char *func, const char *fmt, ...)
 219 {
 220         char buf[CONFIG_SYS_CBSIZE];
 221         struct log_rec rec;
 222         va_list args;
 223
 224         rec.cat = cat;
 225         rec.level = level & LOGL_LEVEL_MASK;
 226         rec.force_debug = level & LOGL_FORCE_DEBUG;
 227         rec.file = file;
 228         rec.line = line;
 229         rec.func = func;
 230         va_start(args, fmt);
 231         vsnprintf(buf, sizeof(buf), fmt, args);
 232         va_end(args);
 233         rec.msg = buf;
 234         if (!gd || !(gd->flags & GD_FLG_LOG_READY)) {
 235                 if (gd)
 236                         gd->log_drop_count++;
 237                 return -ENOSYS;
 238         }
 239         log_dispatch(&rec);
 240
 241         return 0;
 242 }
 243
 244 int log_add_filter(const char *drv_name, enum log_category_t cat_list[],
 245                    enum log_level_t max_level, const char *file_list)
 246 {
 247         struct log_filter *filt;
 248         struct log_device *ldev;
 249         int ret;
 250         int i;
 251
 252         ldev = log_device_find_by_name(drv_name);
 253         if (!ldev)
 254                 return -ENOENT;
 255         filt = calloc(1, sizeof(*filt));
 256         if (!filt)
 257                 return -ENOMEM;
 258
 259         if (cat_list) {
 260                 filt->flags |= LOGFF_HAS_CAT;
 261                 for (i = 0; ; i++) {
 262                         if (i == ARRAY_SIZE(filt->cat_list)) {
 263                                 ret = -ENOSPC;
 264                                 goto err;
 265                         }
 266                         filt->cat_list[i] = cat_list[i];
 267                         if (cat_list[i] == LOGC_END)
 268                                 break;
 269                 }
 270         }
 271         filt->max_level = max_level;
 272         if (file_list) {
 273                 filt->file_list = strdup(file_list);
 274                 if (!filt->file_list) {
 275                         ret = ENOMEM;
 276                         goto err;
 277                 }
 278         }
 279         filt->filter_num = ldev->next_filter_num++;
 280         list_add_tail(&filt->sibling_node, &ldev->filter_head);
 281
 282         return filt->filter_num;
 283
 284 err:
 285         free(filt);
 286         return ret;
 287 }
 288
 289 int log_remove_filter(const char *drv_name, int filter_num)
 290 {
 291         struct log_filter *filt;
 292         struct log_device *ldev;
 293
 294         ldev = log_device_find_by_name(drv_name);
 295         if (!ldev)
 296                 return -ENOENT;
 297
 298         list_for_each_entry(filt, &ldev->filter_head, sibling_node) {
 299                 if (filt->filter_num == filter_num) {
 300                         list_del(&filt->sibling_node);
 301                         free(filt);
 302
 303                         return 0;
 304                 }
 305         }
 306
 307         return -ENOENT;
 308 }
 309
 310 int log_init(void)
 311 {
 312         struct log_driver *drv = ll_entry_start(struct log_driver, log_driver);
 313         const int count = ll_entry_count(struct log_driver, log_driver);
 314         struct log_driver *end = drv + count;
 315
 316         /*
 317          * We cannot add runtime data to the driver since it is likely stored
 318          * in rodata. Instead, set up a 'device' corresponding to each driver.
 319          * We only support having a single device.
 320          */
 321         INIT_LIST_HEAD((struct list_head *)&gd->log_head);
 322         while (drv < end) {
 323                 struct log_device *ldev;
 324
 325                 ldev = calloc(1, sizeof(*ldev));
 326                 if (!ldev) {
 327                         debug("%s: Cannot allocate memory\n", __func__);
 328                         return -ENOMEM;
 329                 }
 330                 INIT_LIST_HEAD(&ldev->filter_head);
 331                 ldev->drv = drv;
 332                 list_add_tail(&ldev->sibling_node,
 333                               (struct list_head *)&gd->log_head);
 334                 drv++;
 335         }
 336         gd->flags |= GD_FLG_LOG_READY;
 337         if (!gd->default_log_level)
 338                 gd->default_log_level = CONFIG_LOG_DEFAULT_LEVEL;
 339         gd->log_fmt = log_get_default_format();
 340
 341         return 0;
 342 }