log.c 8.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405
  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 *const log_cat_name[] = {
  14. "none",
  15. "arch",
  16. "board",
  17. "core",
  18. "driver-model",
  19. "device-tree",
  20. "efi",
  21. "alloc",
  22. "sandbox",
  23. "bloblist",
  24. "devres",
  25. "acpi",
  26. "boot",
  27. };
  28. _Static_assert(ARRAY_SIZE(log_cat_name) == LOGC_COUNT - LOGC_NONE,
  29. "log_cat_name size");
  30. static const char *const log_level_name[] = {
  31. "EMERG",
  32. "ALERT",
  33. "CRIT",
  34. "ERR",
  35. "WARNING",
  36. "NOTICE",
  37. "INFO",
  38. "DEBUG",
  39. "CONTENT",
  40. "IO",
  41. };
  42. _Static_assert(ARRAY_SIZE(log_level_name) == LOGL_COUNT, "log_level_name size");
  43. /* All error responses MUST begin with '<' */
  44. const char *log_get_cat_name(enum log_category_t cat)
  45. {
  46. const char *name;
  47. if (cat < 0 || cat >= LOGC_COUNT)
  48. return "<invalid>";
  49. if (cat >= LOGC_NONE)
  50. return log_cat_name[cat - LOGC_NONE];
  51. #if CONFIG_IS_ENABLED(DM)
  52. name = uclass_get_name((enum uclass_id)cat);
  53. #else
  54. name = NULL;
  55. #endif
  56. return name ? name : "<missing>";
  57. }
  58. enum log_category_t log_get_cat_by_name(const char *name)
  59. {
  60. enum uclass_id id;
  61. int i;
  62. for (i = LOGC_NONE; i < LOGC_COUNT; i++)
  63. if (!strcmp(name, log_cat_name[i - LOGC_NONE]))
  64. return i;
  65. id = uclass_get_by_name(name);
  66. if (id != UCLASS_INVALID)
  67. return (enum log_category_t)id;
  68. return LOGC_NONE;
  69. }
  70. const char *log_get_level_name(enum log_level_t level)
  71. {
  72. if (level >= LOGL_COUNT)
  73. return "INVALID";
  74. return log_level_name[level];
  75. }
  76. enum log_level_t log_get_level_by_name(const char *name)
  77. {
  78. int i;
  79. for (i = 0; i < LOGL_COUNT; i++) {
  80. if (!strcasecmp(log_level_name[i], name))
  81. return i;
  82. }
  83. return LOGL_NONE;
  84. }
  85. struct log_device *log_device_find_by_name(const char *drv_name)
  86. {
  87. struct log_device *ldev;
  88. list_for_each_entry(ldev, &gd->log_head, sibling_node) {
  89. if (!strcmp(drv_name, ldev->drv->name))
  90. return ldev;
  91. }
  92. return NULL;
  93. }
  94. bool log_has_cat(enum log_category_t cat_list[], enum log_category_t cat)
  95. {
  96. int i;
  97. for (i = 0; i < LOGF_MAX_CATEGORIES && cat_list[i] != LOGC_END; i++) {
  98. if (cat_list[i] == cat)
  99. return true;
  100. }
  101. return false;
  102. }
  103. bool log_has_file(const char *file_list, const char *file)
  104. {
  105. int file_len = strlen(file);
  106. const char *s, *p;
  107. int substr_len;
  108. for (s = file_list; *s; s = p + (*p != '\0')) {
  109. p = strchrnul(s, ',');
  110. substr_len = p - s;
  111. if (file_len >= substr_len &&
  112. !strncmp(file + file_len - substr_len, s, substr_len))
  113. return true;
  114. }
  115. return false;
  116. }
  117. /**
  118. * log_passes_filters() - check if a log record passes the filters for a device
  119. *
  120. * @ldev: Log device to check
  121. * @rec: Log record to check
  122. * @return true if @rec is not blocked by the filters in @ldev, false if it is
  123. */
  124. static bool log_passes_filters(struct log_device *ldev, struct log_rec *rec)
  125. {
  126. struct log_filter *filt;
  127. if (rec->force_debug)
  128. return true;
  129. /* If there are no filters, filter on the default log level */
  130. if (list_empty(&ldev->filter_head)) {
  131. if (rec->level > gd->default_log_level)
  132. return false;
  133. return true;
  134. }
  135. list_for_each_entry(filt, &ldev->filter_head, sibling_node) {
  136. if (filt->flags & LOGFF_LEVEL_MIN) {
  137. if (rec->level < filt->level)
  138. continue;
  139. } else if (rec->level > filt->level) {
  140. continue;
  141. }
  142. if ((filt->flags & LOGFF_HAS_CAT) &&
  143. !log_has_cat(filt->cat_list, rec->cat))
  144. continue;
  145. if (filt->file_list &&
  146. !log_has_file(filt->file_list, rec->file))
  147. continue;
  148. if (filt->flags & LOGFF_DENY)
  149. return false;
  150. else
  151. return true;
  152. }
  153. return false;
  154. }
  155. /**
  156. * log_dispatch() - Send a log record to all log devices for processing
  157. *
  158. * The log record is sent to each log device in turn, skipping those which have
  159. * filters which block the record.
  160. *
  161. * All log messages created while processing log record @rec are ignored.
  162. *
  163. * @rec: log record to dispatch
  164. * Return: 0 msg sent, 1 msg not sent while already dispatching another msg
  165. */
  166. static int log_dispatch(struct log_rec *rec)
  167. {
  168. struct log_device *ldev;
  169. /*
  170. * When a log driver writes messages (e.g. via the network stack) this
  171. * may result in further generated messages. We cannot process them here
  172. * as this might result in infinite recursion.
  173. */
  174. if (gd->processing_msg)
  175. return 1;
  176. /* Emit message */
  177. gd->processing_msg = true;
  178. list_for_each_entry(ldev, &gd->log_head, sibling_node) {
  179. if ((ldev->flags & LOGDF_ENABLE) &&
  180. log_passes_filters(ldev, rec))
  181. ldev->drv->emit(ldev, rec);
  182. }
  183. gd->processing_msg = false;
  184. return 0;
  185. }
  186. int _log(enum log_category_t cat, enum log_level_t level, const char *file,
  187. int line, const char *func, const char *fmt, ...)
  188. {
  189. char buf[CONFIG_SYS_CBSIZE];
  190. struct log_rec rec;
  191. va_list args;
  192. /* Check for message continuation */
  193. if (cat == LOGC_CONT)
  194. cat = gd->logc_prev;
  195. if (level == LOGL_CONT)
  196. level = gd->logl_prev;
  197. rec.cat = cat;
  198. rec.level = level & LOGL_LEVEL_MASK;
  199. rec.force_debug = level & LOGL_FORCE_DEBUG;
  200. rec.file = file;
  201. rec.line = line;
  202. rec.func = func;
  203. va_start(args, fmt);
  204. vsnprintf(buf, sizeof(buf), fmt, args);
  205. va_end(args);
  206. rec.msg = buf;
  207. if (!gd || !(gd->flags & GD_FLG_LOG_READY)) {
  208. if (gd)
  209. gd->log_drop_count++;
  210. return -ENOSYS;
  211. }
  212. if (!log_dispatch(&rec)) {
  213. gd->logc_prev = cat;
  214. gd->logl_prev = level;
  215. }
  216. return 0;
  217. }
  218. int log_add_filter_flags(const char *drv_name, enum log_category_t cat_list[],
  219. enum log_level_t level, const char *file_list,
  220. int flags)
  221. {
  222. struct log_filter *filt;
  223. struct log_device *ldev;
  224. int ret;
  225. int i;
  226. ldev = log_device_find_by_name(drv_name);
  227. if (!ldev)
  228. return -ENOENT;
  229. filt = calloc(1, sizeof(*filt));
  230. if (!filt)
  231. return -ENOMEM;
  232. filt->flags = flags;
  233. if (cat_list) {
  234. filt->flags |= LOGFF_HAS_CAT;
  235. for (i = 0; ; i++) {
  236. if (i == ARRAY_SIZE(filt->cat_list)) {
  237. ret = -ENOSPC;
  238. goto err;
  239. }
  240. filt->cat_list[i] = cat_list[i];
  241. if (cat_list[i] == LOGC_END)
  242. break;
  243. }
  244. }
  245. filt->level = level;
  246. if (file_list) {
  247. filt->file_list = strdup(file_list);
  248. if (!filt->file_list) {
  249. ret = -ENOMEM;
  250. goto err;
  251. }
  252. }
  253. filt->filter_num = ldev->next_filter_num++;
  254. /* Add deny filters to the beginning of the list */
  255. if (flags & LOGFF_DENY)
  256. list_add(&filt->sibling_node, &ldev->filter_head);
  257. else
  258. list_add_tail(&filt->sibling_node, &ldev->filter_head);
  259. return filt->filter_num;
  260. err:
  261. free(filt);
  262. return ret;
  263. }
  264. int log_remove_filter(const char *drv_name, int filter_num)
  265. {
  266. struct log_filter *filt;
  267. struct log_device *ldev;
  268. ldev = log_device_find_by_name(drv_name);
  269. if (!ldev)
  270. return -ENOENT;
  271. list_for_each_entry(filt, &ldev->filter_head, sibling_node) {
  272. if (filt->filter_num == filter_num) {
  273. list_del(&filt->sibling_node);
  274. free(filt);
  275. return 0;
  276. }
  277. }
  278. return -ENOENT;
  279. }
  280. /**
  281. * log_find_device_by_drv() - Find a device by its driver
  282. *
  283. * @drv: Log driver
  284. * @return Device associated with that driver, or NULL if not found
  285. */
  286. static struct log_device *log_find_device_by_drv(struct log_driver *drv)
  287. {
  288. struct log_device *ldev;
  289. list_for_each_entry(ldev, &gd->log_head, sibling_node) {
  290. if (ldev->drv == drv)
  291. return ldev;
  292. }
  293. /*
  294. * It is quite hard to pass an invalid driver since passing an unknown
  295. * LOG_GET_DRIVER(xxx) would normally produce a compilation error. But
  296. * it is possible to pass NULL, for example, so this
  297. */
  298. return NULL;
  299. }
  300. int log_device_set_enable(struct log_driver *drv, bool enable)
  301. {
  302. struct log_device *ldev;
  303. ldev = log_find_device_by_drv(drv);
  304. if (!ldev)
  305. return -ENOENT;
  306. if (enable)
  307. ldev->flags |= LOGDF_ENABLE;
  308. else
  309. ldev->flags &= ~LOGDF_ENABLE;
  310. return 0;
  311. }
  312. int log_init(void)
  313. {
  314. struct log_driver *drv = ll_entry_start(struct log_driver, log_driver);
  315. const int count = ll_entry_count(struct log_driver, log_driver);
  316. struct log_driver *end = drv + count;
  317. /*
  318. * We cannot add runtime data to the driver since it is likely stored
  319. * in rodata. Instead, set up a 'device' corresponding to each driver.
  320. * We only support having a single device.
  321. */
  322. INIT_LIST_HEAD((struct list_head *)&gd->log_head);
  323. while (drv < end) {
  324. struct log_device *ldev;
  325. ldev = calloc(1, sizeof(*ldev));
  326. if (!ldev) {
  327. debug("%s: Cannot allocate memory\n", __func__);
  328. return -ENOMEM;
  329. }
  330. INIT_LIST_HEAD(&ldev->filter_head);
  331. ldev->drv = drv;
  332. ldev->flags = drv->flags;
  333. list_add_tail(&ldev->sibling_node,
  334. (struct list_head *)&gd->log_head);
  335. drv++;
  336. }
  337. gd->flags |= GD_FLG_LOG_READY;
  338. if (!gd->default_log_level)
  339. gd->default_log_level = CONFIG_LOG_DEFAULT_LEVEL;
  340. gd->log_fmt = log_get_default_format();
  341. gd->logc_prev = LOGC_NONE;
  342. gd->logl_prev = LOGL_INFO;
  343. return 0;
  344. }