kernel/trace/trace_kdb.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * kdb helper for dumping the ftrace buffer
0004  *
0005  * Copyright (C) 2010 Jason Wessel <jason.wessel@windriver.com>
0006  *
0007  * ftrace_dump_buf based on ftrace_dump:
0008  * Copyright (C) 2007-2008 Steven Rostedt <srostedt@redhat.com>
0009  * Copyright (C) 2008 Ingo Molnar <mingo@redhat.com>
0010  *
0011  */
0012 #include <linux/init.h>
0013 #include <linux/kgdb.h>
0014 #include <linux/kdb.h>
0015 #include <linux/ftrace.h>
0016
0017 #include "trace.h"
0018 #include "trace_output.h"
0019
0020 static struct trace_iterator iter;
0021 static struct ring_buffer_iter *buffer_iter[CONFIG_NR_CPUS];
0022
0023 static void ftrace_dump_buf(int skip_entries, long cpu_file)
0024 {
0025     struct trace_array *tr;
0026     unsigned int old_userobj;
0027     int cnt = 0, cpu;
0028
0029     tr = iter.tr;
0030
0031     old_userobj = tr->trace_flags;
0032
0033     /* don't look at user memory in panic mode */
0034     tr->trace_flags &= ~TRACE_ITER_SYM_USEROBJ;
0035
0036     kdb_printf("Dumping ftrace buffer:\n");
0037     if (skip_entries)
0038         kdb_printf("(skipping %d entries)\n", skip_entries);
0039
0040     trace_iterator_reset(&iter);
0041     iter.iter_flags |= TRACE_FILE_LAT_FMT;
0042
0043     if (cpu_file == RING_BUFFER_ALL_CPUS) {
0044         for_each_tracing_cpu(cpu) {
0045             iter.buffer_iter[cpu] =
0046             ring_buffer_read_prepare(iter.array_buffer->buffer,
0047                          cpu, GFP_ATOMIC);
0048             ring_buffer_read_start(iter.buffer_iter[cpu]);
0049             tracing_iter_reset(&iter, cpu);
0050         }
0051     } else {
0052         iter.cpu_file = cpu_file;
0053         iter.buffer_iter[cpu_file] =
0054             ring_buffer_read_prepare(iter.array_buffer->buffer,
0055                          cpu_file, GFP_ATOMIC);
0056         ring_buffer_read_start(iter.buffer_iter[cpu_file]);
0057         tracing_iter_reset(&iter, cpu_file);
0058     }
0059
0060     while (trace_find_next_entry_inc(&iter)) {
0061         if (!cnt)
0062             kdb_printf("---------------------------------\n");
0063         cnt++;
0064
0065         if (!skip_entries) {
0066             print_trace_line(&iter);
0067             trace_printk_seq(&iter.seq);
0068         } else {
0069             skip_entries--;
0070         }
0071
0072         if (KDB_FLAG(CMD_INTERRUPT))
0073             goto out;
0074     }
0075
0076     if (!cnt)
0077         kdb_printf("   (ftrace buffer empty)\n");
0078     else
0079         kdb_printf("---------------------------------\n");
0080
0081 out:
0082     tr->trace_flags = old_userobj;
0083
0084     for_each_tracing_cpu(cpu) {
0085         if (iter.buffer_iter[cpu]) {
0086             ring_buffer_read_finish(iter.buffer_iter[cpu]);
0087             iter.buffer_iter[cpu] = NULL;
0088         }
0089     }
0090 }
0091
0092 /*
0093  * kdb_ftdump - Dump the ftrace log buffer
0094  */
0095 static int kdb_ftdump(int argc, const char **argv)
0096 {
0097     int skip_entries = 0;
0098     long cpu_file;
0099     char *cp;
0100     int cnt;
0101     int cpu;
0102
0103     if (argc > 2)
0104         return KDB_ARGCOUNT;
0105
0106     if (argc) {
0107         skip_entries = simple_strtol(argv[1], &cp, 0);
0108         if (*cp)
0109             skip_entries = 0;
0110     }
0111
0112     if (argc == 2) {
0113         cpu_file = simple_strtol(argv[2], &cp, 0);
0114         if (*cp || cpu_file >= NR_CPUS || cpu_file < 0 ||
0115             !cpu_online(cpu_file))
0116             return KDB_BADINT;
0117     } else {
0118         cpu_file = RING_BUFFER_ALL_CPUS;
0119     }
0120
0121     kdb_trap_printk++;
0122
0123     trace_init_global_iter(&iter);
0124     iter.buffer_iter = buffer_iter;
0125
0126     for_each_tracing_cpu(cpu) {
0127         atomic_inc(&per_cpu_ptr(iter.array_buffer->data, cpu)->disabled);
0128     }
0129
0130     /* A negative skip_entries means skip all but the last entries */
0131     if (skip_entries < 0) {
0132         if (cpu_file == RING_BUFFER_ALL_CPUS)
0133             cnt = trace_total_entries(NULL);
0134         else
0135             cnt = trace_total_entries_cpu(NULL, cpu_file);
0136         skip_entries = max(cnt + skip_entries, 0);
0137     }
0138
0139     ftrace_dump_buf(skip_entries, cpu_file);
0140
0141     for_each_tracing_cpu(cpu) {
0142         atomic_dec(&per_cpu_ptr(iter.array_buffer->data, cpu)->disabled);
0143     }
0144
0145     kdb_trap_printk--;
0146
0147     return 0;
0148 }
0149
0150 static kdbtab_t ftdump_cmd = {
0151     .name = "ftdump",
0152     .func = kdb_ftdump,
0153     .usage = "[skip_#entries] [cpu]",
0154     .help = "Dump ftrace log; -skip dumps last #entries",
0155     .flags = KDB_ENABLE_ALWAYS_SAFE,
0156 };
0157
0158 static __init int kdb_ftrace_register(void)
0159 {
0160     kdb_register(&ftdump_cmd);
0161     return 0;
0162 }
0163
0164 late_initcall(kdb_ftrace_register);