[J-u-boot.git] / common / log.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Logging support
 *
 * Copyright (c) 2017 Google, Inc
 * Written by Simon Glass <[email protected]>
 */

#include <common.h>
#include <log.h>
#include <malloc.h>
#include <dm/uclass.h>

DECLARE_GLOBAL_DATA_PTR;

static const char *log_cat_name[LOGC_COUNT - LOGC_NONE] = {
	"none",
	"arch",
	"board",
	"core",
	"driver-model",
	"device-tree",
	"efi",
};

static const char *log_level_name[LOGL_COUNT] = {
	"EMERG",
	"ALERT",
	"CRIT",
	"ERR",
	"WARNING",
	"NOTICE",
	"INFO",
	"DEBUG",
	"CONTENT",
	"IO",
};

const char *log_get_cat_name(enum log_category_t cat)
{
	const char *name;

	if (cat < 0 || cat >= LOGC_COUNT)
		return "<invalid>";
	if (cat >= LOGC_NONE)
		return log_cat_name[cat - LOGC_NONE];

#if CONFIG_IS_ENABLED(DM)
	name = uclass_get_name((enum uclass_id)cat);
#else
	name = NULL;
#endif

	return name ? name : "<missing>";
}

enum log_category_t log_get_cat_by_name(const char *name)
{
	enum uclass_id id;
	int i;

	for (i = LOGC_NONE; i < LOGC_COUNT; i++)
		if (!strcmp(name, log_cat_name[i - LOGC_NONE]))
			return i;
	id = uclass_get_by_name(name);
	if (id != UCLASS_INVALID)
		return (enum log_category_t)id;

	return LOGC_NONE;
}

const char *log_get_level_name(enum log_level_t level)
{
	if (level >= LOGL_COUNT)
		return "INVALID";
	return log_level_name[level];
}

enum log_level_t log_get_level_by_name(const char *name)
{
	int i;

	for (i = 0; i < LOGL_COUNT; i++) {
		if (!strcasecmp(log_level_name[i], name))
			return i;
	}

	return LOGL_NONE;
}

static struct log_device *log_device_find_by_name(const char *drv_name)
{
	struct log_device *ldev;

	list_for_each_entry(ldev, &gd->log_head, sibling_node) {
		if (!strcmp(drv_name, ldev->drv->name))
			return ldev;
	}

	return NULL;
}

/**
 * log_has_cat() - check if a log category exists within a list
 *
 * @cat_list: List of categories to check, at most LOGF_MAX_CATEGORIES entries
 *	long, terminated by LC_END if fewer
 * @cat: Category to search for
 * @return true if @cat is in @cat_list, else false
 */
static bool log_has_cat(enum log_category_t cat_list[], enum log_category_t cat)
{
	int i;

	for (i = 0; i < LOGF_MAX_CATEGORIES && cat_list[i] != LOGC_END; i++) {
		if (cat_list[i] == cat)
			return true;
	}

	return false;
}

/**
 * log_has_file() - check if a file is with a list
 *
 * @file_list: List of files to check, separated by comma
 * @file: File to check for. This string is matched against the end of each
 *	file in the list, i.e. ignoring any preceding path. The list is
 *	intended to consist of relative pathnames, e.g. common/main.c,cmd/log.c
 * @return true if @file is in @file_list, else false
 */
static bool log_has_file(const char *file_list, const char *file)
{
	int file_len = strlen(file);
	const char *s, *p;
	int substr_len;

	for (s = file_list; *s; s = p + (*p != '\0')) {
		p = strchrnul(s, ',');
		substr_len = p - s;
		if (file_len >= substr_len &&
		    !strncmp(file + file_len - substr_len, s, substr_len))
			return true;
	}

	return false;
}

/**
 * log_passes_filters() - check if a log record passes the filters for a device
 *
 * @ldev: Log device to check
 * @rec: Log record to check
 * @return true if @rec is not blocked by the filters in @ldev, false if it is
 */
static bool log_passes_filters(struct log_device *ldev, struct log_rec *rec)
{
	struct log_filter *filt;

	if (rec->force_debug)
		return true;

	/* If there are no filters, filter on the default log level */
	if (list_empty(&ldev->filter_head)) {
		if (rec->level > gd->default_log_level)
			return false;
		return true;
	}

	list_for_each_entry(filt, &ldev->filter_head, sibling_node) {
		if (rec->level > filt->max_level)
			continue;
		if ((filt->flags & LOGFF_HAS_CAT) &&
		    !log_has_cat(filt->cat_list, rec->cat))
			continue;
		if (filt->file_list &&
		    !log_has_file(filt->file_list, rec->file))
			continue;
		return true;
	}

	return false;
}

/**
 * log_dispatch() - Send a log record to all log devices for processing
 *
 * The log record is sent to each log device in turn, skipping those which have
 * filters which block the record
 *
 * @rec: Log record to dispatch
 * @return 0 (meaning success)
 */
static int log_dispatch(struct log_rec *rec)
{
	struct log_device *ldev;
	static int processing_msg;

	/*
	 * When a log driver writes messages (e.g. via the network stack) this
	 * may result in further generated messages. We cannot process them here
	 * as this might result in infinite recursion.
	 */
	if (processing_msg)
		return 0;

	/* Emit message */
	processing_msg = 1;
	list_for_each_entry(ldev, &gd->log_head, sibling_node) {
		if ((ldev->flags & LOGDF_ENABLE) &&
		    log_passes_filters(ldev, rec))
			ldev->drv->emit(ldev, rec);
	}
	processing_msg = 0;
	return 0;
}

int _log(enum log_category_t cat, enum log_level_t level, const char *file,
	 int line, const char *func, const char *fmt, ...)
{
	char buf[CONFIG_SYS_CBSIZE];
	struct log_rec rec;
	va_list args;

	rec.cat = cat;
	rec.level = level & LOGL_LEVEL_MASK;
	rec.force_debug = level & LOGL_FORCE_DEBUG;
	rec.file = file;
	rec.line = line;
	rec.func = func;
	va_start(args, fmt);
	vsnprintf(buf, sizeof(buf), fmt, args);
	va_end(args);
	rec.msg = buf;
	if (!gd || !(gd->flags & GD_FLG_LOG_READY)) {
		if (gd)
			gd->log_drop_count++;
		return -ENOSYS;
	}
	log_dispatch(&rec);

	return 0;
}

int log_add_filter(const char *drv_name, enum log_category_t cat_list[],
		   enum log_level_t max_level, const char *file_list)
{
	struct log_filter *filt;
	struct log_device *ldev;
	int ret;
	int i;

	ldev = log_device_find_by_name(drv_name);
	if (!ldev)
		return -ENOENT;
	filt = calloc(1, sizeof(*filt));
	if (!filt)
		return -ENOMEM;

	if (cat_list) {
		filt->flags |= LOGFF_HAS_CAT;
		for (i = 0; ; i++) {
			if (i == ARRAY_SIZE(filt->cat_list)) {
				ret = -ENOSPC;
				goto err;
			}
			filt->cat_list[i] = cat_list[i];
			if (cat_list[i] == LOGC_END)
				break;
		}
	}
	filt->max_level = max_level;
	if (file_list) {
		filt->file_list = strdup(file_list);
		if (!filt->file_list) {
			ret = ENOMEM;
			goto err;
		}
	}
	filt->filter_num = ldev->next_filter_num++;
	list_add_tail(&filt->sibling_node, &ldev->filter_head);

	return filt->filter_num;

err:
	free(filt);
	return ret;
}

int log_remove_filter(const char *drv_name, int filter_num)
{
	struct log_filter *filt;
	struct log_device *ldev;

	ldev = log_device_find_by_name(drv_name);
	if (!ldev)
		return -ENOENT;

	list_for_each_entry(filt, &ldev->filter_head, sibling_node) {
		if (filt->filter_num == filter_num) {
			list_del(&filt->sibling_node);
			free(filt);

			return 0;
		}
	}

	return -ENOENT;
}

/**
 * log_find_device_by_drv() - Find a device by its driver
 *
 * @drv: Log driver
 * @return Device associated with that driver, or NULL if not found
 */
static struct log_device *log_find_device_by_drv(struct log_driver *drv)
{
	struct log_device *ldev;

	list_for_each_entry(ldev, &gd->log_head, sibling_node) {
		if (ldev->drv == drv)
			return ldev;
	}
	/*
	 * It is quite hard to pass an invalid driver since passing an unknown
	 * LOG_GET_DRIVER(xxx) would normally produce a compilation error. But
	 * it is possible to pass NULL, for example, so this
	 */

	return NULL;
}

int log_device_set_enable(struct log_driver *drv, bool enable)
{
	struct log_device *ldev;

	ldev = log_find_device_by_drv(drv);
	if (!ldev)
		return -ENOENT;
	if (enable)
		ldev->flags |= LOGDF_ENABLE;
	else
		ldev->flags &= ~LOGDF_ENABLE;

	return 0;
}

int log_init(void)
{
	struct log_driver *drv = ll_entry_start(struct log_driver, log_driver);
	const int count = ll_entry_count(struct log_driver, log_driver);
	struct log_driver *end = drv + count;

	/*
	 * We cannot add runtime data to the driver since it is likely stored
	 * in rodata. Instead, set up a 'device' corresponding to each driver.
	 * We only support having a single device.
	 */
	INIT_LIST_HEAD((struct list_head *)&gd->log_head);
	while (drv < end) {
		struct log_device *ldev;

		ldev = calloc(1, sizeof(*ldev));
		if (!ldev) {
			debug("%s: Cannot allocate memory\n", __func__);
			return -ENOMEM;
		}
		INIT_LIST_HEAD(&ldev->filter_head);
		ldev->drv = drv;
		ldev->flags = drv->flags;
		list_add_tail(&ldev->sibling_node,
			      (struct list_head *)&gd->log_head);
		drv++;
	}
	gd->flags |= GD_FLG_LOG_READY;
	if (!gd->default_log_level)
		gd->default_log_level = CONFIG_LOG_DEFAULT_LEVEL;
	gd->log_fmt = log_get_default_format();

	return 0;
}
Commit	Line	Data
83d290c5	1	// SPDX-License-Identifier: GPL-2.0+
e9c8d49d SG	2	/*
	3	* Logging support
	4	*
	5	* Copyright (c) 2017 Google, Inc
	6	* Written by Simon Glass <[email protected]>
e9c8d49d SG	7	*/
	8
	9	#include <common.h>
	10	#include <log.h>
	11	#include <malloc.h>
f941c8d7	12	#include <dm/uclass.h>
e9c8d49d SG	13
	14	DECLARE_GLOBAL_DATA_PTR;
	15
f941c8d7 SG	16	static const char *log_cat_name[LOGC_COUNT - LOGC_NONE] = {
	17	"none",
	18	"arch",
	19	"board",
	20	"core",
	21	"driver-model",
	22	"device-tree",
1973b381	23	"efi",
f941c8d7 SG	24	};
	25
	26	static const char *log_level_name[LOGL_COUNT] = {
	27	"EMERG",
	28	"ALERT",
	29	"CRIT",
	30	"ERR",
	31	"WARNING",
	32	"NOTICE",
	33	"INFO",
	34	"DEBUG",
	35	"CONTENT",
	36	"IO",
	37	};
	38
	39	const char *log_get_cat_name(enum log_category_t cat)
	40	{
c2e4e7e6 SG	41	const char *name;
	42
	43	if (cat < 0 \|\| cat >= LOGC_COUNT)
	44	return "<invalid>";
f941c8d7 SG	45	if (cat >= LOGC_NONE)
	46	return log_cat_name[cat - LOGC_NONE];
	47
6c9e4175	48	#if CONFIG_IS_ENABLED(DM)
c2e4e7e6	49	name = uclass_get_name((enum uclass_id)cat);
6c9e4175 HS	50	#else
	51	name = NULL;
	52	#endif
c2e4e7e6 SG	53
c2e4e7e6 SG	54	return name ? name : "<missing>";
f941c8d7 SG	55	}
	56
	57	enum log_category_t log_get_cat_by_name(const char *name)
	58	{
	59	enum uclass_id id;
	60	int i;
	61
	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
	69	return LOGC_NONE;
	70	}
	71
	72	const char *log_get_level_name(enum log_level_t level)
	73	{
	74	if (level >= LOGL_COUNT)
	75	return "INVALID";
	76	return log_level_name[level];
	77	}
	78
	79	enum log_level_t log_get_level_by_name(const char *name)
	80	{
	81	int i;
	82
	83	for (i = 0; i < LOGL_COUNT; i++) {
	84	if (!strcasecmp(log_level_name[i], name))
	85	return i;
	86	}
	87
	88	return LOGL_NONE;
	89	}
	90
e9c8d49d SG	91	static struct log_device log_device_find_by_name(const char drv_name)
	92	{
	93	struct log_device *ldev;
	94
	95	list_for_each_entry(ldev, &gd->log_head, sibling_node) {
	96	if (!strcmp(drv_name, ldev->drv->name))
	97	return ldev;
	98	}
	99
	100	return NULL;
	101	}
	102
	103	/**
	104	* log_has_cat() - check if a log category exists within a list
	105	*
	106	* @cat_list: List of categories to check, at most LOGF_MAX_CATEGORIES entries
	107	* long, terminated by LC_END if fewer
	108	* @cat: Category to search for
	109	* @return true if @cat is in @cat_list, else false
	110	*/
	111	static bool log_has_cat(enum log_category_t cat_list[], enum log_category_t cat)
	112	{
	113	int i;
	114
	115	for (i = 0; i < LOGF_MAX_CATEGORIES && cat_list[i] != LOGC_END; i++) {
	116	if (cat_list[i] == cat)
	117	return true;
	118	}
	119
	120	return false;
	121	}
	122
	123	/**
	124	* log_has_file() - check if a file is with a list
	125	*
	126	* @file_list: List of files to check, separated by comma
	127	* @file: File to check for. This string is matched against the end of each
	128	* file in the list, i.e. ignoring any preceding path. The list is
	129	* intended to consist of relative pathnames, e.g. common/main.c,cmd/log.c
	130	* @return true if @file is in @file_list, else false
	131	*/
	132	static bool log_has_file(const char file_list, const char file)
	133	{
	134	int file_len = strlen(file);
	135	const char s, p;
	136	int substr_len;
	137
	138	for (s = file_list; s; s = p + (p != '\0')) {
	139	p = strchrnul(s, ',');
	140	substr_len = p - s;
	141	if (file_len >= substr_len &&
	142	!strncmp(file + file_len - substr_len, s, substr_len))
	143	return true;
	144	}
	145
	146	return false;
	147	}
	148
	149	/**
	150	* log_passes_filters() - check if a log record passes the filters for a device
	151	*
	152	* @ldev: Log device to check
	153	* @rec: Log record to check
	154	* @return true if @rec is not blocked by the filters in @ldev, false if it is
155	*/
156	static bool log_passes_filters(struct log_device ldev, struct log_rec rec)
157	{
158	struct log_filter *filt;
159
52d3df7f SG	160	if (rec->force_debug)
	161	return true;
	162
e9c8d49d SG	163	/* If there are no filters, filter on the default log level */
	164	if (list_empty(&ldev->filter_head)) {
	165	if (rec->level > gd->default_log_level)
	166	return false;
	167	return true;
	168	}
	169
	170	list_for_each_entry(filt, &ldev->filter_head, sibling_node) {
	171	if (rec->level > filt->max_level)
	172	continue;
	173	if ((filt->flags & LOGFF_HAS_CAT) &&
	174	!log_has_cat(filt->cat_list, rec->cat))
	175	continue;
	176	if (filt->file_list &&
	177	!log_has_file(filt->file_list, rec->file))
	178	continue;
	179	return true;
	180	}
	181
	182	return false;
	183	}
	184
	185	/**
	186	* log_dispatch() - Send a log record to all log devices for processing
	187	*
	188	* The log record is sent to each log device in turn, skipping those which have
	189	* filters which block the record
	190	*
	191	* @rec: Log record to dispatch
	192	* @return 0 (meaning success)
	193	*/
	194	static int log_dispatch(struct log_rec *rec)
	195	{
	196	struct log_device *ldev;
e5b35f70 HS	197	static int processing_msg;
	198
	199	/*
	200	* When a log driver writes messages (e.g. via the network stack) this
	201	* may result in further generated messages. We cannot process them here
	202	* as this might result in infinite recursion.
	203	*/
	204	if (processing_msg)
	205	return 0;
	206
	207	/* Emit message */
	208	processing_msg = 1;
e9c8d49d	209	list_for_each_entry(ldev, &gd->log_head, sibling_node) {
b4520300 SG	210	if ((ldev->flags & LOGDF_ENABLE) &&
b4520300 SG	211	log_passes_filters(ldev, rec))
e9c8d49d SG	212	ldev->drv->emit(ldev, rec);
e9c8d49d SG	213	}
e5b35f70	214	processing_msg = 0;
e9c8d49d SG	215	return 0;
	216	}
	217
	218	int _log(enum log_category_t cat, enum log_level_t level, const char *file,
	219	int line, const char func, const char fmt, ...)
	220	{
	221	char buf[CONFIG_SYS_CBSIZE];
	222	struct log_rec rec;
	223	va_list args;
	224
	225	rec.cat = cat;
52d3df7f SG	226	rec.level = level & LOGL_LEVEL_MASK;
52d3df7f SG	227	rec.force_debug = level & LOGL_FORCE_DEBUG;
e9c8d49d SG	228	rec.file = file;
	229	rec.line = line;
	230	rec.func = func;
	231	va_start(args, fmt);
	232	vsnprintf(buf, sizeof(buf), fmt, args);
	233	va_end(args);
	234	rec.msg = buf;
	235	if (!gd \|\| !(gd->flags & GD_FLG_LOG_READY)) {
	236	if (gd)
	237	gd->log_drop_count++;
	238	return -ENOSYS;
	239	}
	240	log_dispatch(&rec);
	241
	242	return 0;
	243	}
	244
	245	int log_add_filter(const char *drv_name, enum log_category_t cat_list[],
	246	enum log_level_t max_level, const char *file_list)
	247	{
	248	struct log_filter *filt;
	249	struct log_device *ldev;
45fac9fc	250	int ret;
e9c8d49d SG	251	int i;
	252
	253	ldev = log_device_find_by_name(drv_name);
	254	if (!ldev)
	255	return -ENOENT;
c1f39edc	256	filt = calloc(1, sizeof(*filt));
e9c8d49d SG	257	if (!filt)
	258	return -ENOMEM;
	259
	260	if (cat_list) {
	261	filt->flags \|= LOGFF_HAS_CAT;
	262	for (i = 0; ; i++) {
45fac9fc SG	263	if (i == ARRAY_SIZE(filt->cat_list)) {
	264	ret = -ENOSPC;
	265	goto err;
	266	}
e9c8d49d SG	267	filt->cat_list[i] = cat_list[i];
	268	if (cat_list[i] == LOGC_END)
	269	break;
	270	}
	271	}
	272	filt->max_level = max_level;
	273	if (file_list) {
	274	filt->file_list = strdup(file_list);
45fac9fc SG	275	if (!filt->file_list) {
	276	ret = ENOMEM;
	277	goto err;
	278	}
e9c8d49d SG	279	}
	280	filt->filter_num = ldev->next_filter_num++;
	281	list_add_tail(&filt->sibling_node, &ldev->filter_head);
	282
	283	return filt->filter_num;
	284
45fac9fc	285	err:
e9c8d49d	286	free(filt);
45fac9fc	287	return ret;
e9c8d49d SG	288	}
	289
	290	int log_remove_filter(const char *drv_name, int filter_num)
	291	{
	292	struct log_filter *filt;
	293	struct log_device *ldev;
	294
	295	ldev = log_device_find_by_name(drv_name);
	296	if (!ldev)
	297	return -ENOENT;
	298
	299	list_for_each_entry(filt, &ldev->filter_head, sibling_node) {
	300	if (filt->filter_num == filter_num) {
	301	list_del(&filt->sibling_node);
	302	free(filt);
	303
	304	return 0;
	305	}
	306	}
	307
	308	return -ENOENT;
	309	}
	310
3d03ab63 SG	311	/**
	312	* log_find_device_by_drv() - Find a device by its driver
	313	*
	314	* @drv: Log driver
	315	* @return Device associated with that driver, or NULL if not found
	316	*/
	317	static struct log_device log_find_device_by_drv(struct log_driver drv)
	318	{
	319	struct log_device *ldev;
	320
	321	list_for_each_entry(ldev, &gd->log_head, sibling_node) {
	322	if (ldev->drv == drv)
	323	return ldev;
	324	}
	325	/*
	326	* It is quite hard to pass an invalid driver since passing an unknown
	327	* LOG_GET_DRIVER(xxx) would normally produce a compilation error. But
	328	* it is possible to pass NULL, for example, so this
	329	*/
	330
	331	return NULL;
	332	}
	333
	334	int log_device_set_enable(struct log_driver *drv, bool enable)
	335	{
	336	struct log_device *ldev;
	337
	338	ldev = log_find_device_by_drv(drv);
	339	if (!ldev)
	340	return -ENOENT;
	341	if (enable)
	342	ldev->flags \|= LOGDF_ENABLE;
	343	else
	344	ldev->flags &= ~LOGDF_ENABLE;
	345
	346	return 0;
	347	}
	348
e9c8d49d SG	349	int log_init(void)
	350	{
	351	struct log_driver *drv = ll_entry_start(struct log_driver, log_driver);
	352	const int count = ll_entry_count(struct log_driver, log_driver);
	353	struct log_driver *end = drv + count;
	354
	355	/*
	356	* We cannot add runtime data to the driver since it is likely stored
	357	* in rodata. Instead, set up a 'device' corresponding to each driver.
	358	* We only support having a single device.
	359	*/
	360	INIT_LIST_HEAD((struct list_head *)&gd->log_head);
	361	while (drv < end) {
	362	struct log_device *ldev;
	363
	364	ldev = calloc(1, sizeof(*ldev));
	365	if (!ldev) {
	366	debug("%s: Cannot allocate memory\n", __func__);
	367	return -ENOMEM;
	368	}
	369	INIT_LIST_HEAD(&ldev->filter_head);
	370	ldev->drv = drv;
b4520300	371	ldev->flags = drv->flags;
e9c8d49d SG	372	list_add_tail(&ldev->sibling_node,
	373	(struct list_head *)&gd->log_head);
	374	drv++;
	375	}
af1bc0cf	376	gd->flags \|= GD_FLG_LOG_READY;
2b1dc29a	377	if (!gd->default_log_level)
f0b05c95	378	gd->default_log_level = CONFIG_LOG_DEFAULT_LEVEL;
3c21d773	379	gd->log_fmt = log_get_default_format();
e9c8d49d SG	380
	381	return 0;
	382	}