log.c 7.2 KB

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