"Das U-Boot" Source Tree
log: enable filtering on functions
Up to now we could only use log level, category, and file for filtering.
Allow filtering on a list of functions.
Signed-off-by: Heinrich Schuchardt <heinrich.schuchardt@canonical.com>
+44
-29
+22
-20
cmd/log.c
+22
-20
cmd/log.c
···
115
115
return CMD_RET_FAILURE;
116
116
}
117
117
118
-
/* <3> < 6 > <2+1 + 7 > < 16 > < unbounded... */
119
-
printf("num policy level categories files\n");
120
118
list_for_each_entry(filt, &ldev->filter_head, sibling_node) {
121
-
printf("%3d %6.6s %s %-7.7s ", filt->filter_num,
122
-
filt->flags & LOGFF_DENY ? "deny" : "allow",
119
+
printf("%-3d: %s %s %s\n", filt->filter_num,
120
+
filt->flags & LOGFF_DENY ? "DENY" : "ALLOW",
123
121
filt->flags & LOGFF_LEVEL_MIN ? ">=" : "<=",
124
122
log_get_level_name(filt->level));
125
123
126
124
if (filt->flags & LOGFF_HAS_CAT) {
127
-
int i;
128
-
129
-
if (filt->cat_list[0] != LOGC_END)
130
-
printf("%16.16s %s\n",
131
-
log_get_cat_name(filt->cat_list[0]),
132
-
filt->file_list ? filt->file_list : "");
133
-
134
-
for (i = 1; i < LOGF_MAX_CATEGORIES &&
135
-
filt->cat_list[i] != LOGC_END; i++)
136
-
printf("%21c %16.16s\n", ' ',
125
+
printf(" Categories:");
126
+
for (int i = 0;
127
+
i < LOGF_MAX_CATEGORIES &&
128
+
filt->cat_list[i] != LOGC_END;
129
+
++i) {
130
+
printf(" %s",
137
131
log_get_cat_name(filt->cat_list[i]));
138
-
} else {
139
-
printf("%16c %s\n", ' ',
140
-
filt->file_list ? filt->file_list : "");
132
+
}
133
+
printf("\n");
141
134
}
135
+
if (filt->file_list)
136
+
printf(" Files: %s\n", filt->file_list);
137
+
if (filt->func_list)
138
+
printf(" Functions: %s\n", filt->func_list);
142
139
}
143
140
144
141
return CMD_RET_SUCCESS;
···
151
148
bool print_num = false;
152
149
bool type_set = false;
153
150
char *file_list = NULL;
151
+
char *func_list = NULL;
154
152
const char *drv_name = "console";
155
153
int opt, err;
156
154
int cat_count = 0;
···
160
158
struct getopt_state gs;
161
159
162
160
getopt_init_state(&gs);
163
-
while ((opt = getopt(&gs, argc, argv, "Ac:d:Df:l:L:p")) > 0) {
161
+
while ((opt = getopt(&gs, argc, argv, "Ac:d:Df:F:l:L:p")) > 0) {
164
162
switch (opt) {
165
163
case 'A':
166
164
#define do_type() do { \
···
199
197
case 'f':
200
198
file_list = gs.arg;
201
199
break;
200
+
case 'F':
201
+
func_list = gs.arg;
202
+
break;
202
203
case 'l':
203
204
#define do_level() do { \
204
205
if (level_set) { \
···
229
230
230
231
cat_list[cat_count] = LOGC_END;
231
232
err = log_add_filter_flags(drv_name, cat_count ? cat_list : NULL, level,
232
-
file_list, flags);
233
+
file_list, func_list, flags);
233
234
if (err < 0) {
234
235
printf("Could not add filter (err = %d)\n", err);
235
236
return CMD_RET_FAILURE;
···
388
389
"\t-d <driver> - Specify the log driver to add the filter to; defaults\n"
389
390
"\t to console\n"
390
391
"\t-D - Deny messages matching this filter; mutually exclusive with -A\n"
391
-
"\t-f <files_list> - A comma-separated list of files to match\n"
392
+
"\t-f <file_list> - A comma-separated list of files to match\n"
393
+
"\t-F <func_list> - A comma-separated list of functions to match\n"
392
394
"\t-l <level> - Match log levels less than or equal to <level>;\n"
393
395
"\t mutually-exclusive with -L\n"
394
396
"\t-L <level> - Match log levels greather than or equal to <level>;\n"
+12
-1
common/log.c
+12
-1
common/log.c
···
192
192
!log_has_member(filt->file_list, rec->file))
193
193
continue;
194
194
195
+
if (filt->func_list &&
196
+
!log_has_member(filt->func_list, rec->func))
197
+
continue;
198
+
195
199
if (filt->flags & LOGFF_DENY)
196
200
return false;
197
201
else
···
329
333
330
334
int log_add_filter_flags(const char *drv_name, enum log_category_t cat_list[],
331
335
enum log_level_t level, const char *file_list,
332
-
int flags)
336
+
const char *func_list, int flags)
333
337
{
334
338
struct log_filter *filt;
335
339
struct log_device *ldev;
···
360
364
if (file_list) {
361
365
filt->file_list = strdup(file_list);
362
366
if (!filt->file_list) {
367
+
ret = -ENOMEM;
368
+
goto err;
369
+
}
370
+
}
371
+
if (func_list) {
372
+
filt->func_list = strdup(func_list);
373
+
if (!filt->func_list) {
363
374
ret = -ENOMEM;
364
375
goto err;
365
376
}
+5
-2
include/log.h
+5
-2
include/log.h
···
500
500
* @level: Maximum (or minimum, if %LOGFF_MIN_LEVEL) log level to allow
501
501
* @file_list: List of files to allow, separated by comma. If NULL then all
502
502
* files are permitted
503
+
* @func_list: Comma separated list of functions or NULL.
503
504
* @sibling_node: Next filter in the list of filters for this log device
504
505
*/
505
506
struct log_filter {
···
508
509
enum log_category_t cat_list[LOGF_MAX_CATEGORIES];
509
510
enum log_level_t level;
510
511
const char *file_list;
512
+
const char *func_list;
511
513
struct list_head sibling_node;
512
514
};
513
515
···
599
601
* @level: Maximum (or minimum, if %LOGFF_LEVEL_MIN) log level to allow
600
602
* @file_list: List of files to allow, separated by comma. If NULL then all
601
603
* files are permitted
604
+
* @func_list: Comma separated list of functions or NULL.
602
605
* Return:
603
606
* the sequence number of the new filter (>=0) if the filter was added, or a
604
607
* -ve value on error
605
608
*/
606
609
int log_add_filter_flags(const char *drv_name, enum log_category_t cat_list[],
607
610
enum log_level_t level, const char *file_list,
608
-
int flags);
611
+
const char *func_list, int flags);
609
612
610
613
/**
611
614
* log_add_filter() - Add a new filter to a log device
···
628
631
const char *file_list)
629
632
{
630
633
return log_add_filter_flags(drv_name, cat_list, max_level, file_list,
631
-
0);
634
+
NULL, 0);
632
635
}
633
636
634
637
/**
-1
test/log/log_filter.c
-1
test/log/log_filter.c
+5
-5
test/log/log_test.c
+5
-5
test/log/log_test.c
···
320
320
filt1 = log_add_filter("console", cat_list, LOGL_MAX, NULL);
321
321
ut_assert(filt1 >= 0);
322
322
filt2 = log_add_filter_flags("console", cat_list, LOGL_MAX, NULL,
323
-
LOGFF_DENY);
323
+
NULL, LOGFF_DENY);
324
324
ut_assert(filt2 >= 0);
325
325
326
326
log_run_cat(UCLASS_SPI);
···
340
340
filt1 = log_add_filter("console", NULL, LOGL_MAX, "file");
341
341
ut_assert(filt1 >= 0);
342
342
filt2 = log_add_filter_flags("console", NULL, LOGL_MAX, "file",
343
-
LOGFF_DENY);
343
+
NULL, LOGFF_DENY);
344
344
ut_assert(filt2 >= 0);
345
345
346
346
log_run_file("file");
···
360
360
filt1 = log_add_filter("console", NULL, LOGL_INFO, NULL);
361
361
ut_assert(filt1 >= 0);
362
362
filt2 = log_add_filter_flags("console", NULL, LOGL_WARNING, NULL,
363
-
LOGFF_DENY);
363
+
NULL, LOGFF_DENY);
364
364
ut_assert(filt2 >= 0);
365
365
366
366
log_run();
···
380
380
int filt1, filt2;
381
381
382
382
filt1 = log_add_filter_flags("console", NULL, LOGL_WARNING, NULL,
383
-
LOGFF_LEVEL_MIN);
383
+
NULL, LOGFF_LEVEL_MIN);
384
384
ut_assert(filt1 >= 0);
385
385
filt2 = log_add_filter_flags("console", NULL, LOGL_INFO, NULL,
386
-
LOGFF_DENY | LOGFF_LEVEL_MIN);
386
+
NULL, LOGFF_DENY | LOGFF_LEVEL_MIN);
387
387
ut_assert(filt2 >= 0);
388
388
389
389
log_run();