common/log.c

   1 /*
   2  * Logging support
   3  *
   4  * Copyright (c) 2017 Google, Inc
   5  * Written by Simon Glass <sjg@chromium.org>
   6  *
   7  * SPDX-License-Identifier:     GPL-2.0+
   8  */
   9
  10 #include <common.h>
  11 #include <log.h>
  12 #include <malloc.h>
  13 #include <dm/uclass.h>
  14
  15 DECLARE_GLOBAL_DATA_PTR;
  16
  17 static const char *log_cat_name[LOGC_COUNT - LOGC_NONE] = {
  18         "none",
  19         "arch",
  20         "board",
  21         "core",
  22         "driver-model",
  23         "device-tree",
  24         "efi",
  25 };
  26
  27 static const char *log_level_name[LOGL_COUNT] = {
  28         "EMERG",
  29         "ALERT",
  30         "CRIT",
  31         "ERR",
  32         "WARNING",
  33         "NOTICE",
  34         "INFO",
  35         "DEBUG",
  36         "CONTENT",
  37         "IO",
  38 };
  39
  40 const char *log_get_cat_name(enum log_category_t cat)
  41 {
  42         if (cat > LOGC_COUNT)
  43                 return "invalid";
  44         if (cat >= LOGC_NONE)
  45                 return log_cat_name[cat - LOGC_NONE];
  46
  47         return uclass_get_name((enum uclass_id)cat);
  48 }
  49
  50 enum log_category_t log_get_cat_by_name(const char *name)
  51 {
  52         enum uclass_id id;
  53         int i;
  54
  55         for (i = LOGC_NONE; i < LOGC_COUNT; i++)
  56                 if (!strcmp(name, log_cat_name[i - LOGC_NONE]))
  57                         return i;
  58         id = uclass_get_by_name(name);
  59         if (id != UCLASS_INVALID)
  60                 return (enum log_category_t)id;
  61
  62         return LOGC_NONE;
  63 }
  64
  65 const char *log_get_level_name(enum log_level_t level)
  66 {
  67         if (level >= LOGL_COUNT)
  68                 return "INVALID";
  69         return log_level_name[level];
  70 }
  71
  72 enum log_level_t log_get_level_by_name(const char *name)
  73 {
  74         int i;
  75
  76         for (i = 0; i < LOGL_COUNT; i++) {
  77                 if (!strcasecmp(log_level_name[i], name))
  78                         return i;
  79         }
  80
  81         return LOGL_NONE;
  82 }
  83
  84 static struct log_device *log_device_find_by_name(const char *drv_name)
  85 {
  86         struct log_device *ldev;
  87
  88         list_for_each_entry(ldev, &gd->log_head, sibling_node) {
  89                 if (!strcmp(drv_name, ldev->drv->name))
  90                         return ldev;
  91         }
  92
  93         return NULL;
  94 }
  95
  96 /**
  97  * log_has_cat() - check if a log category exists within a list
  98  *
  99  * @cat_list: List of categories to check, at most LOGF_MAX_CATEGORIES entries
 100  *      long, terminated by LC_END if fewer
 101  * @cat: Category to search for
 102  * @return true if @cat is in @cat_list, else false
 103  */
 104 static bool log_has_cat(enum log_category_t cat_list[], enum log_category_t cat)
 105 {
 106         int i;
 107
 108         for (i = 0; i < LOGF_MAX_CATEGORIES && cat_list[i] != LOGC_END; i++) {
 109                 if (cat_list[i] == cat)
 110                         return true;
 111         }
 112
 113         return false;
 114 }
 115
 116 /**
 117  * log_has_file() - check if a file is with a list
 118  *
 119  * @file_list: List of files to check, separated by comma
 120  * @file: File to check for. This string is matched against the end of each
 121  *      file in the list, i.e. ignoring any preceding path. The list is
 122  *      intended to consist of relative pathnames, e.g. common/main.c,cmd/log.c
 123  * @return true if @file is in @file_list, else false
 124  */
 125 static bool log_has_file(const char *file_list, const char *file)
 126 {
 127         int file_len = strlen(file);
 128         const char *s, *p;
 129         int substr_len;
 130
 131         for (s = file_list; *s; s = p + (*p != '\0')) {
 132                 p = strchrnul(s, ',');
 133                 substr_len = p - s;
 134                 if (file_len >= substr_len &&
 135                     !strncmp(file + file_len - substr_len, s, substr_len))
 136                         return true;
 137         }
 138
 139         return false;
 140 }
 141
 142 /**
 143  * log_passes_filters() - check if a log record passes the filters for a device
 144  *
 145  * @ldev: Log device to check
 146  * @rec: Log record to check
 147  * @return true if @rec is not blocked by the filters in @ldev, false if it is
 148  */
 149 static bool log_passes_filters(struct log_device *ldev, struct log_rec *rec)
 150 {
 151         struct log_filter *filt;
 152
 153         /* If there are no filters, filter on the default log level */
 154         if (list_empty(&ldev->filter_head)) {
 155                 if (rec->level > gd->default_log_level)
 156                         return false;
 157                 return true;
 158         }
 159
 160         list_for_each_entry(filt, &ldev->filter_head, sibling_node) {
 161                 if (rec->level > filt->max_level)
 162                         continue;
 163                 if ((filt->flags & LOGFF_HAS_CAT) &&
 164                     !log_has_cat(filt->cat_list, rec->cat))
 165                         continue;
 166                 if (filt->file_list &&
 167                     !log_has_file(filt->file_list, rec->file))
 168                         continue;
 169                 return true;
 170         }
 171
 172         return false;
 173 }
 174
 175 /**
 176  * log_dispatch() - Send a log record to all log devices for processing
 177  *
 178  * The log record is sent to each log device in turn, skipping those which have
 179  * filters which block the record
 180  *
 181  * @rec: Log record to dispatch
 182  * @return 0 (meaning success)
 183  */
 184 static int log_dispatch(struct log_rec *rec)
 185 {
 186         struct log_device *ldev;
 187
 188         list_for_each_entry(ldev, &gd->log_head, sibling_node) {
 189                 if (log_passes_filters(ldev, rec))
 190                         ldev->drv->emit(ldev, rec);
 191         }
 192
 193         return 0;
 194 }
 195
 196 int _log(enum log_category_t cat, enum log_level_t level, const char *file,
 197          int line, const char *func, const char *fmt, ...)
 198 {
 199         char buf[CONFIG_SYS_CBSIZE];
 200         struct log_rec rec;
 201         va_list args;
 202
 203         rec.cat = cat;
 204         rec.level = level;
 205         rec.file = file;
 206         rec.line = line;
 207         rec.func = func;
 208         va_start(args, fmt);
 209         vsnprintf(buf, sizeof(buf), fmt, args);
 210         va_end(args);
 211         rec.msg = buf;
 212         if (!gd || !(gd->flags & GD_FLG_LOG_READY)) {
 213                 if (gd)
 214                         gd->log_drop_count++;
 215                 return -ENOSYS;
 216         }
 217         log_dispatch(&rec);
 218
 219         return 0;
 220 }
 221
 222 int log_add_filter(const char *drv_name, enum log_category_t cat_list[],
 223                    enum log_level_t max_level, const char *file_list)
 224 {
 225         struct log_filter *filt;
 226         struct log_device *ldev;
 227         int ret;
 228         int i;
 229
 230         ldev = log_device_find_by_name(drv_name);
 231         if (!ldev)
 232                 return -ENOENT;
 233         filt = (struct log_filter *)calloc(1, sizeof(*filt));
 234         if (!filt)
 235                 return -ENOMEM;
 236
 237         if (cat_list) {
 238                 filt->flags |= LOGFF_HAS_CAT;
 239                 for (i = 0; ; i++) {
 240                         if (i == ARRAY_SIZE(filt->cat_list)) {
 241                                 ret = -ENOSPC;
 242                                 goto err;
 243                         }
 244                         filt->cat_list[i] = cat_list[i];
 245                         if (cat_list[i] == LOGC_END)
 246                                 break;
 247                 }
 248         }
 249         filt->max_level = max_level;
 250         if (file_list) {
 251                 filt->file_list = strdup(file_list);
 252                 if (!filt->file_list) {
 253                         ret = ENOMEM;
 254                         goto err;
 255                 }
 256         }
 257         filt->filter_num = ldev->next_filter_num++;
 258         list_add_tail(&filt->sibling_node, &ldev->filter_head);
 259
 260         return filt->filter_num;
 261
 262 err:
 263         free(filt);
 264         return ret;
 265 }
 266
 267 int log_remove_filter(const char *drv_name, int filter_num)
 268 {
 269         struct log_filter *filt;
 270         struct log_device *ldev;
 271
 272         ldev = log_device_find_by_name(drv_name);
 273         if (!ldev)
 274                 return -ENOENT;
 275
 276         list_for_each_entry(filt, &ldev->filter_head, sibling_node) {
 277                 if (filt->filter_num == filter_num) {
 278                         list_del(&filt->sibling_node);
 279                         free(filt);
 280
 281                         return 0;
 282                 }
 283         }
 284
 285         return -ENOENT;
 286 }
 287
 288 int log_init(void)
 289 {
 290         struct log_driver *drv = ll_entry_start(struct log_driver, log_driver);
 291         const int count = ll_entry_count(struct log_driver, log_driver);
 292         struct log_driver *end = drv + count;
 293
 294         /*
 295          * We cannot add runtime data to the driver since it is likely stored
 296          * in rodata. Instead, set up a 'device' corresponding to each driver.
 297          * We only support having a single device.
 298          */
 299         INIT_LIST_HEAD((struct list_head *)&gd->log_head);
 300         while (drv < end) {
 301                 struct log_device *ldev;
 302
 303                 ldev = calloc(1, sizeof(*ldev));
 304                 if (!ldev) {
 305                         debug("%s: Cannot allocate memory\n", __func__);
 306                         return -ENOMEM;
 307                 }
 308                 INIT_LIST_HEAD(&ldev->filter_head);
 309                 ldev->drv = drv;
 310                 list_add_tail(&ldev->sibling_node,
 311                               (struct list_head *)&gd->log_head);
 312                 drv++;
 313         }
 314         gd->flags |= GD_FLG_LOG_READY;
 315         gd->default_log_level = LOGL_INFO;
 316         gd->log_fmt = LOGF_DEFAULT;
 317
 318         return 0;
 319 }