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 } 246