1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Copyright (c) 2017 Google, Inc
4 * Written by Simon Glass <sjg@chromium.org>
5 */
6
7#include <common.h>
8#include <command.h>
9#include <dm.h>
10#include <getopt.h>
11#include <log.h>
12#include <malloc.h>
13#include <asm/global_data.h>
14
15static char log_fmt_chars[LOGF_COUNT] = "clFLfm";
16
17static enum log_level_t parse_log_level(char *const arg)
18{
19	enum log_level_t ret;
20	ulong level;
21
22	if (!strict_strtoul(arg, 10, &level)) {
23		if (level > _LOG_MAX_LEVEL) {
24			printf("Only log levels <= %d are supported\n",
25			       _LOG_MAX_LEVEL);
26			return LOGL_NONE;
27		}
28		return level;
29	}
30
31	ret = log_get_level_by_name(arg);
32	if (ret == LOGL_NONE)
33		printf("Unknown log level \"%s\"\n", arg);
34	return ret;
35}
36
37static int do_log_level(struct cmd_tbl *cmdtp, int flag, int argc,
38			char *const argv[])
39{
40	enum log_level_t log_level;
41
42	if (argc > 1) {
43		log_level = parse_log_level(argv[1]);
44
45		if (log_level == LOGL_NONE)
46			return CMD_RET_FAILURE;
47		gd->default_log_level = log_level;
48	} else {
49		for (log_level = LOGL_FIRST; log_level <= _LOG_MAX_LEVEL;
50		     log_level++)
51			printf("%s%s\n", log_get_level_name(log_level),
52			       log_level == gd->default_log_level ?
53			       " (default)" : "");
54	}
55
56	return CMD_RET_SUCCESS;
57}
58
59static int do_log_categories(struct cmd_tbl *cmdtp, int flag, int argc,
60			     char *const argv[])
61{
62	enum log_category_t cat;
63	const char *name;
64
65	for (cat = LOGC_FIRST; cat < LOGC_COUNT; cat++) {
66		name = log_get_cat_name(cat);
67		/*
68		 * Invalid category names (e.g. <invalid> or <missing>) begin
69		 * with '<'.
70		 */
71		if (name[0] == '<')
72			continue;
73		printf("%s\n", name);
74	}
75
76	return CMD_RET_SUCCESS;
77}
78
79static int do_log_drivers(struct cmd_tbl *cmdtp, int flag, int argc,
80			  char *const argv[])
81{
82	struct log_device *ldev;
83
84	list_for_each_entry(ldev, &gd->log_head, sibling_node)
85		printf("%s\n", ldev->drv->name);
86
87	return CMD_RET_SUCCESS;
88}
89
90static int do_log_filter_list(struct cmd_tbl *cmdtp, int flag, int argc,
91			      char *const argv[])
92{
93	int opt;
94	const char *drv_name = "console";
95	struct getopt_state gs;
96	struct log_filter *filt;
97	struct log_device *ldev;
98
99	getopt_init_state(&gs);
100	while ((opt = getopt(&gs, argc, argv, "d:")) > 0) {
101		switch (opt) {
102		case 'd':
103			drv_name = gs.arg;
104			break;
105		default:
106			return CMD_RET_USAGE;
107		}
108	}
109
110	if (gs.index != argc)
111		return CMD_RET_USAGE;
112
113	ldev = log_device_find_by_name(drv_name);
114	if (!ldev) {
115		printf("Could not find log device for \"%s\"\n", drv_name);
116		return CMD_RET_FAILURE;
117	}
118
119	/*      <3> < 6  > <2+1 + 7 > <      16      > < unbounded... */
120	printf("num policy level            categories files\n");
121	list_for_each_entry(filt, &ldev->filter_head, sibling_node) {
122		printf("%3d %6.6s %s %-7.7s ", filt->filter_num,
123		       filt->flags & LOGFF_DENY ? "deny" : "allow",
124		       filt->flags & LOGFF_LEVEL_MIN ? ">=" : "<=",
125		       log_get_level_name(filt->level));
126
127		if (filt->flags & LOGFF_HAS_CAT) {
128			int i;
129
130			if (filt->cat_list[0] != LOGC_END)
131				printf("%16.16s %s\n",
132				       log_get_cat_name(filt->cat_list[0]),
133				       filt->file_list ? filt->file_list : "");
134
135			for (i = 1; i < LOGF_MAX_CATEGORIES &&
136				    filt->cat_list[i] != LOGC_END; i++)
137				printf("%21c %16.16s\n", ' ',
138				       log_get_cat_name(filt->cat_list[i]));
139		} else {
140			printf("%16c %s\n", ' ',
141			       filt->file_list ? filt->file_list : "");
142		}
143	}
144
145	return CMD_RET_SUCCESS;
146}
147
148static int do_log_filter_add(struct cmd_tbl *cmdtp, int flag, int argc,
149			     char *const argv[])
150{
151	bool level_set = false;
152	bool print_num = false;
153	bool type_set = false;
154	char *file_list = NULL;
155	const char *drv_name = "console";
156	int opt, err;
157	int cat_count = 0;
158	int flags = 0;
159	enum log_category_t cat_list[LOGF_MAX_CATEGORIES + 1];
160	enum log_level_t level = LOGL_MAX;
161	struct getopt_state gs;
162
163	getopt_init_state(&gs);
164	while ((opt = getopt(&gs, argc, argv, "Ac:d:Df:l:L:p")) > 0) {
165		switch (opt) {
166		case 'A':
167#define do_type() do { \
168			if (type_set) { \
169				printf("Allow or deny set twice\n"); \
170				return CMD_RET_USAGE; \
171			} \
172			type_set = true; \
173} while (0)
174			do_type();
175			break;
176		case 'c': {
177			enum log_category_t cat;
178
179			if (cat_count >= LOGF_MAX_CATEGORIES) {
180				printf("Too many categories\n");
181				return CMD_RET_FAILURE;
182			}
183
184			cat = log_get_cat_by_name(gs.arg);
185			if (cat == LOGC_NONE) {
186				printf("Unknown category \"%s\"\n", gs.arg);
187				return CMD_RET_FAILURE;
188			}
189
190			cat_list[cat_count++] = cat;
191			break;
192		}
193		case 'd':
194			drv_name = gs.arg;
195			break;
196		case 'D':
197			do_type();
198			flags |= LOGFF_DENY;
199			break;
200		case 'f':
201			file_list = gs.arg;
202			break;
203		case 'l':
204#define do_level() do { \
205			if (level_set) { \
206				printf("Log level set twice\n"); \
207				return CMD_RET_USAGE; \
208			} \
209			level = parse_log_level(gs.arg); \
210			if (level == LOGL_NONE) \
211				return CMD_RET_FAILURE; \
212			level_set = true; \
213} while (0)
214			do_level();
215			break;
216		case 'L':
217			do_level();
218			flags |= LOGFF_LEVEL_MIN;
219			break;
220		case 'p':
221			print_num = true;
222			break;
223		default:
224			return CMD_RET_USAGE;
225		}
226	}
227
228	if (gs.index != argc)
229		return CMD_RET_USAGE;
230
231	cat_list[cat_count] = LOGC_END;
232	err = log_add_filter_flags(drv_name, cat_count ? cat_list : NULL, level,
233				   file_list, flags);
234	if (err < 0) {
235		printf("Could not add filter (err = %d)\n", err);
236		return CMD_RET_FAILURE;
237	} else if (print_num) {
238		printf("%d\n", err);
239	}
240
241	return CMD_RET_SUCCESS;
242}
243
244static int do_log_filter_remove(struct cmd_tbl *cmdtp, int flag, int argc,
245				char *const argv[])
246{
247	bool all = false;
248	int opt, err;
249	ulong filter_num;
250	const char *drv_name = "console";
251	struct getopt_state gs;
252
253	getopt_init_state(&gs);
254	while ((opt = getopt(&gs, argc, argv, "ad:")) > 0) {
255		switch (opt) {
256		case 'a':
257			all = true;
258			break;
259		case 'd':
260			drv_name = gs.arg;
261			break;
262		default:
263			return CMD_RET_USAGE;
264		}
265	}
266
267	if (all) {
268		struct log_filter *filt, *tmp_filt;
269		struct log_device *ldev;
270
271		if (gs.index != argc)
272			return CMD_RET_USAGE;
273
274		ldev = log_device_find_by_name(drv_name);
275		if (!ldev) {
276			printf("Could not find log device for \"%s\"\n",
277			       drv_name);
278			return CMD_RET_FAILURE;
279		}
280
281		list_for_each_entry_safe(filt, tmp_filt, &ldev->filter_head,
282					 sibling_node) {
283			list_del(&filt->sibling_node);
284			free(filt);
285		}
286	} else {
287		if (gs.index + 1 != argc)
288			return CMD_RET_USAGE;
289
290		if (strict_strtoul(argv[gs.index], 10, &filter_num)) {
291			printf("Invalid filter number \"%s\"\n", argv[gs.index]);
292			return CMD_RET_FAILURE;
293		}
294
295		err = log_remove_filter(drv_name, filter_num);
296		if (err) {
297			printf("Could not remove filter (err = %d)\n", err);
298			return CMD_RET_FAILURE;
299		}
300	}
301
302	return CMD_RET_SUCCESS;
303}
304
305static int do_log_format(struct cmd_tbl *cmdtp, int flag, int argc,
306			 char *const argv[])
307{
308	int i;
309
310	if (argc > 1) {
311		const char *str = argv[1];
312
313		if (!strcmp(str, "default")) {
314			gd->log_fmt = log_get_default_format();
315		} else if (!strcmp(str, "all")) {
316			gd->log_fmt = LOGF_ALL;
317		} else {
318			gd->log_fmt = 0;
319			for (; *str; str++) {
320				char *ptr = strchr(log_fmt_chars, *str);
321
322				if (!ptr) {
323					printf("Invalid log char '%c'\n", *str);
324					return CMD_RET_FAILURE;
325				}
326				gd->log_fmt |= 1 << (ptr - log_fmt_chars);
327			}
328		}
329	} else {
330		printf("Log format: ");
331		for (i = 0; i < LOGF_COUNT; i++) {
332			if (gd->log_fmt & (1 << i))
333				printf("%c", log_fmt_chars[i]);
334		}
335		printf("\n");
336	}
337
338	return 0;
339}
340
341static int do_log_rec(struct cmd_tbl *cmdtp, int flag, int argc,
342		      char *const argv[])
343{
344	enum log_category_t cat;
345	enum log_level_t level;
346	const char *file;
347	uint line;
348	const char *func;
349	const char *msg;
350	char *end;
351
352	if (argc < 7)
353		return CMD_RET_USAGE;
354	cat = log_get_cat_by_name(argv[1]);
355	level = dectoul(argv[2], &end);
356	if (end == argv[2]) {
357		level = log_get_level_by_name(argv[2]);
358
359		if (level == LOGL_NONE) {
360			printf("Invalid log level '%s'\n", argv[2]);
361			return CMD_RET_USAGE;
362		}
363	}
364	if (level >= LOGL_MAX) {
365		printf("Invalid log level %u\n", level);
366		return CMD_RET_USAGE;
367	}
368	file = argv[3];
369	line = dectoul(argv[4], NULL);
370	func = argv[5];
371	msg = argv[6];
372	if (_log(cat, level, file, line, func, "%s\n", msg))
373		return CMD_RET_FAILURE;
374
375	return 0;
376}
377
378U_BOOT_LONGHELP(log,
379	"level [<level>] - get/set log level\n"
380	"categories - list log categories\n"
381	"drivers - list log drivers\n"
382	"log filter-list [OPTIONS] - list all filters for a log driver\n"
383	"\t-d <driver> - Specify the log driver to list filters from; defaults\n"
384	"\t              to console\n"
385	"log filter-add [OPTIONS] - add a new filter to a driver\n"
386	"\t-A - Allow messages matching this filter; mutually exclusive with -D\n"
387	"\t     This is the default.\n"
388	"\t-c <category> - Category to match; may be specified multiple times\n"
389	"\t-d <driver> - Specify the log driver to add the filter to; defaults\n"
390	"\t              to console\n"
391	"\t-D - Deny messages matching this filter; mutually exclusive with -A\n"
392	"\t-f <files_list> - A comma-separated list of files to match\n"
393	"\t-l <level> - Match log levels less than or equal to <level>;\n"
394	"\t             mutually-exclusive with -L\n"
395	"\t-L <level> - Match log levels greather than or equal to <level>;\n"
396	"\t             mutually-exclusive with -l\n"
397	"\t-p - Print the filter number on success\n"
398	"log filter-remove [OPTIONS] [<num>] - Remove filter number <num>\n"
399	"\t-a - Remove ALL filters\n"
400	"\t-d <driver> - Specify the log driver to remove the filter from;\n"
401	"\t              defaults to console\n"
402	"log format <fmt> - set log output format. <fmt> is a string where\n"
403	"\teach letter indicates something that should be displayed:\n"
404	"\tc=category, l=level, F=file, L=line number, f=function, m=msg\n"
405	"\tor 'default', or 'all' for all\n"
406	"log rec <category> <level> <file> <line> <func> <message> - "
407		"output a log record");
408
409U_BOOT_CMD_WITH_SUBCMDS(log, "log system", log_help_text,
410	U_BOOT_SUBCMD_MKENT(level, 2, 1, do_log_level),
411	U_BOOT_SUBCMD_MKENT(categories, 1, 1, do_log_categories),
412	U_BOOT_SUBCMD_MKENT(drivers, 1, 1, do_log_drivers),
413	U_BOOT_SUBCMD_MKENT(filter-list, 3, 1, do_log_filter_list),
414	U_BOOT_SUBCMD_MKENT(filter-add, CONFIG_SYS_MAXARGS, 1,
415			    do_log_filter_add),
416	U_BOOT_SUBCMD_MKENT(filter-remove, 4, 1, do_log_filter_remove),
417	U_BOOT_SUBCMD_MKENT(format, 2, 1, do_log_format),
418	U_BOOT_SUBCMD_MKENT(rec, 7, 1, do_log_rec),
419);
420