log.c 6.8 KB

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