[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 <display_options.h>
#include <log.h>
#include <malloc.h>
#include <asm/global_data.h>
#include <dm/uclass.h>

DECLARE_GLOBAL_DATA_PTR;

static const char *const log_cat_name[] = {
	"none",
	"arch",
	"board",
	"core",
	"driver-model",
	"device-tree",
	"efi",
	"alloc",
	"sandbox",
	"bloblist",
	"devres",
	"acpi",
	"boot",
	"event",
	"fs",
	"expo",
};

_Static_assert(ARRAY_SIZE(log_cat_name) == LOGC_COUNT - LOGC_NONE,
	       "log_cat_name size");

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

_Static_assert(ARRAY_SIZE(log_level_name) == LOGL_COUNT, "log_level_name size");

/* All error responses MUST begin with '<' */
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;
}

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;
}

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;
}

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->flags & LOGRECF_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 (filt->flags & LOGFF_LEVEL_MIN) {
			if (rec->level < filt->level)
				continue;
		} else if (rec->level > filt->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;

		if (filt->flags & LOGFF_DENY)
			return false;
		else
			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.
 *
 * All log messages created while processing log record @rec are ignored.
 *
 * @rec:	log record to dispatch
 * Return:	0 msg sent, 1 msg not sent while already dispatching another msg
 */
static int log_dispatch(struct log_rec *rec, const char *fmt, va_list args)
{
	struct log_device *ldev;
	char buf[CONFIG_SYS_CBSIZE];

	/*
	 * 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 (gd->processing_msg)
		return 1;

	/* Emit message */
	gd->processing_msg = true;
	list_for_each_entry(ldev, &gd->log_head, sibling_node) {
		if ((ldev->flags & LOGDF_ENABLE) &&
		    log_passes_filters(ldev, rec)) {
			if (!rec->msg) {
				int len;

				len = vsnprintf(buf, sizeof(buf), fmt, args);
				rec->msg = buf;
				gd->log_cont = len && buf[len - 1] != '\n';
			}
			ldev->drv->emit(ldev, rec);
		}
	}
	gd->processing_msg = false;
	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, ...)
{
	struct log_rec rec;
	va_list args;

	if (!gd)
		return -ENOSYS;

	/* Check for message continuation */
	if (cat == LOGC_CONT)
		cat = gd->logc_prev;
	if (level == LOGL_CONT)
		level = gd->logl_prev;

	rec.cat = cat;
	rec.level = level & LOGL_LEVEL_MASK;
	rec.flags = 0;
	if (level & LOGL_FORCE_DEBUG)
		rec.flags |= LOGRECF_FORCE_DEBUG;
	if (gd->log_cont)
		rec.flags |= LOGRECF_CONT;
	rec.file = file;
	rec.line = line;
	rec.func = func;
	rec.msg = NULL;

	if (!(gd->flags & GD_FLG_LOG_READY)) {
		gd->log_drop_count++;

		/* display dropped traces with console puts and DEBUG_UART */
		if (rec.level <= CONFIG_LOG_DEFAULT_LEVEL ||
		    rec.flags & LOGRECF_FORCE_DEBUG) {
			char buf[CONFIG_SYS_CBSIZE];

			va_start(args, fmt);
			vsnprintf(buf, sizeof(buf), fmt, args);
			puts(buf);
			va_end(args);
		}

		return -ENOSYS;
	}
	va_start(args, fmt);
	if (!log_dispatch(&rec, fmt, args)) {
		gd->logc_prev = cat;
		gd->logl_prev = level;
	}
	va_end(args);

	return 0;
}

#define MAX_LINE_LENGTH_BYTES		64
#define DEFAULT_LINE_LENGTH_BYTES	16

int _log_buffer(enum log_category_t cat, enum log_level_t level,
		const char *file, int line, const char *func, ulong addr,
		const void *data, uint width, uint count, uint linelen)
{
	if (linelen * width > MAX_LINE_LENGTH_BYTES)
		linelen = MAX_LINE_LENGTH_BYTES / width;
	if (linelen < 1)
		linelen = DEFAULT_LINE_LENGTH_BYTES / width;

	while (count) {
		uint thislinelen;
		char buf[HEXDUMP_MAX_BUF_LENGTH(width * linelen)];

		thislinelen = hexdump_line(addr, data, width, count, linelen,
					   buf, sizeof(buf));
		assert(thislinelen >= 0);
		_log(cat, level, file, line, func, "%s\n", buf);

		/* update references */
		data += thislinelen * width;
		addr += thislinelen * width;
		count -= thislinelen;
	}

	return 0;
}

int log_add_filter_flags(const char *drv_name, enum log_category_t cat_list[],
			 enum log_level_t level, const char *file_list,
			 int flags)
{
	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;

	filt->flags = flags;
	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->level = 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++;
	/* Add deny filters to the beginning of the list */
	if (flags & LOGFF_DENY)
		list_add(&filt->sibling_node, &ldev->filter_head);
	else
		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;
}

void log_fixup_for_gd_move(struct global_data *new_gd)
{
	new_gd->log_head.prev->next = &new_gd->log_head;
}

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 for each driver.
	 */
	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();
	gd->logc_prev = LOGC_NONE;
	gd->logl_prev = LOGL_INFO;

	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	*/
e9c8d49d SG	8
4e4bf944	9	#include <display_options.h>
e9c8d49d SG	10	#include <log.h>
e9c8d49d SG	11	#include <malloc.h>
401d1c4f	12	#include <asm/global_data.h>
f941c8d7	13	#include <dm/uclass.h>
e9c8d49d SG	14
	15	DECLARE_GLOBAL_DATA_PTR;
	16
43381401	17	static const char *const log_cat_name[] = {
f941c8d7 SG	18	"none",
	19	"arch",
	20	"board",
	21	"core",
	22	"driver-model",
	23	"device-tree",
1973b381	24	"efi",
8021296a SG	25	"alloc",
	26	"sandbox",
	27	"bloblist",
	28	"devres",
	29	"acpi",
b73d61a5	30	"boot",
87a5d1b5	31	"event",
4f6daaca	32	"fs",
c98cb512	33	"expo",
f941c8d7 SG	34	};
f941c8d7 SG	35
2a0cbf3b HS	36	_Static_assert(ARRAY_SIZE(log_cat_name) == LOGC_COUNT - LOGC_NONE,
	37	"log_cat_name size");
	38
43381401	39	static const char *const log_level_name[] = {
f941c8d7 SG	40	"EMERG",
	41	"ALERT",
	42	"CRIT",
	43	"ERR",
	44	"WARNING",
	45	"NOTICE",
	46	"INFO",
	47	"DEBUG",
	48	"CONTENT",
	49	"IO",
	50	};
	51
2a0cbf3b HS	52	_Static_assert(ARRAY_SIZE(log_level_name) == LOGL_COUNT, "log_level_name size");
	53
	54	/* All error responses MUST begin with '<' */
f941c8d7 SG	55	const char *log_get_cat_name(enum log_category_t cat)
f941c8d7 SG	56	{
c2e4e7e6 SG	57	const char *name;
	58
	59	if (cat < 0 \|\| cat >= LOGC_COUNT)
	60	return "<invalid>";
f941c8d7 SG	61	if (cat >= LOGC_NONE)
	62	return log_cat_name[cat - LOGC_NONE];
	63
6c9e4175	64	#if CONFIG_IS_ENABLED(DM)
c2e4e7e6	65	name = uclass_get_name((enum uclass_id)cat);
6c9e4175 HS	66	#else
	67	name = NULL;
	68	#endif
c2e4e7e6 SG	69
c2e4e7e6 SG	70	return name ? name : "<missing>";
f941c8d7 SG	71	}
	72
	73	enum log_category_t log_get_cat_by_name(const char *name)
	74	{
	75	enum uclass_id id;
	76	int i;
	77
	78	for (i = LOGC_NONE; i < LOGC_COUNT; i++)
	79	if (!strcmp(name, log_cat_name[i - LOGC_NONE]))
	80	return i;
	81	id = uclass_get_by_name(name);
	82	if (id != UCLASS_INVALID)
	83	return (enum log_category_t)id;
	84
	85	return LOGC_NONE;
	86	}
	87
	88	const char *log_get_level_name(enum log_level_t level)
	89	{
	90	if (level >= LOGL_COUNT)
	91	return "INVALID";
	92	return log_level_name[level];
	93	}
	94
	95	enum log_level_t log_get_level_by_name(const char *name)
	96	{
	97	int i;
	98
	99	for (i = 0; i < LOGL_COUNT; i++) {
	100	if (!strcasecmp(log_level_name[i], name))
	101	return i;
	102	}
	103
	104	return LOGL_NONE;
	105	}
	106
3102c1d2	107	struct log_device log_device_find_by_name(const char drv_name)
e9c8d49d SG	108	{
	109	struct log_device *ldev;
	110
	111	list_for_each_entry(ldev, &gd->log_head, sibling_node) {
	112	if (!strcmp(drv_name, ldev->drv->name))
	113	return ldev;
	114	}
	115
	116	return NULL;
	117	}
	118
3102c1d2	119	bool log_has_cat(enum log_category_t cat_list[], enum log_category_t cat)
e9c8d49d SG	120	{
	121	int i;
	122
	123	for (i = 0; i < LOGF_MAX_CATEGORIES && cat_list[i] != LOGC_END; i++) {
	124	if (cat_list[i] == cat)
	125	return true;
	126	}
	127
	128	return false;
	129	}
	130
3102c1d2	131	bool log_has_file(const char file_list, const char file)
e9c8d49d SG	132	{
	133	int file_len = strlen(file);
	134	const char s, p;
	135	int substr_len;
	136
	137	for (s = file_list; s; s = p + (p != '\0')) {
	138	p = strchrnul(s, ',');
	139	substr_len = p - s;
	140	if (file_len >= substr_len &&
	141	!strncmp(file + file_len - substr_len, s, substr_len))
	142	return true;
	143	}
	144
	145	return false;
	146	}
	147
	148	/**
	149	* log_passes_filters() - check if a log record passes the filters for a device
	150	*
	151	* @ldev: Log device to check
	152	* @rec: Log record to check
185f812c	153	* Return: true if @rec is not blocked by the filters in @ldev, false if it is
e9c8d49d SG	154	*/
	155	static bool log_passes_filters(struct log_device ldev, struct log_rec rec)
	156	{
	157	struct log_filter *filt;
	158
79d5983b	159	if (rec->flags & LOGRECF_FORCE_DEBUG)
52d3df7f SG	160	return true;
52d3df7f SG	161
e9c8d49d SG	162	/* If there are no filters, filter on the default log level */
	163	if (list_empty(&ldev->filter_head)) {
	164	if (rec->level > gd->default_log_level)
	165	return false;
	166	return true;
	167	}
	168
	169	list_for_each_entry(filt, &ldev->filter_head, sibling_node) {
40455a69 SA	170	if (filt->flags & LOGFF_LEVEL_MIN) {
	171	if (rec->level < filt->level)
	172	continue;
	173	} else if (rec->level > filt->level) {
e9c8d49d	174	continue;
40455a69 SA	175	}
40455a69 SA	176
e9c8d49d SG	177	if ((filt->flags & LOGFF_HAS_CAT) &&
	178	!log_has_cat(filt->cat_list, rec->cat))
	179	continue;
40455a69	180
e9c8d49d SG	181	if (filt->file_list &&
	182	!log_has_file(filt->file_list, rec->file))
	183	continue;
fe3b1a2d SA	184
	185	if (filt->flags & LOGFF_DENY)
	186	return false;
	187	else
	188	return true;
e9c8d49d SG	189	}
	190
	191	return false;
	192	}
	193
	194	/**
	195	* log_dispatch() - Send a log record to all log devices for processing
	196	*
	197	* The log record is sent to each log device in turn, skipping those which have
d094a073	198	* filters which block the record.
e9c8d49d	199	*
d094a073 HS	200	* All log messages created while processing log record @rec are ignored.
	201	*
	202	* @rec: log record to dispatch
	203	* Return: 0 msg sent, 1 msg not sent while already dispatching another msg
e9c8d49d	204	*/
c698b998	205	static int log_dispatch(struct log_rec rec, const char fmt, va_list args)
e9c8d49d SG	206	{
e9c8d49d SG	207	struct log_device *ldev;
c698b998	208	char buf[CONFIG_SYS_CBSIZE];
e5b35f70 HS	209
	210	/*
	211	* When a log driver writes messages (e.g. via the network stack) this
	212	* may result in further generated messages. We cannot process them here
	213	* as this might result in infinite recursion.
	214	*/
993a06b6	215	if (gd->processing_msg)
d094a073	216	return 1;
e5b35f70 HS	217
e5b35f70 HS	218	/* Emit message */
993a06b6	219	gd->processing_msg = true;
e9c8d49d	220	list_for_each_entry(ldev, &gd->log_head, sibling_node) {
b4520300	221	if ((ldev->flags & LOGDF_ENABLE) &&
c698b998 PD	222	log_passes_filters(ldev, rec)) {
c698b998 PD	223	if (!rec->msg) {
9ad7a6c2 SG	224	int len;
	225
	226	len = vsnprintf(buf, sizeof(buf), fmt, args);
c698b998	227	rec->msg = buf;
9ad7a6c2	228	gd->log_cont = len && buf[len - 1] != '\n';
c698b998	229	}
e9c8d49d	230	ldev->drv->emit(ldev, rec);
c698b998	231	}
e9c8d49d	232	}
993a06b6	233	gd->processing_msg = false;
e9c8d49d SG	234	return 0;
	235	}
	236
	237	int _log(enum log_category_t cat, enum log_level_t level, const char *file,
	238	int line, const char func, const char fmt, ...)
	239	{
e9c8d49d SG	240	struct log_rec rec;
	241	va_list args;
	242
f0e90e0e PD	243	if (!gd)
	244	return -ENOSYS;
	245
d094a073 HS	246	/* Check for message continuation */
	247	if (cat == LOGC_CONT)
	248	cat = gd->logc_prev;
	249	if (level == LOGL_CONT)
	250	level = gd->logl_prev;
	251
e9c8d49d	252	rec.cat = cat;
52d3df7f	253	rec.level = level & LOGL_LEVEL_MASK;
79d5983b SG	254	rec.flags = 0;
	255	if (level & LOGL_FORCE_DEBUG)
	256	rec.flags \|= LOGRECF_FORCE_DEBUG;
9ad7a6c2 SG	257	if (gd->log_cont)
9ad7a6c2 SG	258	rec.flags \|= LOGRECF_CONT;
e9c8d49d SG	259	rec.file = file;
	260	rec.line = line;
	261	rec.func = func;
c698b998	262	rec.msg = NULL;
f0e90e0e PD	263
	264	if (!(gd->flags & GD_FLG_LOG_READY)) {
	265	gd->log_drop_count++;
dd500134 PD	266
dd500134 PD	267	/* display dropped traces with console puts and DEBUG_UART */
79d5983b SG	268	if (rec.level <= CONFIG_LOG_DEFAULT_LEVEL \|\|
79d5983b SG	269	rec.flags & LOGRECF_FORCE_DEBUG) {
c698b998 PD	270	char buf[CONFIG_SYS_CBSIZE];
c698b998 PD	271
dd500134 PD	272	va_start(args, fmt);
	273	vsnprintf(buf, sizeof(buf), fmt, args);
	274	puts(buf);
	275	va_end(args);
	276	}
	277
f0e90e0e PD	278	return -ENOSYS;
f0e90e0e PD	279	}
e9c8d49d	280	va_start(args, fmt);
c698b998	281	if (!log_dispatch(&rec, fmt, args)) {
d094a073 HS	282	gd->logc_prev = cat;
	283	gd->logl_prev = level;
	284	}
c698b998	285	va_end(args);
e9c8d49d SG	286
	287	return 0;
	288	}
	289
58b4b713 SG	290	#define MAX_LINE_LENGTH_BYTES 64
	291	#define DEFAULT_LINE_LENGTH_BYTES 16
	292
	293	int _log_buffer(enum log_category_t cat, enum log_level_t level,
	294	const char file, int line, const char func, ulong addr,
	295	const void *data, uint width, uint count, uint linelen)
	296	{
	297	if (linelen * width > MAX_LINE_LENGTH_BYTES)
	298	linelen = MAX_LINE_LENGTH_BYTES / width;
	299	if (linelen < 1)
	300	linelen = DEFAULT_LINE_LENGTH_BYTES / width;
	301
	302	while (count) {
	303	uint thislinelen;
	304	char buf[HEXDUMP_MAX_BUF_LENGTH(width * linelen)];
	305
	306	thislinelen = hexdump_line(addr, data, width, count, linelen,
	307	buf, sizeof(buf));
	308	assert(thislinelen >= 0);
	309	_log(cat, level, file, line, func, "%s\n", buf);
	310
	311	/* update references */
	312	data += thislinelen * width;
	313	addr += thislinelen * width;
	314	count -= thislinelen;
	315	}
	316
	317	return 0;
	318	}
	319
a02f84ee	320	int log_add_filter_flags(const char *drv_name, enum log_category_t cat_list[],
40455a69	321	enum log_level_t level, const char *file_list,
a02f84ee	322	int flags)
e9c8d49d SG	323	{
	324	struct log_filter *filt;
	325	struct log_device *ldev;
45fac9fc	326	int ret;
e9c8d49d SG	327	int i;
	328
	329	ldev = log_device_find_by_name(drv_name);
	330	if (!ldev)
	331	return -ENOENT;
c1f39edc	332	filt = calloc(1, sizeof(*filt));
e9c8d49d SG	333	if (!filt)
	334	return -ENOMEM;
	335
a02f84ee	336	filt->flags = flags;
e9c8d49d SG	337	if (cat_list) {
	338	filt->flags \|= LOGFF_HAS_CAT;
	339	for (i = 0; ; i++) {
45fac9fc SG	340	if (i == ARRAY_SIZE(filt->cat_list)) {
	341	ret = -ENOSPC;
	342	goto err;
	343	}
e9c8d49d SG	344	filt->cat_list[i] = cat_list[i];
	345	if (cat_list[i] == LOGC_END)
	346	break;
	347	}
	348	}
40455a69	349	filt->level = level;
e9c8d49d SG	350	if (file_list) {
e9c8d49d SG	351	filt->file_list = strdup(file_list);
45fac9fc	352	if (!filt->file_list) {
69529f98	353	ret = -ENOMEM;
45fac9fc SG	354	goto err;
45fac9fc SG	355	}
e9c8d49d SG	356	}
e9c8d49d SG	357	filt->filter_num = ldev->next_filter_num++;
fe3b1a2d SA	358	/* Add deny filters to the beginning of the list */
	359	if (flags & LOGFF_DENY)
	360	list_add(&filt->sibling_node, &ldev->filter_head);
	361	else
	362	list_add_tail(&filt->sibling_node, &ldev->filter_head);
e9c8d49d SG	363
	364	return filt->filter_num;
	365
45fac9fc	366	err:
e9c8d49d	367	free(filt);
45fac9fc	368	return ret;
e9c8d49d SG	369	}
	370
	371	int log_remove_filter(const char *drv_name, int filter_num)
	372	{
	373	struct log_filter *filt;
	374	struct log_device *ldev;
	375
	376	ldev = log_device_find_by_name(drv_name);
	377	if (!ldev)
	378	return -ENOENT;
	379
	380	list_for_each_entry(filt, &ldev->filter_head, sibling_node) {
	381	if (filt->filter_num == filter_num) {
	382	list_del(&filt->sibling_node);
	383	free(filt);
	384
	385	return 0;
	386	}
	387	}
	388
	389	return -ENOENT;
	390	}
	391
3d03ab63 SG	392	/**
	393	* log_find_device_by_drv() - Find a device by its driver
	394	*
	395	* @drv: Log driver
185f812c	396	* Return: Device associated with that driver, or NULL if not found
3d03ab63 SG	397	*/
	398	static struct log_device log_find_device_by_drv(struct log_driver drv)
	399	{
	400	struct log_device *ldev;
	401
	402	list_for_each_entry(ldev, &gd->log_head, sibling_node) {
	403	if (ldev->drv == drv)
	404	return ldev;
	405	}
	406	/*
	407	* It is quite hard to pass an invalid driver since passing an unknown
	408	* LOG_GET_DRIVER(xxx) would normally produce a compilation error. But
	409	* it is possible to pass NULL, for example, so this
	410	*/
	411
	412	return NULL;
	413	}
	414
	415	int log_device_set_enable(struct log_driver *drv, bool enable)
	416	{
	417	struct log_device *ldev;
	418
	419	ldev = log_find_device_by_drv(drv);
	420	if (!ldev)
	421	return -ENOENT;
	422	if (enable)
	423	ldev->flags \|= LOGDF_ENABLE;
	424	else
	425	ldev->flags &= ~LOGDF_ENABLE;
	426
	427	return 0;
	428	}
	429
39162d93 TW	430	void log_fixup_for_gd_move(struct global_data *new_gd)
	431	{
	432	new_gd->log_head.prev->next = &new_gd->log_head;
	433	}
	434
e9c8d49d SG	435	int log_init(void)
	436	{
	437	struct log_driver *drv = ll_entry_start(struct log_driver, log_driver);
	438	const int count = ll_entry_count(struct log_driver, log_driver);
	439	struct log_driver *end = drv + count;
	440
	441	/*
	442	* We cannot add runtime data to the driver since it is likely stored
	443	* in rodata. Instead, set up a 'device' corresponding to each driver.
f98caa6a	444	* We only support having a single device for each driver.
e9c8d49d SG	445	*/
	446	INIT_LIST_HEAD((struct list_head *)&gd->log_head);
	447	while (drv < end) {
	448	struct log_device *ldev;
	449
	450	ldev = calloc(1, sizeof(*ldev));
	451	if (!ldev) {
	452	debug("%s: Cannot allocate memory\n", __func__);
	453	return -ENOMEM;
	454	}
	455	INIT_LIST_HEAD(&ldev->filter_head);
	456	ldev->drv = drv;
b4520300	457	ldev->flags = drv->flags;
e9c8d49d SG	458	list_add_tail(&ldev->sibling_node,
	459	(struct list_head *)&gd->log_head);
	460	drv++;
	461	}
af1bc0cf	462	gd->flags \|= GD_FLG_LOG_READY;
2b1dc29a	463	if (!gd->default_log_level)
f0b05c95	464	gd->default_log_level = CONFIG_LOG_DEFAULT_LEVEL;
3c21d773	465	gd->log_fmt = log_get_default_format();
d094a073 HS	466	gd->logc_prev = LOGC_NONE;
d094a073 HS	467	gd->logl_prev = LOGL_INFO;
e9c8d49d SG	468
	469	return 0;
	470	}