Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  * kdb helper for dumping the ftrace buffer
       4                 :            :  *
       5                 :            :  * Copyright (C) 2010 Jason Wessel <jason.wessel@windriver.com>
       6                 :            :  *
       7                 :            :  * ftrace_dump_buf based on ftrace_dump:
       8                 :            :  * Copyright (C) 2007-2008 Steven Rostedt <srostedt@redhat.com>
       9                 :            :  * Copyright (C) 2008 Ingo Molnar <mingo@redhat.com>
      10                 :            :  *
      11                 :            :  */
      12                 :            : #include <linux/init.h>
      13                 :            : #include <linux/kgdb.h>
      14                 :            : #include <linux/kdb.h>
      15                 :            : #include <linux/ftrace.h>
      16                 :            : 
      17                 :            : #include "trace.h"
      18                 :            : #include "trace_output.h"
      19                 :            : 
      20                 :            : static struct trace_iterator iter;
      21                 :            : static struct ring_buffer_iter *buffer_iter[CONFIG_NR_CPUS];
      22                 :            : 
      23                 :          0 : static void ftrace_dump_buf(int skip_entries, long cpu_file)
      24                 :            : {
      25                 :            :         struct trace_array *tr;
      26                 :            :         unsigned int old_userobj;
      27                 :            :         int cnt = 0, cpu;
      28                 :            : 
      29                 :          0 :         tr = iter.tr;
      30                 :            : 
      31                 :          0 :         old_userobj = tr->trace_flags;
      32                 :            : 
      33                 :            :         /* don't look at user memory in panic mode */
      34                 :          0 :         tr->trace_flags &= ~TRACE_ITER_SYM_USEROBJ;
      35                 :            : 
      36                 :          0 :         kdb_printf("Dumping ftrace buffer:\n");
      37                 :          0 :         if (skip_entries)
      38                 :          0 :                 kdb_printf("(skipping %d entries)\n", skip_entries);
      39                 :            : 
      40                 :            :         trace_iterator_reset(&iter);
      41                 :          0 :         iter.iter_flags |= TRACE_FILE_LAT_FMT;
      42                 :            : 
      43                 :          0 :         if (cpu_file == RING_BUFFER_ALL_CPUS) {
      44                 :          0 :                 for_each_tracing_cpu(cpu) {
      45                 :          0 :                         iter.buffer_iter[cpu] =
      46                 :          0 :                         ring_buffer_read_prepare(iter.trace_buffer->buffer,
      47                 :            :                                                  cpu, GFP_ATOMIC);
      48                 :          0 :                         ring_buffer_read_start(iter.buffer_iter[cpu]);
      49                 :          0 :                         tracing_iter_reset(&iter, cpu);
      50                 :            :                 }
      51                 :            :         } else {
      52                 :          0 :                 iter.cpu_file = cpu_file;
      53                 :          0 :                 iter.buffer_iter[cpu_file] =
      54                 :          0 :                         ring_buffer_read_prepare(iter.trace_buffer->buffer,
      55                 :            :                                                  cpu_file, GFP_ATOMIC);
      56                 :          0 :                 ring_buffer_read_start(iter.buffer_iter[cpu_file]);
      57                 :          0 :                 tracing_iter_reset(&iter, cpu_file);
      58                 :            :         }
      59                 :            : 
      60                 :          0 :         while (trace_find_next_entry_inc(&iter)) {
      61                 :          0 :                 if (!cnt)
      62                 :          0 :                         kdb_printf("---------------------------------\n");
      63                 :          0 :                 cnt++;
      64                 :            : 
      65                 :          0 :                 if (!skip_entries) {
      66                 :          0 :                         print_trace_line(&iter);
      67                 :          0 :                         trace_printk_seq(&iter.seq);
      68                 :            :                 } else {
      69                 :          0 :                         skip_entries--;
      70                 :            :                 }
      71                 :            : 
      72                 :          0 :                 if (KDB_FLAG(CMD_INTERRUPT))
      73                 :            :                         goto out;
      74                 :            :         }
      75                 :            : 
      76                 :          0 :         if (!cnt)
      77                 :          0 :                 kdb_printf("   (ftrace buffer empty)\n");
      78                 :            :         else
      79                 :          0 :                 kdb_printf("---------------------------------\n");
      80                 :            : 
      81                 :            : out:
      82                 :          0 :         tr->trace_flags = old_userobj;
      83                 :            : 
      84                 :          0 :         for_each_tracing_cpu(cpu) {
      85                 :          0 :                 if (iter.buffer_iter[cpu]) {
      86                 :          0 :                         ring_buffer_read_finish(iter.buffer_iter[cpu]);
      87                 :          0 :                         iter.buffer_iter[cpu] = NULL;
      88                 :            :                 }
      89                 :            :         }
      90                 :          0 : }
      91                 :            : 
      92                 :            : /*
      93                 :            :  * kdb_ftdump - Dump the ftrace log buffer
      94                 :            :  */
      95                 :          0 : static int kdb_ftdump(int argc, const char **argv)
      96                 :            : {
      97                 :            :         int skip_entries = 0;
      98                 :            :         long cpu_file;
      99                 :            :         char *cp;
     100                 :            :         int cnt;
     101                 :            :         int cpu;
     102                 :            : 
     103                 :          0 :         if (argc > 2)
     104                 :            :                 return KDB_ARGCOUNT;
     105                 :            : 
     106                 :          0 :         if (argc) {
     107                 :          0 :                 skip_entries = simple_strtol(argv[1], &cp, 0);
     108                 :          0 :                 if (*cp)
     109                 :            :                         skip_entries = 0;
     110                 :            :         }
     111                 :            : 
     112                 :          0 :         if (argc == 2) {
     113                 :          0 :                 cpu_file = simple_strtol(argv[2], &cp, 0);
     114                 :          0 :                 if (*cp || cpu_file >= NR_CPUS || cpu_file < 0 ||
     115                 :            :                     !cpu_online(cpu_file))
     116                 :            :                         return KDB_BADINT;
     117                 :            :         } else {
     118                 :            :                 cpu_file = RING_BUFFER_ALL_CPUS;
     119                 :            :         }
     120                 :            : 
     121                 :          0 :         kdb_trap_printk++;
     122                 :            : 
     123                 :          0 :         trace_init_global_iter(&iter);
     124                 :          0 :         iter.buffer_iter = buffer_iter;
     125                 :            : 
     126                 :          0 :         for_each_tracing_cpu(cpu) {
     127                 :          0 :                 atomic_inc(&per_cpu_ptr(iter.trace_buffer->data, cpu)->disabled);
     128                 :            :         }
     129                 :            : 
     130                 :            :         /* A negative skip_entries means skip all but the last entries */
     131                 :          0 :         if (skip_entries < 0) {
     132                 :          0 :                 if (cpu_file == RING_BUFFER_ALL_CPUS)
     133                 :          0 :                         cnt = trace_total_entries(NULL);
     134                 :            :                 else
     135                 :          0 :                         cnt = trace_total_entries_cpu(NULL, cpu_file);
     136                 :          0 :                 skip_entries = max(cnt + skip_entries, 0);
     137                 :            :         }
     138                 :            : 
     139                 :          0 :         ftrace_dump_buf(skip_entries, cpu_file);
     140                 :            : 
     141                 :          0 :         for_each_tracing_cpu(cpu) {
     142                 :          0 :                 atomic_dec(&per_cpu_ptr(iter.trace_buffer->data, cpu)->disabled);
     143                 :            :         }
     144                 :            : 
     145                 :          0 :         kdb_trap_printk--;
     146                 :            : 
     147                 :          0 :         return 0;
     148                 :            : }
     149                 :            : 
     150                 :          3 : static __init int kdb_ftrace_register(void)
     151                 :            : {
     152                 :          3 :         kdb_register_flags("ftdump", kdb_ftdump, "[skip_#entries] [cpu]",
     153                 :            :                             "Dump ftrace log; -skip dumps last #entries", 0,
     154                 :            :                             KDB_ENABLE_ALWAYS_SAFE);
     155                 :          3 :         return 0;
     156                 :            : }
     157                 :            : 
     158                 :            : late_initcall(kdb_ftrace_register);