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
  14 DECLARE_GLOBAL_DATA_PTR;
  15
  16 static struct log_device *log_device_find_by_name(const char *drv_name)
  17 {
  18         struct log_device *ldev;
  19
  20         list_for_each_entry(ldev, &gd->log_head, sibling_node) {
  21                 if (!strcmp(drv_name, ldev->drv->name))
  22                         return ldev;
  23         }
  24
  25         return NULL;
  26 }
  27
  28 /**
  29  * log_has_cat() - check if a log category exists within a list
  30  *
  31  * @cat_list: List of categories to check, at most LOGF_MAX_CATEGORIES entries
  32  *      long, terminated by LC_END if fewer
  33  * @cat: Category to search for
  34  * @return true if @cat is in @cat_list, else false
  35  */
  36 static bool log_has_cat(enum log_category_t cat_list[], enum log_category_t cat)
  37 {
  38         int i;
  39
  40         for (i = 0; i < LOGF_MAX_CATEGORIES && cat_list[i] != LOGC_END; i++) {
  41                 if (cat_list[i] == cat)
  42                         return true;
  43         }
  44
  45         return false;
  46 }
  47
  48 /**
  49  * log_has_file() - check if a file is with a list
  50  *
  51  * @file_list: List of files to check, separated by comma
  52  * @file: File to check for. This string is matched against the end of each
  53  *      file in the list, i.e. ignoring any preceding path. The list is
  54  *      intended to consist of relative pathnames, e.g. common/main.c,cmd/log.c
  55  * @return true if @file is in @file_list, else false
  56  */
  57 static bool log_has_file(const char *file_list, const char *file)
  58 {
  59         int file_len = strlen(file);
  60         const char *s, *p;
  61         int substr_len;
  62
  63         for (s = file_list; *s; s = p + (*p != '\0')) {
  64                 p = strchrnul(s, ',');
  65                 substr_len = p - s;
  66                 if (file_len >= substr_len &&
  67                     !strncmp(file + file_len - substr_len, s, substr_len))
  68                         return true;
  69         }
  70
  71         return false;
  72 }
  73
  74 /**
  75  * log_passes_filters() - check if a log record passes the filters for a device
  76  *
  77  * @ldev: Log device to check
  78  * @rec: Log record to check
  79  * @return true if @rec is not blocked by the filters in @ldev, false if it is
  80  */
  81 static bool log_passes_filters(struct log_device *ldev, struct log_rec *rec)
  82 {
  83         struct log_filter *filt;
  84
  85         /* If there are no filters, filter on the default log level */
  86         if (list_empty(&ldev->filter_head)) {
  87                 if (rec->level > gd->default_log_level)
  88                         return false;
  89                 return true;
  90         }
  91
  92         list_for_each_entry(filt, &ldev->filter_head, sibling_node) {
  93                 if (rec->level > filt->max_level)
  94                         continue;
  95                 if ((filt->flags & LOGFF_HAS_CAT) &&
  96                     !log_has_cat(filt->cat_list, rec->cat))
  97                         continue;
  98                 if (filt->file_list &&
  99                     !log_has_file(filt->file_list, rec->file))
 100                         continue;
 101                 return true;
 102         }
 103
 104         return false;
 105 }
 106
 107 /**
 108  * log_dispatch() - Send a log record to all log devices for processing
 109  *
 110  * The log record is sent to each log device in turn, skipping those which have
 111  * filters which block the record
 112  *
 113  * @rec: Log record to dispatch
 114  * @return 0 (meaning success)
 115  */
 116 static int log_dispatch(struct log_rec *rec)
 117 {
 118         struct log_device *ldev;
 119
 120         list_for_each_entry(ldev, &gd->log_head, sibling_node) {
 121                 if (log_passes_filters(ldev, rec))
 122                         ldev->drv->emit(ldev, rec);
 123         }
 124
 125         return 0;
 126 }
 127
 128 int _log(enum log_category_t cat, enum log_level_t level, const char *file,
 129          int line, const char *func, const char *fmt, ...)
 130 {
 131         char buf[CONFIG_SYS_CBSIZE];
 132         struct log_rec rec;
 133         va_list args;
 134
 135         rec.cat = cat;
 136         rec.level = level;
 137         rec.file = file;
 138         rec.line = line;
 139         rec.func = func;
 140         va_start(args, fmt);
 141         vsnprintf(buf, sizeof(buf), fmt, args);
 142         va_end(args);
 143         rec.msg = buf;
 144         if (!gd || !(gd->flags & GD_FLG_LOG_READY)) {
 145                 if (gd)
 146                         gd->log_drop_count++;
 147                 return -ENOSYS;
 148         }
 149         log_dispatch(&rec);
 150
 151         return 0;
 152 }
 153
 154 int log_add_filter(const char *drv_name, enum log_category_t cat_list[],
 155                    enum log_level_t max_level, const char *file_list)
 156 {
 157         struct log_filter *filt;
 158         struct log_device *ldev;
 159         int i;
 160
 161         ldev = log_device_find_by_name(drv_name);
 162         if (!ldev)
 163                 return -ENOENT;
 164         filt = (struct log_filter *)calloc(1, sizeof(*filt));
 165         if (!filt)
 166                 return -ENOMEM;
 167
 168         if (cat_list) {
 169                 filt->flags |= LOGFF_HAS_CAT;
 170                 for (i = 0; ; i++) {
 171                         if (i == ARRAY_SIZE(filt->cat_list))
 172                                 return -ENOSPC;
 173                         filt->cat_list[i] = cat_list[i];
 174                         if (cat_list[i] == LOGC_END)
 175                                 break;
 176                 }
 177         }
 178         filt->max_level = max_level;
 179         if (file_list) {
 180                 filt->file_list = strdup(file_list);
 181                 if (!filt->file_list)
 182                         goto nomem;
 183         }
 184         filt->filter_num = ldev->next_filter_num++;
 185         list_add_tail(&filt->sibling_node, &ldev->filter_head);
 186
 187         return filt->filter_num;
 188
 189 nomem:
 190         free(filt);
 191         return -ENOMEM;
 192 }
 193
 194 int log_remove_filter(const char *drv_name, int filter_num)
 195 {
 196         struct log_filter *filt;
 197         struct log_device *ldev;
 198
 199         ldev = log_device_find_by_name(drv_name);
 200         if (!ldev)
 201                 return -ENOENT;
 202
 203         list_for_each_entry(filt, &ldev->filter_head, sibling_node) {
 204                 if (filt->filter_num == filter_num) {
 205                         list_del(&filt->sibling_node);
 206                         free(filt);
 207
 208                         return 0;
 209                 }
 210         }
 211
 212         return -ENOENT;
 213 }
 214
 215 int log_init(void)
 216 {
 217         struct log_driver *drv = ll_entry_start(struct log_driver, log_driver);
 218         const int count = ll_entry_count(struct log_driver, log_driver);
 219         struct log_driver *end = drv + count;
 220
 221         /*
 222          * We cannot add runtime data to the driver since it is likely stored
 223          * in rodata. Instead, set up a 'device' corresponding to each driver.
 224          * We only support having a single device.
 225          */
 226         INIT_LIST_HEAD((struct list_head *)&gd->log_head);
 227         while (drv < end) {
 228                 struct log_device *ldev;
 229
 230                 ldev = calloc(1, sizeof(*ldev));
 231                 if (!ldev) {
 232                         debug("%s: Cannot allocate memory\n", __func__);
 233                         return -ENOMEM;
 234                 }
 235                 INIT_LIST_HEAD(&ldev->filter_head);
 236                 ldev->drv = drv;
 237                 list_add_tail(&ldev->sibling_node,
 238                               (struct list_head *)&gd->log_head);
 239                 drv++;
 240         }
 241         gd->flags |= GD_FLG_LOG_READY;
 242         gd->default_log_level = LOGL_INFO;
 243
 244         return 0;
 245 }