log.c 6.9 KB

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